Tamarin Tracing LIR Dictionary

Here's a big list of all the Intermediate Representation(IR) instructions and what they represent. The IR in general is very close to machine instructions, hence the name Low IR(LIR). A few things to note: All data is wrapped in a 64 bit word, which is an intel defined quadword. The bits 0-31 represent the actual data. Bits 32-63 represent the type information. Heres a little
mapping for the type integer:

             63            51   47              31               15             0
int 1 11111111111 1000 ............... iiiiiiiiiiiiiiii iiiiiiiiiiiiiiii

_lirNames[LIR_imm] = "imm "; // Seems signed 8 bit int
_lirNames[LIR_imm32] = "int "; // 32bit signed integer
_lirNames[LIR_immq] = "quad "; // 64 bit integer

_lirNames[LIR_trace] = "trace"; //indicates the start of a trace, used to terminate the assembler loop
_lirNames[LIR_skip] = "skip "; //used to skip over a section of raw data within a trace. For example the SideExit record attached to a guard.
_lirNames[LIR_tramp] = "tramp"; // trampoline, used to refer to a previous LIR expression more than 255 instructions away. see LIns.oprnd1() for an example of dereferencing LIR operands through a trampoline.

Refers to the end of a loop, and signals the trace to jump back to the loop header.
_lirNames[LIR_loop] = "loop ";

These refer to trace guard/exit instructions. These are preceded by some LIR comparisoni nstruction.
_lirNames[LIR_x] = "x "; // Exit the trace always
_lirNames[LIR_xt] = "xt "; // Exit the trace if true
_lirNames[LIR_xf] = "xf "; // Exit the trace if false

Standard Comparison Operators:
_lirNames[LIR_eq] = "eq ";
_lirNames[LIR_lt] = "lt ";
_lirNames[LIR_le] = "le ";
_lirNames[LIR_gt] = "gt ";
_lirNames[LIR_ge] = "ge ";

Comparison Operators. The U stands for unsigned integer comparison.
_lirNames[LIR_ult] = "ult ";
_lirNames[LIR_ule] = "ule ";
_lirNames[LIR_ugt] = "ugt ";
_lirNames[LIR_uge] = "uge ";
_lirNames[LIR_neg] = "neg ";

Basic Math:
_lirNames[LIR_add] = "add ";
_lirNames[LIR_sub] = "sub ";
_lirNames[LIR_mul] = "mul ";

Binary Operators:
_lirNames[LIR_and] = "and ";
_lirNames[LIR_or] = "or ";
_lirNames[LIR_xor] = "xor ";
_lirNames[LIR_not] = "not ";

Shift operators:
_lirNames[LIR_lsh] = "lsh "; // << _lirNames[LIR_rsh] = "rsh "; // >>
_lirNames[LIR_ush] = "ush "; // >>> Shift in a 0 regardless

The q stuff is interesting.
_lirNames[LIR_qjoin] = "qjoin";

_lirNames[LIR_qlo] = "qlo ";
_lirNames[LIR_qhi] = "qhi ";

These are 64 bit quadwords. The hi represents bits 32-63 and qlo represents bits 0-31. Qjoin takes two operands and affixes one to the hi bits, and the other to the low bits. Qlo/Qhi gets the corresponding portion of a given quad word.

The F stands for floating point.
_lirNames[LIR_fneg] = "fneg ";
_lirNames[LIR_fadd] = "fadd ";
_lirNames[LIR_fsub] = "fsub ";
_lirNames[LIR_fmul] = "fmul ";
_lirNames[LIR_fdiv] = "fdiv ";

Conversion. I is integer, F is float. U is unsigned integer.
_lirNames[LIR_i2f] = "i2f ";
_lirNames[LIR_u2f] = "u2f ";

Loads/stores. Non-volatile refers to something that always has to be loaded, and cannot be optimized away.
_lirNames[LIR_ld] = "ld "; // load
_lirNames[LIR_ldc] = "ldc "; // non-volatile load
_lirNames[LIR_ldc8] = "ldc8 "; // load 8 bit word
_lirNames[LIR_cmov] = "cmov "; // Conditional move
_lirNames[LIR_ldq] = "ldq "; // load quad word

These actually store with immedate displacement. LIR_st/sti are used for storing anything, the data width is determined by the LIR expression being stored.
_lirNames[LIR_st] = "st ";
_lirNames[LIR_sti] = "sti ";

_lirNames[LIR_arg] = "arg "; // Arguments prior to a call
_lirNames[LIR_in] = "in "; // No idea

A call is self explanatory. A callh is somewhat confusing. Callh is used after a call to a function that returns a "Box::RetType". Ret type is an uint64. Callh then moves the "hi" portion, that is bits 32-63 into a given register. This represents the return type as the type information of any given data is in 32-63.
_lirNames[LIR_call] = "call ";
_lirNames[LIR_callh] = "callh";

When I figure these out, i'll let you know. Farg and Fcall refer to an argument being a floating point value, and that the result of a fcall is a floating point value.
_lirNames[LIR_farg] = "farg ";
_lirNames[LIR_fcall] = "fcall";

* Items that are italicized are fixes. Thanks Edwin!