1 ========================================
2 Machine IR (MIR) Format Reference Manual
3 ========================================
9 This is a work in progress.
14 This document is a reference manual for the Machine IR (MIR) serialization
15 format. MIR is a human readable serialization format that is used to represent
16 LLVM's :ref:`machine specific intermediate representation
17 <machine code representation>`.
19 The MIR serialization format is designed to be used for testing the code
20 generation passes in LLVM.
25 The MIR serialization format uses a YAML container. YAML is a standard
26 data serialization language, and the full YAML language spec can be read at
28 <http://www.yaml.org/spec/1.2/spec.html#Introduction>`_.
30 A MIR file is split up into a series of `YAML documents`_. The first document
31 can contain an optional embedded LLVM IR module, and the rest of the documents
32 contain the serialized machine functions.
34 .. _YAML documents: http://www.yaml.org/spec/1.2/spec.html#id2800132
42 When the first YAML document contains a `YAML block literal string`_, the MIR
43 parser will treat this string as an LLVM assembly language string that
44 represents an embedded LLVM IR module.
45 Here is an example of a YAML document that contains an LLVM module:
50 define i32 @inc(i32* %x) {
52 %0 = load i32, i32* %x
59 .. _YAML block literal string: http://www.yaml.org/spec/1.2/spec.html#id2795688
64 The remaining YAML documents contain the machine functions. This is an example
65 of such YAML document:
71 tracksRegLiveness: true
78 %eax = MOV32rm %rdi, 1, _, 0, _
79 %eax = INC32r killed %eax, implicit-def dead %eflags
80 MOV32mr killed %rdi, 1, _, 0, _, %eax
84 The document above consists of attributes that represent the various
85 properties and data structures in a machine function.
87 The attribute ``name`` is required, and its value should be identical to the
88 name of a function that this machine function is based on.
90 The attribute ``body`` is a `YAML block literal string`_. Its value represents
91 the function's machine basic blocks and their machine instructions.
93 Machine Instructions Format Reference
94 =====================================
96 The machine basic blocks and their instructions are represented using a custom,
97 human readable serialization language. This language is used in the
98 `YAML block literal string`_ that corresponds to the machine function's body.
100 A source string that uses this language contains a list of machine basic
101 blocks, which are described in the section below.
106 A machine basic block is defined in a single block definition source construct
107 that contains the block's ID.
108 The example below defines two blocks that have an ID of zero and one:
117 A machine basic block can also have a name. It should be specified after the ID
118 in the block's definition:
122 bb.0.entry: ; This block's name is "entry"
125 The block's name should be identical to the name of the IR block that this
126 machine block is based on.
131 The machine basic blocks are identified by their ID numbers. Individual
132 blocks are referenced using the following syntax:
148 The machine basic block's successors have to be specified before any of the
154 successors: %bb.1.then, %bb.2.else
161 The branch weights can be specified in brackets after the successor blocks.
162 The example below defines a block that has two successors with branch weights
168 successors: %bb.1.then(32), %bb.2.else(16)
175 The machine basic block's live in registers have to be specified before any of
183 The list of live in registers and successors can be empty. The language also
184 allows multiple live in register and successor lists - they are combined into
185 one list by the parser.
187 Miscellaneous Attributes
188 ^^^^^^^^^^^^^^^^^^^^^^^^
190 The attributes ``IsAddressTaken``, ``IsLandingPad`` and ``Alignment`` can be
191 specified in brackets after the block's definition:
195 bb.0.entry (address-taken):
199 bb.3(landing-pad, align 4):
202 .. TODO: Describe the way the reference to an unnamed LLVM IR block can be
208 A machine instruction is composed of a name,
209 :ref:`machine operands <machine-operands>`,
210 :ref:`instruction flags <instruction-flags>`, and machine memory operands.
212 The instruction's name is usually specified before the operands. The example
213 below shows an instance of the X86 ``RETQ`` instruction with a single machine
220 However, if the machine instruction has one or more explicitly defined register
221 operands, the instruction's name has to be specified after them. The example
222 below shows an instance of the AArch64 ``LDPXpost`` instruction with three
223 defined register operands:
227 %sp, %fp, %lr = LDPXpost %sp, 2
229 The instruction names are serialized using the exact definitions from the
230 target's ``*InstrInfo.td`` files, and they are case sensitive. This means that
231 similar instruction names like ``TSTri`` and ``tSTRi`` represent different
232 machine instructions.
234 .. _instruction-flags:
239 The flag ``frame-setup`` can be specified before the instruction's name:
243 %fp = frame-setup ADDXri %sp, 0, 0
250 Registers are one of the key primitives in the machine instructions
251 serialization language. They are primarly used in the
252 :ref:`register machine operands <register-operands>`,
253 but they can also be used in a number of other places, like the
254 :ref:`basic block's live in list <bb-liveins>`.
256 The physical registers are identified by their name. They use the following
263 The example below shows three X86 physical registers:
271 The virtual registers are identified by their ID number. They use the following
284 The null registers are represented using an underscore ('``_``'). They can also be
285 represented using a '``%noreg``' named register, although the former syntax
288 .. _machine-operands:
293 There are seventeen different kinds of machine operands, and all of them, except
294 the ``MCSymbol`` operand, can be serialized. The ``MCSymbol`` operands are
295 just printed out - they can't be parsed back yet.
300 The immediate machine operands are untyped, 64-bit signed integers. The
301 example below shows an instance of the X86 ``MOV32ri`` instruction that has an
302 immediate machine operand ``-42``:
308 .. TODO: Describe the CIMM (Rare) and FPIMM immediate operands.
310 .. _register-operands:
315 The :ref:`register <registers>` primitive is used to represent the register
316 machine operands. The register operands can also have optional
317 :ref:`register flags <register-flags>`,
318 a subregister index, and a reference to the tied register operand.
319 The full syntax of a register operand is shown below:
323 [<flags>] <register> [ :<subregister-idx-name> ] [ (tied-def <tied-op>) ]
325 This example shows an instance of the X86 ``XOR32rr`` instruction that has
326 5 register operands with different register flags:
330 dead %eax = XOR32rr undef %eax, undef %eax, implicit-def dead %eflags, implicit-def %al
337 The table below shows all of the possible register flags along with the
338 corresponding internal ``llvm::RegState`` representation:
347 - ``RegState::Implicit``
350 - ``RegState::ImplicitDefine``
353 - ``RegState::Define``
362 - ``RegState::Undef``
365 - ``RegState::InternalRead``
367 * - ``early-clobber``
368 - ``RegState::EarlyClobber``
371 - ``RegState::Debug``
373 .. TODO: Describe the parsers default behaviour when optional YAML attributes
375 .. TODO: Describe the syntax for the bundled instructions.
376 .. TODO: Describe the syntax for virtual register YAML definitions.
377 .. TODO: Describe the syntax of the subregisters.
378 .. TODO: Describe the machine function's YAML flag attributes.
379 .. TODO: Describe the syntax for the global value, external symbol and register
380 mask machine operands.
381 .. TODO: Describe the frame information YAML mapping.
382 .. TODO: Describe the syntax of the stack object machine operands and their
384 .. TODO: Describe the syntax of the constant pool machine operands and their
386 .. TODO: Describe the syntax of the jump table machine operands and their
388 .. TODO: Describe the syntax of the block address machine operands.
389 .. TODO: Describe the syntax of the CFI index machine operands.
390 .. TODO: Describe the syntax of the metadata machine operands, and the
391 instructions debug location attribute.
392 .. TODO: Describe the syntax of the target index machine operands.
393 .. TODO: Describe the syntax of the register live out machine operands.
394 .. TODO: Describe the syntax of the machine memory operands.