GitLab

replacing most uses of HashMap with LinkedHashMap. This will reduce (if not eliminate) undeterminism in the compilation.
Copied LinkedHashMap implementation to local so that I can implement encode/decode and other necessary methods

1. asm call do not use all argument registers (otherwise it will keep
them alive)
2. spilling a register that is used and defined in one instruction will
result in creating one new temporary, instead of two
3. spilling now deals with floating point
4. SELECT with int8 is implemented using conditional jump (cmov cannot
take reg8)
5. postcall convention now deals correctly with fp return values
6. reg alloc conservative() was wrong in a few commits ago, fixed it
7. in liveness analysis, when finding a move between a temp and a
register, find the color for the register (such as RAX for EAX)

currently mov constant as imm to a GPR, then mov from GPR
to xmm. A better approach should be put the immediate in memroy,
and load it

when we add interefence between %a and %edi, we also add %a with %rdi
because we cannot assign rdi to a

changed a condition on coealescing. Fixed a bug in spilling rewrite.
Currently test_extern_Func is broken

was using nalgebra::DMatrix to implement a graph

1. see vm/vm_options.rs for usage and default values
2. added mu_fastimpl_new_with_opts under vm/api/api_impl/muvm.rs

1. compiler knows all the registers
2. but only 64bits register is a color (for reg alloc)
3. backend records the length of GPR for each operand during instruction
selection
4. after reg alloc, when replacing temp with a color, find corresponding
GPR for the length recorded before

1. grow/shrink frame size in the pro/epilogue. Note: though we removed
push/pop for unused callee saved registers, we still reserve frame space
for them. Because we generate spill on frame before we know exactly how
large a space is. The solution is to make spill locations patchable.
2. control flow will combine branches in switch instruction if they all
target the same destination.

now

(for callee saved regs, we insert push/pop before reg alloc. and
after allocation, remove unnecessary ones)

we never go back to previous passes, since it is not necessary

convention(stack args), and need to optimize spill1 code

now we have 4 passes: fast_inst_sel, fast_reg_alloc, followed
by slow_inst_sel and slow_reg_alloc. This might make the
compilation pipeline more linear

partially serialize compiled function into bootimage

cannot get it work by loading it dynamically. Rust mangles mu runtime
functions in test executable (even if I stated #[no_mangle]), so the
dynamic library cannot call mu runtime functions (symbols not found)

(for blocks created during instruction selection)