Documentation

• Integral addition.
• First boolean flag: check for unsigned overflow.
• Second boolean flag: check for signed overflow.
• If the checks fail, then the result is poisoned.

Floating point addition.

• Integral subtraction.
• First boolean flag: check for unsigned overflow.
• Second boolean flag: check for signed overflow.
• If the checks fail, then the result is poisoned.

Floating point subtraction.

• Integral multiplication.
• First boolean flag: check for unsigned overflow.
• Second boolean flag: check for signed overflow.
• If the checks fail, then the result is poisoned.

Floating point multiplication.

• Integral unsigned division.
• Boolean flag: check for exact result.
• If the check fails, then the result is poisoned.

• Integral signed division.
• Boolean flag: check for exact result.
• If the check fails, then the result is poisoned.

Floating point division.

Integral unsigned reminder resulting from unsigned division. Division by 0 is undefined.

• Integral signded reminder resulting from signed division.
• The sign of the reminder matches the divident (first parameter).
• Division by 0 is undefined.

• Floating point reminder resulting from floating point division.
• The reminder has the same sign as the divident (first parameter).

• Shift left.
• First bool flag: check for unsigned overflow (i.e., shifted out a 1).

• Second bool flag: check for signed overflow (i.e., shifted out something that does not match the sign bit)

  If a check fails, then the result is poisoned.

  The value of the second parameter must be strictly less than the nubmer of bits in the first parameter, otherwise the result is undefined.

• Logical shift right.
• The boolean is for exact check: posion the result, if we shift out a 1 bit (i.e., had to round).

The value of the second parameter must be strictly less than the nubmer of bits in the first parameter, otherwise the result is undefined.

• Arithmetic shift right.
• The boolean is for exact check: posion the result, if we shift out a 1 bit (i.e., had to round).

The value of the second parameter must be strictly less than the nubmer of bits in the first parameter, otherwise the result is undefined.

• Return from function with the given value.
• Ends basic block.

• Return from function.
• Ends basic block.

• Binary arithmetic operation, both operands have the same type.
• Middle of basic block.
• The result is the same as parameters.

• Binary bit-vector operation, both operands have the same type.
• Middle of basic block.
• The result is the same as parameters.

• Convert a value from one type to another.
• Middle of basic block.
• The result matches the 3rd parameter.

• Call a function. The boolean is tail-call hint (XXX: needs to be updated)
• Middle of basic block.
• The result is as indicated by the provided type.

• Allocated space on the stack: type of elements; how many elements (1 if Nothing); required alignment.
• Middle of basic block.
• Returns a pointer to hold the given number of elemets.

• Read a value from the given address: address to read from; assumptions about alignment of the given pointer.
• Middle of basic block.
• Returns a value of type matching the pointer.

• Write a value to memory: value to store; pointer to location where to store; assumptions about the alignment of the given pointer.
• Middle of basic block.
• Effect.

• Compare two integral values.
• Middle of basic block.
• Returns a boolean value.

• Compare two floating point values.
• Middle of basic block.
• Returns a boolean value.

• Join point for an SSA value: we get one value per predecessor basic block.
• Middle of basic block.
• Returns a value of the specified type.

• "Get element pointer", compute the address of a field in a structure: inbounds check (value poisoned if this fails); pointer to parent strucutre; path to a sub-component of a strucutre.
• Middle of basic block.
• Returns the address of the requiested member.

The types in path are the types of the index, not the fields.

The indexes are in units of a fields (i.e., the first element in a struct is field 0, the next one is 1, etc., regardless of the size of the fields in bytes).

• Local if-then-else; the first argument is boolean, if true pick the 2nd argument, otherwise evaluate to the 3rd.
• Middle of basic block.
• Returns either the 2nd or the 3rd argument.

• Get the value of a member of an aggregate value: the first argument is an aggregate value (not a pointer!), the second is a path of indexes, similar to the one in GEP.
• Middle of basic block.
• Returns the given member of the aggregate value.

• Set the value for a member of an aggregate value: the first argument is the value to insert, the second is the aggreagate value to be modified.
• Middle of basic block.
• Returns an updated aggregate value.

• Get an element from a vector: the first argument is a vector, the second an index.
• Middle of basic block.
• Returns the element at the given positoin.

• Modify an element of a vector: the first argument is the vector, the second the value to be inserted, the third is the index where to insert the value.
• Middle of basic block.
• Returns an updated vector.

• Jump to the given basic block.
• Ends basic block.

• Conditional jump: if the value is true jump to the first basic block, otherwise jump to the second.
• Ends basic block.

Comment

No defined sematics, we should not get to here.

• Multi-way branch: the first value determines the direction of the branch, the label is a default direction, if the value does not appear in the jump table, the last argument is the jump table.
• Ends basic block.