95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1 ========================================
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2 Machine IR (MIR) Format Reference Manual
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
3 ========================================
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
4
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
5 .. contents::
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
6 :local:
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
7
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
8 .. warning::
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
9 This is a work in progress.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
10
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
11 Introduction
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
12 ============
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
13
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
14 This document is a reference manual for the Machine IR (MIR) serialization
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
15 format. MIR is a human readable serialization format that is used to represent
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
16 LLVM's :ref:`machine specific intermediate representation
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
17 <machine code representation>`.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
18
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
19 The MIR serialization format is designed to be used for testing the code
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
20 generation passes in LLVM.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
21
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
22 Overview
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
23 ========
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
24
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
25 The MIR serialization format uses a YAML container. YAML is a standard
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
26 data serialization language, and the full YAML language spec can be read at
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
27 `yaml.org
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
28 <http://www.yaml.org/spec/1.2/spec.html#Introduction>`_.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
29
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
30 A MIR file is split up into a series of `YAML documents`_. The first document
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
31 can contain an optional embedded LLVM IR module, and the rest of the documents
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
32 contain the serialized machine functions.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
33
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
34 .. _YAML documents: http://www.yaml.org/spec/1.2/spec.html#id2800132
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
35
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
36 MIR Testing Guide
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
37 =================
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
38
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
39 You can use the MIR format for testing in two different ways:
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
40
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
41 - You can write MIR tests that invoke a single code generation pass using the
|
121
|
42 ``-run-pass`` option in llc.
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
43
|
121
|
44 - You can use llc's ``-stop-after`` option with existing or new LLVM assembly
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
45 tests and check the MIR output of a specific code generation pass.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
46
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
47 Testing Individual Code Generation Passes
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
48 -----------------------------------------
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
49
|
121
|
50 The ``-run-pass`` option in llc allows you to create MIR tests that invoke just
|
|
51 a single code generation pass. When this option is used, llc will parse an
|
|
52 input MIR file, run the specified code generation pass(es), and output the
|
|
53 resulting MIR code.
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
54
|
121
|
55 You can generate an input MIR file for the test by using the ``-stop-after`` or
|
|
56 ``-stop-before`` option in llc. For example, if you would like to write a test
|
|
57 for the post register allocation pseudo instruction expansion pass, you can
|
|
58 specify the machine copy propagation pass in the ``-stop-after`` option, as it
|
|
59 runs just before the pass that we are trying to test:
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
60
|
121
|
61 ``llc -stop-after=machine-cp bug-trigger.ll > test.mir``
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
62
|
147
|
63 If the same pass is run multiple times, a run index can be included
|
|
64 after the name with a comma.
|
|
65
|
|
66 ``llc -stop-after=dead-mi-elimination,1 bug-trigger.ll > test.mir``
|
|
67
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
68 After generating the input MIR file, you'll have to add a run line that uses
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
69 the ``-run-pass`` option to it. In order to test the post register allocation
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
70 pseudo instruction expansion pass on X86-64, a run line like the one shown
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
71 below can be used:
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
72
|
121
|
73 ``# RUN: llc -o - %s -mtriple=x86_64-- -run-pass=postrapseudos | FileCheck %s``
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
74
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
75 The MIR files are target dependent, so they have to be placed in the target
|
121
|
76 specific test directories (``lib/CodeGen/TARGETNAME``). They also need to
|
|
77 specify a target triple or a target architecture either in the run line or in
|
|
78 the embedded LLVM IR module.
|
|
79
|
|
80 Simplifying MIR files
|
|
81 ^^^^^^^^^^^^^^^^^^^^^
|
|
82
|
|
83 The MIR code coming out of ``-stop-after``/``-stop-before`` is very verbose;
|
|
84 Tests are more accessible and future proof when simplified:
|
|
85
|
|
86 - Use the ``-simplify-mir`` option with llc.
|
|
87
|
|
88 - Machine function attributes often have default values or the test works just
|
|
89 as well with default values. Typical candidates for this are: `alignment:`,
|
|
90 `exposesReturnsTwice`, `legalized`, `regBankSelected`, `selected`.
|
|
91 The whole `frameInfo` section is often unnecessary if there is no special
|
|
92 frame usage in the function. `tracksRegLiveness` on the other hand is often
|
|
93 necessary for some passes that care about block livein lists.
|
|
94
|
|
95 - The (global) `liveins:` list is typically only interesting for early
|
|
96 instruction selection passes and can be removed when testing later passes.
|
|
97 The per-block `liveins:` on the other hand are necessary if
|
|
98 `tracksRegLiveness` is true.
|
|
99
|
|
100 - Branch probability data in block `successors:` lists can be dropped if the
|
|
101 test doesn't depend on it. Example:
|
|
102 `successors: %bb.1(0x40000000), %bb.2(0x40000000)` can be replaced with
|
|
103 `successors: %bb.1, %bb.2`.
|
|
104
|
|
105 - MIR code contains a whole IR module. This is necessary because there are
|
|
106 no equivalents in MIR for global variables, references to external functions,
|
|
107 function attributes, metadata, debug info. Instead some MIR data references
|
|
108 the IR constructs. You can often remove them if the test doesn't depend on
|
|
109 them.
|
|
110
|
|
111 - Alias Analysis is performed on IR values. These are referenced by memory
|
|
112 operands in MIR. Example: `:: (load 8 from %ir.foobar, !alias.scope !9)`.
|
|
113 If the test doesn't depend on (good) alias analysis the references can be
|
|
114 dropped: `:: (load 8)`
|
|
115
|
|
116 - MIR blocks can reference IR blocks for debug printing, profile information
|
|
117 or debug locations. Example: `bb.42.myblock` in MIR references the IR block
|
|
118 `myblock`. It is usually possible to drop the `.myblock` reference and simply
|
|
119 use `bb.42`.
|
|
120
|
|
121 - If there are no memory operands or blocks referencing the IR then the
|
|
122 IR function can be replaced by a parameterless dummy function like
|
|
123 `define @func() { ret void }`.
|
|
124
|
|
125 - It is possible to drop the whole IR section of the MIR file if it only
|
|
126 contains dummy functions (see above). The .mir loader will create the
|
|
127 IR functions automatically in this case.
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
128
|
134
|
129 .. _limitations:
|
|
130
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
131 Limitations
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
132 -----------
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
133
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
134 Currently the MIR format has several limitations in terms of which state it
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
135 can serialize:
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
136
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
137 - The target-specific state in the target-specific ``MachineFunctionInfo``
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
138 subclasses isn't serialized at the moment.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
139
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
140 - The target-specific ``MachineConstantPoolValue`` subclasses (in the ARM and
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
141 SystemZ backends) aren't serialized at the moment.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
142
|
147
|
143 - The ``MCSymbol`` machine operands don't support temporary or local symbols.
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
144
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
145 - A lot of the state in ``MachineModuleInfo`` isn't serialized - only the CFI
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
146 instructions and the variable debug information from MMI is serialized right
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
147 now.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
148
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
149 These limitations impose restrictions on what you can test with the MIR format.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
150 For now, tests that would like to test some behaviour that depends on the state
|
147
|
151 of temporary or local ``MCSymbol`` operands or the exception handling state in
|
|
152 MMI, can't use the MIR format. As well as that, tests that test some behaviour
|
|
153 that depends on the state of the target specific ``MachineFunctionInfo`` or
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
154 ``MachineConstantPoolValue`` subclasses can't use the MIR format at the moment.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
155
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
156 High Level Structure
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
157 ====================
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
158
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
159 .. _embedded-module:
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
160
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
161 Embedded Module
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
162 ---------------
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
163
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
164 When the first YAML document contains a `YAML block literal string`_, the MIR
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
165 parser will treat this string as an LLVM assembly language string that
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
166 represents an embedded LLVM IR module.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
167 Here is an example of a YAML document that contains an LLVM module:
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
168
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
169 .. code-block:: llvm
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
170
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
171 define i32 @inc(i32* %x) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
172 entry:
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
173 %0 = load i32, i32* %x
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
174 %1 = add i32 %0, 1
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
175 store i32 %1, i32* %x
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
176 ret i32 %1
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
177 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
178
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
179 .. _YAML block literal string: http://www.yaml.org/spec/1.2/spec.html#id2795688
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
180
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
181 Machine Functions
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
182 -----------------
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
183
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
184 The remaining YAML documents contain the machine functions. This is an example
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
185 of such YAML document:
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
186
|
120
|
187 .. code-block:: text
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
188
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
189 ---
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
190 name: inc
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
191 tracksRegLiveness: true
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
192 liveins:
|
147
|
193 - { reg: '$rdi' }
|
|
194 callSites:
|
|
195 - { bb: 0, offset: 3, fwdArgRegs:
|
|
196 - { arg: 0, reg: '$edi' } }
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
197 body: |
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
198 bb.0.entry:
|
147
|
199 liveins: $rdi
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
200
|
147
|
201 $eax = MOV32rm $rdi, 1, _, 0, _
|
|
202 $eax = INC32r killed $eax, implicit-def dead $eflags
|
|
203 MOV32mr killed $rdi, 1, _, 0, _, $eax
|
|
204 CALL64pcrel32 @foo <regmask...>
|
|
205 RETQ $eax
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
206 ...
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
207
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
208 The document above consists of attributes that represent the various
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
209 properties and data structures in a machine function.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
210
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
211 The attribute ``name`` is required, and its value should be identical to the
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
212 name of a function that this machine function is based on.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
213
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
214 The attribute ``body`` is a `YAML block literal string`_. Its value represents
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
215 the function's machine basic blocks and their machine instructions.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
216
|
147
|
217 The attribute ``callSites`` is a representation of call site information which
|
|
218 keeps track of call instructions and registers used to transfer call arguments.
|
|
219
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
220 Machine Instructions Format Reference
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
221 =====================================
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
222
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
223 The machine basic blocks and their instructions are represented using a custom,
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
224 human readable serialization language. This language is used in the
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
225 `YAML block literal string`_ that corresponds to the machine function's body.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
226
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
227 A source string that uses this language contains a list of machine basic
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
228 blocks, which are described in the section below.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
229
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
230 Machine Basic Blocks
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
231 --------------------
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
232
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
233 A machine basic block is defined in a single block definition source construct
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
234 that contains the block's ID.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
235 The example below defines two blocks that have an ID of zero and one:
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
236
|
120
|
237 .. code-block:: text
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
238
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
239 bb.0:
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
240 <instructions>
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
241 bb.1:
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
242 <instructions>
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
243
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
244 A machine basic block can also have a name. It should be specified after the ID
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
245 in the block's definition:
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
246
|
120
|
247 .. code-block:: text
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
248
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
249 bb.0.entry: ; This block's name is "entry"
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
250 <instructions>
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
251
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
252 The block's name should be identical to the name of the IR block that this
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
253 machine block is based on.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
254
|
134
|
255 .. _block-references:
|
|
256
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
257 Block References
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
258 ^^^^^^^^^^^^^^^^
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
259
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
260 The machine basic blocks are identified by their ID numbers. Individual
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
261 blocks are referenced using the following syntax:
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
262
|
120
|
263 .. code-block:: text
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
264
|
134
|
265 %bb.<id>
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
266
|
134
|
267 Example:
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
268
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
269 .. code-block:: llvm
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
270
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
271 %bb.0
|
134
|
272
|
|
273 The following syntax is also supported, but the former syntax is preferred for
|
|
274 block references:
|
|
275
|
|
276 .. code-block:: text
|
|
277
|
|
278 %bb.<id>[.<name>]
|
|
279
|
|
280 Example:
|
|
281
|
|
282 .. code-block:: llvm
|
|
283
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
284 %bb.1.then
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
285
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
286 Successors
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
287 ^^^^^^^^^^
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
288
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
289 The machine basic block's successors have to be specified before any of the
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
290 instructions:
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
291
|
120
|
292 .. code-block:: text
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
293
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
294 bb.0.entry:
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
295 successors: %bb.1.then, %bb.2.else
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
296 <instructions>
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
297 bb.1.then:
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
298 <instructions>
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
299 bb.2.else:
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
300 <instructions>
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
301
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
302 The branch weights can be specified in brackets after the successor blocks.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
303 The example below defines a block that has two successors with branch weights
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
304 of 32 and 16:
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
305
|
120
|
306 .. code-block:: text
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
307
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
308 bb.0.entry:
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
309 successors: %bb.1.then(32), %bb.2.else(16)
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
310
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
311 .. _bb-liveins:
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
312
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
313 Live In Registers
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
314 ^^^^^^^^^^^^^^^^^
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
315
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
316 The machine basic block's live in registers have to be specified before any of
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
317 the instructions:
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
318
|
120
|
319 .. code-block:: text
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
320
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
321 bb.0.entry:
|
147
|
322 liveins: $edi, $esi
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
323
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
324 The list of live in registers and successors can be empty. The language also
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
325 allows multiple live in register and successor lists - they are combined into
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
326 one list by the parser.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
327
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
328 Miscellaneous Attributes
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
329 ^^^^^^^^^^^^^^^^^^^^^^^^
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
330
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
331 The attributes ``IsAddressTaken``, ``IsLandingPad`` and ``Alignment`` can be
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
332 specified in brackets after the block's definition:
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
333
|
120
|
334 .. code-block:: text
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
335
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
336 bb.0.entry (address-taken):
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
337 <instructions>
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
338 bb.2.else (align 4):
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
339 <instructions>
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
340 bb.3(landing-pad, align 4):
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
341 <instructions>
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
342
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
343 .. TODO: Describe the way the reference to an unnamed LLVM IR block can be
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
344 preserved.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
345
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
346 Machine Instructions
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
347 --------------------
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
348
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
349 A machine instruction is composed of a name,
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
350 :ref:`machine operands <machine-operands>`,
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
351 :ref:`instruction flags <instruction-flags>`, and machine memory operands.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
352
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
353 The instruction's name is usually specified before the operands. The example
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
354 below shows an instance of the X86 ``RETQ`` instruction with a single machine
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
355 operand:
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
356
|
120
|
357 .. code-block:: text
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
358
|
147
|
359 RETQ $eax
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
360
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
361 However, if the machine instruction has one or more explicitly defined register
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
362 operands, the instruction's name has to be specified after them. The example
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
363 below shows an instance of the AArch64 ``LDPXpost`` instruction with three
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
364 defined register operands:
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
365
|
120
|
366 .. code-block:: text
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
367
|
147
|
368 $sp, $fp, $lr = LDPXpost $sp, 2
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
369
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
370 The instruction names are serialized using the exact definitions from the
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
371 target's ``*InstrInfo.td`` files, and they are case sensitive. This means that
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
372 similar instruction names like ``TSTri`` and ``tSTRi`` represent different
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
373 machine instructions.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
374
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
375 .. _instruction-flags:
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
376
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
377 Instruction Flags
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
378 ^^^^^^^^^^^^^^^^^
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
379
|
134
|
380 The flag ``frame-setup`` or ``frame-destroy`` can be specified before the
|
|
381 instruction's name:
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
382
|
120
|
383 .. code-block:: text
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
384
|
147
|
385 $fp = frame-setup ADDXri $sp, 0, 0
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
386
|
134
|
387 .. code-block:: text
|
|
388
|
147
|
389 $x21, $x20 = frame-destroy LDPXi $sp
|
134
|
390
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
391 .. _registers:
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
392
|
134
|
393 Bundled Instructions
|
|
394 ^^^^^^^^^^^^^^^^^^^^
|
|
395
|
|
396 The syntax for bundled instructions is the following:
|
|
397
|
|
398 .. code-block:: text
|
|
399
|
147
|
400 BUNDLE implicit-def $r0, implicit-def $r1, implicit $r2 {
|
|
401 $r0 = SOME_OP $r2
|
|
402 $r1 = ANOTHER_OP internal $r0
|
134
|
403 }
|
|
404
|
|
405 The first instruction is often a bundle header. The instructions between ``{``
|
|
406 and ``}`` are bundled with the first instruction.
|
|
407
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
408 Registers
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
409 ---------
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
410
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
411 Registers are one of the key primitives in the machine instructions
|
147
|
412 serialization language. They are primarily used in the
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
413 :ref:`register machine operands <register-operands>`,
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
414 but they can also be used in a number of other places, like the
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
415 :ref:`basic block's live in list <bb-liveins>`.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
416
|
147
|
417 The physical registers are identified by their name and by the '$' prefix sigil.
|
|
418 They use the following syntax:
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
419
|
120
|
420 .. code-block:: text
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
421
|
147
|
422 $<name>
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
423
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
424 The example below shows three X86 physical registers:
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
425
|
120
|
426 .. code-block:: text
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
427
|
147
|
428 $eax
|
|
429 $r15
|
|
430 $eflags
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
431
|
147
|
432 The virtual registers are identified by their ID number and by the '%' sigil.
|
|
433 They use the following syntax:
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
434
|
120
|
435 .. code-block:: text
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
436
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
437 %<id>
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
438
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
439 Example:
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
440
|
120
|
441 .. code-block:: text
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
442
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
443 %0
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
444
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
445 The null registers are represented using an underscore ('``_``'). They can also be
|
147
|
446 represented using a '``$noreg``' named register, although the former syntax
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
447 is preferred.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
448
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
449 .. _machine-operands:
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
450
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
451 Machine Operands
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
452 ----------------
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
453
|
147
|
454 There are seventeen different kinds of machine operands, and all of them can be
|
|
455 serialized.
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
456
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
457 Immediate Operands
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
458 ^^^^^^^^^^^^^^^^^^
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
459
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
460 The immediate machine operands are untyped, 64-bit signed integers. The
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
461 example below shows an instance of the X86 ``MOV32ri`` instruction that has an
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
462 immediate machine operand ``-42``:
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
463
|
120
|
464 .. code-block:: text
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
465
|
147
|
466 $eax = MOV32ri -42
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
467
|
134
|
468 An immediate operand is also used to represent a subregister index when the
|
|
469 machine instruction has one of the following opcodes:
|
|
470
|
|
471 - ``EXTRACT_SUBREG``
|
|
472
|
|
473 - ``INSERT_SUBREG``
|
|
474
|
|
475 - ``REG_SEQUENCE``
|
|
476
|
|
477 - ``SUBREG_TO_REG``
|
|
478
|
|
479 In case this is true, the Machine Operand is printed according to the target.
|
|
480
|
|
481 For example:
|
|
482
|
|
483 In AArch64RegisterInfo.td:
|
|
484
|
|
485 .. code-block:: text
|
|
486
|
|
487 def sub_32 : SubRegIndex<32>;
|
|
488
|
|
489 If the third operand is an immediate with the value ``15`` (target-dependent
|
|
490 value), based on the instruction's opcode and the operand's index the operand
|
|
491 will be printed as ``%subreg.sub_32``:
|
|
492
|
|
493 .. code-block:: text
|
|
494
|
|
495 %1:gpr64 = SUBREG_TO_REG 0, %0, %subreg.sub_32
|
|
496
|
|
497 For integers > 64bit, we use a special machine operand, ``MO_CImmediate``,
|
|
498 which stores the immediate in a ``ConstantInt`` using an ``APInt`` (LLVM's
|
|
499 arbitrary precision integers).
|
|
500
|
|
501 .. TODO: Describe the FPIMM immediate operands.
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
502
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
503 .. _register-operands:
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
504
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
505 Register Operands
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
506 ^^^^^^^^^^^^^^^^^
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
507
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
508 The :ref:`register <registers>` primitive is used to represent the register
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
509 machine operands. The register operands can also have optional
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
510 :ref:`register flags <register-flags>`,
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
511 :ref:`a subregister index <subregister-indices>`,
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
512 and a reference to the tied register operand.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
513 The full syntax of a register operand is shown below:
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
514
|
120
|
515 .. code-block:: text
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
516
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
517 [<flags>] <register> [ :<subregister-idx-name> ] [ (tied-def <tied-op>) ]
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
518
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
519 This example shows an instance of the X86 ``XOR32rr`` instruction that has
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
520 5 register operands with different register flags:
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
521
|
120
|
522 .. code-block:: text
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
523
|
147
|
524 dead $eax = XOR32rr undef $eax, undef $eax, implicit-def dead $eflags, implicit-def $al
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
525
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
526 .. _register-flags:
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
527
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
528 Register Flags
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
529 ~~~~~~~~~~~~~~
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
530
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
531 The table below shows all of the possible register flags along with the
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
532 corresponding internal ``llvm::RegState`` representation:
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
533
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
534 .. list-table::
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
535 :header-rows: 1
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
536
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
537 * - Flag
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
538 - Internal Value
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
539
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
540 * - ``implicit``
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
541 - ``RegState::Implicit``
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
542
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
543 * - ``implicit-def``
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
544 - ``RegState::ImplicitDefine``
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
545
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
546 * - ``def``
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
547 - ``RegState::Define``
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
548
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
549 * - ``dead``
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
550 - ``RegState::Dead``
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
551
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
552 * - ``killed``
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
553 - ``RegState::Kill``
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
554
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
555 * - ``undef``
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
556 - ``RegState::Undef``
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
557
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
558 * - ``internal``
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
559 - ``RegState::InternalRead``
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
560
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
561 * - ``early-clobber``
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
562 - ``RegState::EarlyClobber``
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
563
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
564 * - ``debug-use``
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
565 - ``RegState::Debug``
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
566
|
134
|
567 * - ``renamable``
|
|
568 - ``RegState::Renamable``
|
|
569
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
570 .. _subregister-indices:
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
571
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
572 Subregister Indices
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
573 ~~~~~~~~~~~~~~~~~~~
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
574
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
575 The register machine operands can reference a portion of a register by using
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
576 the subregister indices. The example below shows an instance of the ``COPY``
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
577 pseudo instruction that uses the X86 ``sub_8bit`` subregister index to copy 8
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
578 lower bits from the 32-bit virtual register 0 to the 8-bit virtual register 1:
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
579
|
120
|
580 .. code-block:: text
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
581
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
582 %1 = COPY %0:sub_8bit
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
583
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
584 The names of the subregister indices are target specific, and are typically
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
585 defined in the target's ``*RegisterInfo.td`` file.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
586
|
134
|
587 Constant Pool Indices
|
|
588 ^^^^^^^^^^^^^^^^^^^^^
|
|
589
|
|
590 A constant pool index (CPI) operand is printed using its index in the
|
|
591 function's ``MachineConstantPool`` and an offset.
|
|
592
|
|
593 For example, a CPI with the index 1 and offset 8:
|
|
594
|
|
595 .. code-block:: text
|
|
596
|
|
597 %1:gr64 = MOV64ri %const.1 + 8
|
|
598
|
|
599 For a CPI with the index 0 and offset -12:
|
|
600
|
|
601 .. code-block:: text
|
|
602
|
|
603 %1:gr64 = MOV64ri %const.0 - 12
|
|
604
|
|
605 A constant pool entry is bound to a LLVM IR ``Constant`` or a target-specific
|
|
606 ``MachineConstantPoolValue``. When serializing all the function's constants the
|
|
607 following format is used:
|
|
608
|
|
609 .. code-block:: text
|
|
610
|
|
611 constants:
|
|
612 - id: <index>
|
|
613 value: <value>
|
|
614 alignment: <alignment>
|
|
615 isTargetSpecific: <target-specific>
|
|
616
|
|
617 where ``<index>`` is a 32-bit unsigned integer, ``<value>`` is a `LLVM IR Constant
|
|
618 <https://www.llvm.org/docs/LangRef.html#constants>`_, alignment is a 32-bit
|
|
619 unsigned integer, and ``<target-specific>`` is either true or false.
|
|
620
|
|
621 Example:
|
|
622
|
|
623 .. code-block:: text
|
|
624
|
|
625 constants:
|
|
626 - id: 0
|
|
627 value: 'double 3.250000e+00'
|
|
628 alignment: 8
|
|
629 - id: 1
|
|
630 value: 'g-(LPC0+8)'
|
|
631 alignment: 4
|
|
632 isTargetSpecific: true
|
|
633
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
634 Global Value Operands
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
635 ^^^^^^^^^^^^^^^^^^^^^
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
636
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
637 The global value machine operands reference the global values from the
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
638 :ref:`embedded LLVM IR module <embedded-module>`.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
639 The example below shows an instance of the X86 ``MOV64rm`` instruction that has
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
640 a global value operand named ``G``:
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
641
|
120
|
642 .. code-block:: text
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
643
|
147
|
644 $rax = MOV64rm $rip, 1, _, @G, _
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
645
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
646 The named global values are represented using an identifier with the '@' prefix.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
647 If the identifier doesn't match the regular expression
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
648 `[-a-zA-Z$._][-a-zA-Z$._0-9]*`, then this identifier must be quoted.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
649
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
650 The unnamed global values are represented using an unsigned numeric value with
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
651 the '@' prefix, like in the following examples: ``@0``, ``@989``.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
652
|
134
|
653 Target-dependent Index Operands
|
|
654 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
|
655
|
|
656 A target index operand is a target-specific index and an offset. The
|
|
657 target-specific index is printed using target-specific names and a positive or
|
|
658 negative offset.
|
|
659
|
|
660 For example, the ``amdgpu-constdata-start`` is associated with the index ``0``
|
|
661 in the AMDGPU backend. So if we have a target index operand with the index 0
|
|
662 and the offset 8:
|
|
663
|
|
664 .. code-block:: text
|
|
665
|
147
|
666 $sgpr2 = S_ADD_U32 _, target-index(amdgpu-constdata-start) + 8, implicit-def _, implicit-def _
|
134
|
667
|
|
668 Jump-table Index Operands
|
|
669 ^^^^^^^^^^^^^^^^^^^^^^^^^
|
|
670
|
|
671 A jump-table index operand with the index 0 is printed as following:
|
|
672
|
|
673 .. code-block:: text
|
|
674
|
147
|
675 tBR_JTr killed $r0, %jump-table.0
|
134
|
676
|
|
677 A machine jump-table entry contains a list of ``MachineBasicBlocks``. When serializing all the function's jump-table entries, the following format is used:
|
|
678
|
|
679 .. code-block:: text
|
|
680
|
|
681 jumpTable:
|
|
682 kind: <kind>
|
|
683 entries:
|
|
684 - id: <index>
|
|
685 blocks: [ <bbreference>, <bbreference>, ... ]
|
|
686
|
|
687 where ``<kind>`` is describing how the jump table is represented and emitted (plain address, relocations, PIC, etc.), and each ``<index>`` is a 32-bit unsigned integer and ``blocks`` contains a list of :ref:`machine basic block references <block-references>`.
|
|
688
|
|
689 Example:
|
|
690
|
|
691 .. code-block:: text
|
|
692
|
|
693 jumpTable:
|
|
694 kind: inline
|
|
695 entries:
|
|
696 - id: 0
|
|
697 blocks: [ '%bb.3', '%bb.9', '%bb.4.d3' ]
|
|
698 - id: 1
|
|
699 blocks: [ '%bb.7', '%bb.7', '%bb.4.d3', '%bb.5' ]
|
|
700
|
|
701 External Symbol Operands
|
|
702 ^^^^^^^^^^^^^^^^^^^^^^^^^
|
|
703
|
147
|
704 An external symbol operand is represented using an identifier with the ``&``
|
134
|
705 prefix. The identifier is surrounded with ""'s and escaped if it has any
|
|
706 special non-printable characters in it.
|
|
707
|
|
708 Example:
|
|
709
|
|
710 .. code-block:: text
|
|
711
|
147
|
712 CALL64pcrel32 &__stack_chk_fail, csr_64, implicit $rsp, implicit-def $rsp
|
134
|
713
|
|
714 MCSymbol Operands
|
|
715 ^^^^^^^^^^^^^^^^^
|
|
716
|
|
717 A MCSymbol operand is holding a pointer to a ``MCSymbol``. For the limitations
|
|
718 of this operand in MIR, see :ref:`limitations <limitations>`.
|
|
719
|
|
720 The syntax is:
|
|
721
|
|
722 .. code-block:: text
|
|
723
|
|
724 EH_LABEL <mcsymbol Ltmp1>
|
|
725
|
|
726 CFIIndex Operands
|
|
727 ^^^^^^^^^^^^^^^^^
|
|
728
|
|
729 A CFI Index operand is holding an index into a per-function side-table,
|
|
730 ``MachineFunction::getFrameInstructions()``, which references all the frame
|
|
731 instructions in a ``MachineFunction``. A ``CFI_INSTRUCTION`` may look like it
|
|
732 contains multiple operands, but the only operand it contains is the CFI Index.
|
|
733 The other operands are tracked by the ``MCCFIInstruction`` object.
|
|
734
|
|
735 The syntax is:
|
|
736
|
|
737 .. code-block:: text
|
|
738
|
147
|
739 CFI_INSTRUCTION offset $w30, -16
|
134
|
740
|
|
741 which may be emitted later in the MC layer as:
|
|
742
|
|
743 .. code-block:: text
|
|
744
|
|
745 .cfi_offset w30, -16
|
|
746
|
|
747 IntrinsicID Operands
|
|
748 ^^^^^^^^^^^^^^^^^^^^
|
|
749
|
|
750 An Intrinsic ID operand contains a generic intrinsic ID or a target-specific ID.
|
|
751
|
|
752 The syntax for the ``returnaddress`` intrinsic is:
|
|
753
|
|
754 .. code-block:: text
|
|
755
|
147
|
756 $x0 = COPY intrinsic(@llvm.returnaddress)
|
134
|
757
|
|
758 Predicate Operands
|
|
759 ^^^^^^^^^^^^^^^^^^
|
|
760
|
|
761 A Predicate operand contains an IR predicate from ``CmpInst::Predicate``, like
|
|
762 ``ICMP_EQ``, etc.
|
|
763
|
|
764 For an int eq predicate ``ICMP_EQ``, the syntax is:
|
|
765
|
|
766 .. code-block:: text
|
|
767
|
|
768 %2:gpr(s32) = G_ICMP intpred(eq), %0, %1
|
|
769
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
770 .. TODO: Describe the parsers default behaviour when optional YAML attributes
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
771 are missing.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
772 .. TODO: Describe the syntax for virtual register YAML definitions.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
773 .. TODO: Describe the machine function's YAML flag attributes.
|
134
|
774 .. TODO: Describe the syntax for the register mask machine operands.
|
95
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
775 .. TODO: Describe the frame information YAML mapping.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
776 .. TODO: Describe the syntax of the stack object machine operands and their
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
777 YAML definitions.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
778 .. TODO: Describe the syntax of the block address machine operands.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
779 .. TODO: Describe the syntax of the metadata machine operands, and the
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
780 instructions debug location attribute.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
781 .. TODO: Describe the syntax of the register live out machine operands.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
782 .. TODO: Describe the syntax of the machine memory operands.
|