llvm.org GIT mirror llvm / 5cda901
Sphinxify the lexicon doc. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@158813 91177308-0d34-0410-b5e6-96231b3b80d8 Bill Wendling 7 years ago
3 changed file(s) with 196 addition(s) and 295 deletion(s). Raw diff Collapse all Expand all
+0
-294
docs/Lexicon.html less more
None
1
2
3
4 The LLVM Lexicon
5
6
7
8 content="A glossary of terms used with the LLVM project.">
9
10
11

The LLVM Lexicon

12

NOTE: This document is a work in progress!

13
14

Table Of Contents

15
16
17
18
- A -
19
20 ADCE
21
22
- B -
23
24 BURS
25
26
- C -
27
28 CSE
29
30
- D -
31
32 DAG
33 Derived Pointer
34 DSA
35 DSE
36
37
- F -
38
39 FCA
40
41
- G -
42
43 GC
44
45
- I -
46
47 IPA
48 IPO
49 ISel
50
51
- L -
52
53 LCSSA
54 LICM
55 Load-VN
56 LTO
57
58
- M -
59
60 MC
61
62
- O -
63
64 Object Pointer
65
66
- P -
67
68 PRE
69
70
- R -
71
72 RAUW
73 Reassociation
74 Root
75 RPO
76
77
- S -
78
79 Safe Point
80 SCC
81 SCCP
82 SDISel
83 SRoA
84 Stack Map
85
86
87
88
89
90

Definitions

91
92
93
94

- A -

95
96
97
ADCE
98
Aggressive Dead Code Elimination
99
100
101
102

- B -

103
104
105
BURS
106
Bottom Up Rewriting System—A method of instruction selection for
107 code generation. An example is the
108 href="http://www.program-transformation.org/Transform/BURG">BURG tool.
109
110
111
112

- C -

113
114
115
CSE
116
Common Subexpression Elimination. An optimization that removes common
117 subexpression compuation. For example (a+b)*(a+b) has two
118 subexpressions that are the same: (a+b). This optimization would
119 perform the addition only once and then perform the multiply (but only if
120 it's compulationally correct/safe).
121
122
123
124

- D -

125
126
127
DAG
128
Directed Acyclic Graph
129
Derived Pointer
130
A pointer to the interior of an object, such that a garbage collector
131 is unable to use the pointer for reachability analysis. While a derived
132 pointer is live, the corresponding object pointer must be kept in a root,
133 otherwise the collector might free the referenced object. With copying
134 collectors, derived pointers pose an additional hazard that they may be
135 invalidated at any safe point. This term is used in
136 opposition to object pointer.
137
DSA
138
Data Structure Analysis
139
DSE
140
Dead Store Elimination
141
142
143
144

- F -

145
146
147
FCA
148
First Class Aggregate
149
150
151
152

- G -

153
154
155
GC
156
Garbage Collection. The practice of using reachability analysis instead
157 of explicit memory management to reclaim unused memory.
158
159
160
161

- H -

162
163
164
Heap
165
In garbage collection, the region of memory which is managed using
166 reachability analysis.
167
168
169
170

- I -

171
172
173
IPA
174
Inter-Procedural Analysis. Refers to any variety of code analysis that
175 occurs between procedures, functions or compilation units (modules).
176
IPO
177
Inter-Procedural Optimization. Refers to any variety of code
178 optimization that occurs between procedures, functions or compilation units
179 (modules).
180
ISel
181
Instruction Selection.
182
183
184
185

- L -

186
187
188
LCSSA
189
Loop-Closed Static Single Assignment Form
190
LICM
191
Loop Invariant Code Motion
192
Load-VN
193
Load Value Numbering
194
LTO
195
Link-Time Optimization
196
197
198
199

- M -

200
201
202
MC
203
Machine Code
204
205
206
207

- O -

208
209
210
Object Pointer
211
A pointer to an object such that the garbage collector is able to trace
212 references contained within the object. This term is used in opposition to
213 derived pointer.
214
215
216
217
218

- P -

219
220
221
PRE
222
Partial Redundancy Elimination
223
224
225
226
227

- R -

228
229
230
RAUW
An abbreviation for Replace
231 All Uses With. The functions User::replaceUsesOfWith(),
232 Value::replaceAllUsesWith(), and Constant::replaceUsesOfWithOnConstant()
233 implement the replacement of one Value with another by iterating over its
234 def/use chain and fixing up all of the pointers to point to the new value.
235 See also def/use chains.
236
237
Reassociation
Rearranging
238 associative expressions to promote better redundancy elimination and other
239 optimization. For example, changing (A+B-A) into (B+A-A), permitting it to
240 be optimized into (B+0) then (B).
241
Root
In garbage collection, a
242 pointer variable lying outside of the heap from which
243 the collector begins its reachability analysis. In the context of code
244 generation, "root" almost always refers to a "stack root" -- a local or
245 temporary variable within an executing function.
246
RPO
Reverse postorder
247
248
249
250
251

- S -

252
253
254
Safe Point
255
In garbage collection, it is necessary to identify stack
256 roots so that reachability analysis may proceed. It may be infeasible to
257 provide this information for every instruction, so instead the information
258 may is calculated only at designated safe points. With a copying collector,
259 derived pointers must not be retained across
260 safe points and object pointers must be
261 reloaded from stack roots.
262
SDISel
263
Selection DAG Instruction Selection.
264
SCC
265
Strongly Connected Component
266
SCCP
267
Sparse Conditional Constant Propagation
268
SRoA
269
Scalar Replacement of Aggregates
270
SSA
271
Static Single Assignment
272
Stack Map
273
In garbage collection, metadata emitted by the code generator which
274 identifies roots within the stack frame of an executing
275 function.
276
277
278
279
280
281
282
283 src="http://jigsaw.w3.org/css-validator/images/vcss-blue" alt="Valid CSS">
284 href="http://validator.w3.org/check/referer">
285 src="http://www.w3.org/Icons/valid-html401-blue" alt="Valid HTML 4.01">
286 href="http://llvm.org/">The LLVM Team
287 The LLVM Compiler Infrastructure
288 Last modified: $Date$
289
290
292
293
0 .. _lexicon:
1
2 ================
3 The LLVM Lexicon
4 ================
5
6 .. note::
7
8 This document is a work in progress!
9
10 Definitions
11 ===========
12
13 A
14 -
15
16 **ADCE**
17 Aggressive Dead Code Elimination
18
19 B
20 -
21
22 **BURS**
23
24 Bottom Up Rewriting System --- A method of instruction selection for code
25 generation. An example is the `BURG
26 `_ tool.
27
28 C
29 -
30
31 **CSE**
32 Common Subexpression Elimination. An optimization that removes common
33 subexpression compuation. For example ``(a+b)*(a+b)`` has two subexpressions
34 that are the same: ``(a+b)``. This optimization would perform the addition
35 only once and then perform the multiply (but only if it's compulationally
36 correct/safe).
37
38 D
39 -
40
41 **DAG**
42 Directed Acyclic Graph
43
44 .. _derived pointer:
45 .. _derived pointers:
46
47 **Derived Pointer**
48 A pointer to the interior of an object, such that a garbage collector is
49 unable to use the pointer for reachability analysis. While a derived pointer
50 is live, the corresponding object pointer must be kept in a root, otherwise
51 the collector might free the referenced object. With copying collectors,
52 derived pointers pose an additional hazard that they may be invalidated at
53 any `safe point`_. This term is used in opposition to `object pointer`_.
54
55 **DSA**
56 Data Structure Analysis
57
58 **DSE**
59 Dead Store Elimination
60
61 F
62 -
63
64 **FCA**
65 First Class Aggregate
66
67 G
68 -
69
70 **GC**
71 Garbage Collection. The practice of using reachability analysis instead of
72 explicit memory management to reclaim unused memory.
73
74 H
75 -
76
77 .. _heap:
78
79 **Heap**
80 In garbage collection, the region of memory which is managed using
81 reachability analysis.
82
83 I
84 -
85
86 **IPA**
87 Inter-Procedural Analysis. Refers to any variety of code analysis that
88 occurs between procedures, functions or compilation units (modules).
89
90 **IPO**
91 Inter-Procedural Optimization. Refers to any variety of code optimization
92 that occurs between procedures, functions or compilation units (modules).
93
94 **ISel**
95 Instruction Selection
96
97 L
98 -
99
100 **LCSSA**
101 Loop-Closed Static Single Assignment Form
102
103 **LICM**
104 Loop Invariant Code Motion
105
106 **Load-VN**
107 Load Value Numbering
108
109 **LTO**
110 Link-Time Optimization
111
112 M
113 -
114
115 **MC**
116 Machine Code
117
118 O
119 -
120 .. _object pointer:
121 .. _object pointers:
122
123 **Object Pointer**
124 A pointer to an object such that the garbage collector is able to trace
125 references contained within the object. This term is used in opposition to
126 `derived pointer`_.
127
128 P
129 -
130
131 **PRE**
132 Partial Redundancy Elimination
133
134 R
135 -
136
137 **RAUW**
138
139 Replace All Uses With. The functions ``User::replaceUsesOfWith()``,
140 ``Value::replaceAllUsesWith()``, and
141 ``Constant::replaceUsesOfWithOnConstant()`` implement the replacement of one
142 Value with another by iterating over its def/use chain and fixing up all of
143 the pointers to point to the new value. See
144 also `def/use chains `_.
145
146 **Reassociation**
147 Rearranging associative expressions to promote better redundancy elimination
148 and other optimization. For example, changing ``(A+B-A)`` into ``(B+A-A)``,
149 permitting it to be optimized into ``(B+0)`` then ``(B)``.
150
151 .. _roots:
152 .. _stack roots:
153
154 **Root**
155 In garbage collection, a pointer variable lying outside of the `heap`_ from
156 which the collector begins its reachability analysis. In the context of code
157 generation, "root" almost always refers to a "stack root" --- a local or
158 temporary variable within an executing function.
159
160 **RPO**
161 Reverse postorder
162
163 S
164 -
165
166 .. _safe point:
167
168 **Safe Point**
169 In garbage collection, it is necessary to identify `stack roots`_ so that
170 reachability analysis may proceed. It may be infeasible to provide this
171 information for every instruction, so instead the information may is
172 calculated only at designated safe points. With a copying collector,
173 `derived pointers`_ must not be retained across safe points and `object
174 pointers`_ must be reloaded from stack roots.
175
176 **SDISel**
177 Selection DAG Instruction Selection.
178
179 **SCC**
180 Strongly Connected Component
181
182 **SCCP**
183 Sparse Conditional Constant Propagation
184
185 **SRoA**
186 Scalar Replacement of Aggregates
187
188 **SSA**
189 Static Single Assignment
190
191 **Stack Map**
192 In garbage collection, metadata emitted by the code generator which
193 identifies `roots`_ within the stack frame of an executing function.
77
88 CommandGuide/index
99 FAQ
10 Lexicon
1011
1112 * `The LLVM Getting Started Guide `_
1213
6869
6970 Advice on packaging LLVM into a distribution.
7071
71 * `The LLVM Lexicon `_
72 * :ref:`lexicon`
7273
7374 Definition of acronyms, terms and concepts used in LLVM.
7475