Intro to the LLVM MC Project

History and Background

Primary MC Components

Building on these Primitive Components

1. It uses the Instruction Decoder to read machine code bytes in memory into an MCInst and determine instruction sizes.
2. It uses the Instruction Printer to print the textual form of the instruction to a buffer.
3. It uses the Instruction Parser to re-parse the textual form to find precise operand boundaries in the text and build a symbolic form of the operand.

$ echo "0xCD 0x21" | llvm-mc --disassemble -triple=x86_64-apple-darwin9
 int $33
$ echo "0 0" | llvm-mc --disassemble -triple=x86_64-apple-darwin9
 addb %al, (%rax)
$ echo "0 0" | llvm-mc --disassemble -triple=i386-apple-darwin9
 addb %al, (%eax)
$ echo "0x0f 0x01 0xc2" | llvm-mc --disassemble -triple=i386-apple-darwin9
 vmlaunch

$ llvm-mc foo.s -filetype=obj -o foo.o
$ echo "    invalid_inst _foo, %ebx" | llvm-mc -filetype=obj -o /dev/null
<stdin>:1:5: error: unrecognized instruction
    invalid_inst _foo, %ebx
    ^

$ llvm-mc foo.s -o bar.s
$ echo "addl %eax, %ebx" | llvm-mc -show-encoding -show-inst
 .section __TEXT,__text,regular,pure_instructions
 addl %eax, %ebx              ## encoding: [0x01,0xc3]
                                        ## <MCInst #66 ADD32rr
                                        ##  <MCOperand Reg:29>
                                        ##  <MCOperand Reg:29>
                                        ##  <MCOperand Reg:27>>
$ echo "xorl _foo, %ebx" | llvm-mc -show-encoding
 .section __TEXT,__text,regular,pure_instructions
 xorl _foo, %ebx              ## encoding: [0x33,0x1c,0x25,A,A,A,A]
                                        ##   fixup A - offset: 3, value: _foo, kind: FK_Data_4

$ clang foo.c -S -o foo.s

$ clang foo.c -c -o foo.o -integrated-as

$ cat t.c
int foo(int X) {
 __asm__ ("frob    %0" : "+r" (X));
 return X;
}
$ gcc t.c 
/var/folders/51/51Qw875vFdGa9KojoIi7Zk+++TM/-Tmp-//ccyXfgfZ.s:11:no such instruction: `frob %eax'
$ clang t.c
/var/folders/51/51Qw875vFdGa9KojoIi7Zk+++TM/-Tmp-/cc-4zimMn.s:15:no such instruction: `frob %eax'
clang: error: assembler command failed with exit code 1 (use -v to see invocation)
$ clang t.c -integrated-as
t.c:2:11: error: unrecognized instruction
        frob    %eax
        ^
<inline asm>:1:2: note: instantated into assembly here
 __asm__ ("frob    %0" : "+r" (X));
          ^
1 error generated.

Status and Open Projects!

1. All the clang-side work is done: the driver knows -integrated-as, the diagnostics subsystem can handle assembler errors, the code generator is fully switched over to use MCStreamer, etc.
2. The X86 and ARM disassemblers are in good shape and considered to be at or near production quality.
3. The X86 instruction printer is done for both AT&T and Intel Syntax.
4. The MC components have been designed to be object file independent (e.g. work for MachO, ELF, PE-COFF etc) but only have an implementation for MachO (used on Mac OS/X systems). Adding support for ELF and/or PE-COFF should be reasonably straight-forward.
5. The X86 AT&T-syntax assembly parser is missing some important features, e.g. forward/backward labels, support for inferring suffixes on instructions (e.g. add -> addl), macros etc. However, it is sufficiently advanced to reliably parse everything generated by the LLVM X86 backend. Adding these missing features should be quite straight-forward.
6. The X86 Intel-syntax assembly parser doesn't exist.
7. The ARM assembly parser is not complete (probably 50% to useful), and the instruction printer is about 50% refactored from the old-style printer.
8. The assembler backend works quite well and currently tries to produces bitwise identical object files to the system assembler on the Mac (to allow validating through "/usr/bin/cmp"). That said, it's algorithms aren't all performance tuned, so it could probably be substantially faster.
9. The old JIT code path is still alive in LLVM, it should be killed off once it is replaced with a new MC implementation. One win of this is that the JIT will support inline assembly :)