1464  1464  
1465  1465 

1466  1466  exponential notation (e.g. 1.23421e+2), or a more precise hexadecimal 
1467  notation (see below). Floating point constants must have a  
1468 


1467  notation (see below). The assembler requires the exact decimal value of⏎  
1468  a floatingpoint constant. For example, the assembler accepts 1.25 but  
1469  rejects 1.3 because 1.3 is a repeating decimal in binary. Floating point  
1470  constants must have a floating point type.  
1469  1471  
1470  1472 

1471  1473  
2189  2191  types. This instruction can also take vector versions 
2190  2192  of the values in which case the elements must be integers. 
2191  2193 
Semantics: 
2192 
The value produced is the signed integer quotient of the two operands 

2194 
The value produced is the signed integer quotient of the two operands rounded towards zero. ⏎ 

2193  2195 
Note that signed integer division and unsigned integer division are distinct 
2194  2196  operations; for unsigned integer division, use 'udiv'. 
2195  2197 
Division by zero leads to undefined behavior. Overflow also leads to 
2237  2239  of the values in which case the elements must be integers. 
2238  2240 
Semantics: 
2239  2241 
This instruction returns the unsigned integer remainder of a division. 
2240  This instruction always performs an unsigned division to get the remainder,  
2241 


2242  This instruction always performs an unsigned division to get the remainder.⏎  
2242  2243 
Note that unsigned integer remainder and signed integer remainder are 
2243  2244  distinct operations; for signed integer remainder, use 'srem'. 
2244  2245 
Taking the remainder of a division by zero leads to undefined behavior. 
2302  2303  identical types. This instruction can also take vector 
2303  2304  versions of floating point values. 
2304  2305 
Semantics: 
2305 
This instruction returns the remainder of a division. 

2306 
This instruction returns the remainder of a division.⏎ 

2307  The remainder has the same sign as the dividend.  
2306  2308 
Example: 
2307  2309 
<result> = frem float 4.0, %var ; yields {float}:result = 4.0 % %var 
2308  2310  
2315  2317 
Bitwise binary operators are used to do various forms of 
2316  2318  bittwiddling in a program. They are generally very efficient 
2317  2319  instructions and can commonly be strength reduced from other 
2318  instructions. They require two operands, execute an operation on them,  
2319  and produce a single value. The resulting value of the bitwise binary  
2320  operators is always the same type as its first operand.⏎  
2320  instructions. They require two operands of the same type, execute an operation on them,⏎  
2321  and produce a single value. The resulting value is the same type as its operands.  
2321  2322  
2322  2323  
2323  2324  
2340  2341  
2341  2342 
Semantics: 
2342  2343  
2343 
The value produced is var1 * 2^{var2}. If 

2344  var2 is (statically or dynamically) equal to or larger than the number  
2345  of bits in var1, the result is undefined.⏎  
2344 
The value produced is var1 * 2^{var2} mod 2^{n},⏎ 

2345  where n is the width of the result. If var2 is (statically or dynamically) negative or  
2346  equal to or larger than the number of bits in var1, the result is undefined.  
2346  2347  
2347  2348 
Example: 
2348  2349  <result> = shl i32 4, %var ; yields {i32}: 4 << %var 