.CIL File Format – Arithmetic and conversion

Introduction

Arithmetic instructions pop their operands from the evaluation stack and push the result. Each instruction is the same for every operand type; the type decides what it does. The operands of a binary instruction must be of the same kind (int32 with int32, int64 with int64, floating point with floating point), except that int32 and native int mix freely and give a native int, and a managed pointer plus or minus an integer is a pointer. The result is of the operand kind; there is no 8-bit or 16-bit arithmetic on the stack (smaller values were widened to int32 when loaded).

Exceptions and verifiability, for the whole page. Integer add, sub and mul wrap around on overflow and throw nothing; the .ovf forms throw OverflowException. Integer div and rem throw DivideByZeroException when the divisor is 0, and may throw ArithmeticException (an OverflowException is one) when the smallest integer is divided by −1; floating-point division by zero gives an infinity or NaN and throws nothing. Mixed or mismatched operand kinds are not verifiable. Pointer arithmetic on native int or unmanaged pointers is not verifiable.

Arithmetic, logic and shifts

Overflow-checked arithmetic

These work on integers only and throw instead of wrapping. The .un forms treat both operands as unsigned. C# emits them inside checked contexts.

Comparison

These compare two values and push 1 (true) or 0 (false) as an int32; a conditional branch does the same and jumps. For floats, any comparison with a NaN is false, except that the .un forms (“unordered”) are true when either operand is a NaN. For integers the .un forms compare as unsigned. Object references can be compared with ceq; cgt.un against null is how code tests that a reference is not null.

Conversion

A conv instruction pops a number and pushes it converted to the named type: i1, i2, i4, i8 are signed integers of 8 to 64 bits, u1 to u8 unsigned, i and u native-sized, r4 and r8 floating point. The result of a conversion to an integer of 32 bits or fewer is an int32 on the stack; i8 and u8 give an int64; i and u give a native int. Converting an integer to a narrower one keeps the low bits. Converting a float to an integer truncates toward zero, and the result is unspecified if the value is out of range. The .ovf forms throw OverflowException instead of truncating or leaving the result unspecified; the .un forms take the input as unsigned.

Not described

Known, not yet covered

• Floating-point precision: the specification lets the stack hold floats at a precision above double; how much each runtime keeps, and when it narrows, is not described.

Unknown

• Which exception each runtime throws for the smallest integer divided by −1 (the specification allows ArithmeticException); this page gives the specification’s wording.

Links