Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / llvm / 9f6487563c0ea0e80b8c18a0e68fed4ade43f269 / . / docs / AliasAnalysis.html
blob: 1cbd5a17992f851166cb17401548fc86711470be [file] [log] [blame]
Chris Lattner9f648752003-03-04 19:37:49 +0000[diff] [blame^]1<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
2<html><head><title>Alias Analysis Infrastructure in LLVM</title></head>
3
4<body bgcolor=white>
5
6<table width="100%" bgcolor="#330077" border=0 cellpadding=4 cellspacing=0>
7<tr><td>&nbsp; <font size=+3 color="#EEEEFF" face="Georgia,Palatino,Times,Roman"><b>Alias Analysis Infrastructure in LLVM</b></font></td>
8</tr></table>
9
10<ol>
11 <li><a href="#introduction">Introduction</a>
12
13 <li><a href="#overview">AliasAnalysis Overview</a>
14 <ul>
15 <li><a href="#pointers">Representation of Pointers</a>
16 <li><a href="#MustMayNo">Must, May, and No Alias Responses</a>
17 <li><a href="#ModRefInfo">The <tt>getModRefInfo</tt> methods</a>
18 </ul>
19
20 <li><a href="#writingnew">Writing a new AliasAnalysis Implementation</a>
21 <ul>
22 <li><a href="#passsubclasses">Different Pass styles</a>
23 <li><a href="#requiredcalls">Required initialization calls</a>
24 <li><a href="#interfaces">Interfaces which may be specified</a>
25 <li><a href="#chaining">The AliasAnalysis chaining behavior</a>
26 <li><a href="#implefficiency">Efficiency Issues</a>
27 </ul>
28
29 <li><a href="#using">Using AliasAnalysis results</a>
30 <ul>
31 <li><a href="#loadvn">Using the <tt>-load-vn</tt> Pass</a>
32 <li><a href="#ast">Using the <tt>AliasSetTracker</tt> class</a>
33 <li><a href="#direct">Using the AliasAnalysis interface directly</a>
34 </ul>
35 <li><a href="#tools">Helpful alias analysis related tools</a>
36 <ul>
37 <li><a href="#no-aa">The <tt>-no-aa</tt> pass</a>
38 <li><a href="#print-alias-sets">The <tt>-print-alias-sets</tt> pass</a>
39 <li><a href="#count-aa">The <tt>-count-aa</tt> pass</a>
40 <li><a href="#aa-eval">The <tt>-aa-eval</tt> pass</a>
41 </ul>
42 </ul>
43
44 <p><b>Written by <a href="mailto:sabre@nondot.org">Chris Lattner</a></b><p>
45</ol><p>
46
47
48
49<!-- *********************************************************************** -->
50<table width="100%" bgcolor="#330077" border=0 cellpadding=4 cellspacing=0>
51<tr><td align=center><font color="#EEEEFF" size=+2 face="Georgia,Palatino"><b>
52<a name="introduction">Introduction
53</b></font></td></tr></table><ul>
54<!-- *********************************************************************** -->
55
56Alias Analysis (or Pointer Analysis) is a technique which attempts to determine
57whether or not two pointers ever can point to the same object in memory.
58Traditionally, Alias Analyses respond to a query with either a <a
59href="#MustNoMay">Must, May, or No</a> alias response, indicating that two
60pointers do point to the same object, might point to the same object, or are
61known not to point to the same object.<p>
62
63The <a href="/doxygen/classAliasAnalysis.html">AliasAnalysis</a> class is the
64centerpiece of the LLVM Alias Analysis related infrastructure. This class is
65the common interface between clients of alias analysis information and the
66implementations providing it. In addition to simple alias analysis information,
67this class exposes Mod/Ref information from those implementations which can
68provide it, allowing for powerful analyses and transformations to work well
69together.<p>
70
71This document contains information neccesary to successfully implement this
72interface, use it, and to test both sides. It also explains some of the finer
73points about what exactly results mean. If you feel that something is unclear
74or should be added, please <a href="mailto:sabre@nondot.org">let me know</a>.<p>
75
76
77<!-- *********************************************************************** -->
78</ul><table width="100%" bgcolor="#330077" border=0 cellpadding=4 cellspacing=0>
79<tr><td align=center><font color="#EEEEFF" size=+2 face="Georgia,Palatino"><b>
80<a name="overview">AliasAnalysis Overview
81</b></font></td></tr></table><ul>
82<!-- *********************************************************************** -->
83
84The <a href="/doxygen/classAliasAnalysis.html">AliasAnalysis</a> class defines
85the interface that Alias Analysis implementations should support. This class
86exports two important enums: <tt>AliasResult</tt> and <tt>ModRefResult</tt>
87which represent the result of an alias query or a mod/ref query,
88respectively.<p>
89
90The AliasAnalysis interface exposes information about memory, represented in
91several different ways. In particular, memory objects are represented as a
92starting address and size, and function calls are represented as the actual
93<tt>call</tt> or <tt>invoke</tt> instructions that performs the call. The
94AliasAnalysis interface also exposes some helper methods which allow you to get
95mod/ref information for arbitrary instructions.<p>
96
97<!-- ======================================================================= -->
98</ul><table width="50%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
99<tr><td>&nbsp;</td><td width="100%">&nbsp;
100<font color="#EEEEFF" face="Georgia,Palatino"><b>
101<a name="pointers">Representation of Pointers
102</b></font></td></tr></table><ul>
103
104Most importantly, the AliasAnalysis class provides several methods which are
105used to query whether or not pointers alias, whether function calls can modify
106or read memory, etc.<p>
107
108Representing memory objects as a starting address and a size is critically
109important for precise Alias Analyses. For example, consider this (silly) C
110code:<p>
111
112<pre>
113 int i;
114 char C[2];
115 char A[10];
116 /* ... */
117 for (i = 0; i != 10; ++i) {
118 C[0] = A[i]; /* One byte store */
119 C[1] = A[9-i]; /* One byte store */
120 }
121</pre>
122
123In this case, the <tt>basicaa</tt> pass will disambiguate the stores to
124<tt>C[0]</tt> and <tt>C[1]</tt> because they are accesses to two distinct
125locations one byte apart, and the accesses are each one byte. In this case, the
126LICM pass can use store motion to remove the stores from the loop. In
127constrast, the following code:<p>
128
129<pre>
130 int i;
131 char C[2];
132 char A[10];
133 /* ... */
134 for (i = 0; i != 10; ++i) {
135 ((short*)C)[0] = A[i]; /* Two byte store! */
136 C[1] = A[9-i]; /* One byte store */
137 }
138</pre>
139
140In this case, the two stores to C do alias each other, because the access to the
141<tt>&amp;C[0]</tt> element is a two byte access. If size information wasn't
142available in the query, even the first case would have to conservatively assume
143that the accesses alias.<p>
144
145
146<!-- ======================================================================= -->
147</ul><table width="50%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
148<tr><td>&nbsp;</td><td width="100%">&nbsp;
149<font color="#EEEEFF" face="Georgia,Palatino"><b>
150<a name="MustMayNo">Must, May, and No Alias Responses
151</b></font></td></tr></table><ul>
152
153An Alias Analysis implementation can return one of three responses: MustAlias,
154MayAlias, and NoAlias. The No and May alias results are obvious: if the two
155pointers may never equal each other, return NoAlias, if they might, return
156MayAlias.<p>
157
158The Must Alias response is trickier though. In LLVM, the Must Alias response
159may only be returned if the two memory objects are guaranteed to always start at
160exactly the same location. If two memory objects overlap, but do not start at
161the same location, MayAlias must be returned.<p>
162
163
164<!-- ======================================================================= -->
165</ul><table width="50%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
166<tr><td>&nbsp;</td><td width="100%">&nbsp;
167<font color="#EEEEFF" face="Georgia,Palatino"><b>
168<a name="ModRefInfo">The <tt>getModRefInfo</tt> methods
169</b></font></td></tr></table><ul>
170
171The <tt>getModRefInfo</tt> methods return information about whether the
172execution of an instruction can read or modify a memory location. Mod/Ref
173information is always conservative: if an action <b>may</b> read a location, Ref
174is returned.<p>
175
176
177
178<!-- *********************************************************************** -->
179</ul><table width="100%" bgcolor="#330077" border=0 cellpadding=4 cellspacing=0>
180<tr><td align=center><font color="#EEEEFF" size=+2 face="Georgia,Palatino"><b>
181<a name="writingnew">Writing a new AliasAnalysis Implementation
182</b></font></td></tr></table><ul>
183<!-- *********************************************************************** -->
184
185Writing a new alias analysis implementation for LLVM is quite straight-forward.
186There are already several implementations that you can use for examples, and the
187following information should help fill in any details. For a minimal example,
188take a look at the <a href="/doxygen/structNoAA.html"><tt>no-aa</tt></a>
189implementation.<p>
190
191
192<!-- ======================================================================= -->
193</ul><table width="50%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
194<tr><td>&nbsp;</td><td width="100%">&nbsp;
195<font color="#EEEEFF" face="Georgia,Palatino"><b>
196<a name="passsubclasses">Different Pass styles
197</b></font></td></tr></table><ul>
198
199The first step to determining what type of <a href="WritingAnLLVMPass.html">LLVM
200pass</a> you need to use for your Alias Analysis. As is the case with most
201other analyses and transformations, the answer should be fairly obvious from
202what type of problem you are trying to solve:<p>
203
204<ol>
205<li>If you require interprocedural analysis, it should be a <tt>Pass</tt>.
206<li>If you are a global analysis, subclass <tt>FunctionPass</tt>.
207<li>If you are a local pass, subclass <tt>BasicBlockPass</tt>.
208<li>If you don't need to look at the program at all, subclass
209 <tt>ImmutablePass</tt>.
210</ol><p>
211
212In addition to the pass that you subclass, you should also inherit from the
213<tt>AliasAnalysis</tt> interface of course, and use the
214<tt>RegisterAnalysisGroup</tt> template to register as an implementation of
215<tt>AliasAnalysis</tt>.<p>
216
217
218<!-- ======================================================================= -->
219</ul><table width="50%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
220<tr><td>&nbsp;</td><td width="100%">&nbsp;
221<font color="#EEEEFF" face="Georgia,Palatino"><b>
222<a name="requiredcalls">Required initialization calls
223</b></font></td></tr></table><ul>
224
225Your subclass of AliasAnalysis is required to invoke two methods on the
226AliasAnalysis base class: <tt>getAnalysisUsage</tt> and
227<tt>InitializeAliasAnalysis</tt>. In particular, your implementation of
228<tt>getAnalysisUsage</tt> should explicitly call into the
229<tt>AliasAnalysis::getAnalysisUsage</tt> method in addition to doing any
230declaring any pass dependencies your pass has. Thus you should have something
231like this:<p>
232
233<pre>
234 void getAnalysisUsage(AnalysisUsage &amp;AU) const {
235 AliasAnalysis::getAnalysisUsage(AU);
236 <i>// declare your dependencies here.</i>
237 }
238</pre>
239
240Additionally, your must invoke the <tt>InitializeAliasAnalysis</tt> method from
241your analysis run method (<tt>run</tt> for a <tt>Pass</tt>,
242<tt>runOnFunction</tt> for a <tt>FunctionPass</tt>, <tt>runOnBasicBlock</tt> for
243a <tt>BasicBlockPass</tt>, or <tt>InitializeAliasAnalysis</tt> for an
244<tt>ImmutablePass</tt>). For example (as part of a <tt>Pass</tt>):<p>
245
246<pre>
247 bool run(Module &amp;M) {
248 InitializeAliasAnalysis(this);
249 <i>// Perform analysis here...</i>
250 return false;
251 }
252</pre>
253
254
255<!-- ======================================================================= -->
256</ul><table width="50%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
257<tr><td>&nbsp;</td><td width="100%">&nbsp;
258<font color="#EEEEFF" face="Georgia,Palatino"><b>
259<a name="interfaces">Interfaces which may be specified
260</b></font></td></tr></table><ul>
261
262All of the <a href="/doxygen/classAliasAnalysis.html">AliasAnalysis</a> virtual
263methods default to providing conservatively correct information (returning "May"
264Alias and "Mod/Ref" for alias and mod/ref queries respectively). Depending on
265the capabilities of the analysis you are implementing, you just override the
266interfaces you can improve.
267
268
269<!-- ======================================================================= -->
270</ul><table width="50%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
271<tr><td>&nbsp;</td><td width="100%">&nbsp;
272<font color="#EEEEFF" face="Georgia,Palatino"><b>
273<a name="chaining">The AliasAnalysis chaining behavior
274</b></font></td></tr></table><ul>
275
276With only two special exceptions (the <tt>basicaa</tt> and <a
277href="#no-aa"><tt>no-aa</tt></a> passes) every alias analysis pass should chain
278to another alias analysis implementation (for example, you could specify
279"<tt>-basic-aa -ds-aa -andersens-aa -licm</tt>" to get the maximum benefit from
280the three alias analyses). To do this, simply "Require" AliasAnalysis in your
281<tt>getAnalysisUsage</tt> method, and if you need to return a conservative
282MayAlias or Mod/Ref result, simply chain to a lower analysis.<p>
283
284
285<!-- ======================================================================= -->
286</ul><table width="50%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
287<tr><td>&nbsp;</td><td width="100%">&nbsp;
288<font color="#EEEEFF" face="Georgia,Palatino"><b>
289<a name="implefficiency">Efficiency Issues
290</b></font></td></tr></table><ul>
291
292From the LLVM perspective, the only thing you need to do to provide an efficient
293alias analysis is to make sure that alias analysis <b>queries</b> are serviced
294quickly. The actual calculation of the alias analysis results (the "run"
295method) is only performed once, but many (perhaps duplicate) queries may be
296performed. Because of this, try to move as much computation to the run method
297as possible (within reason).<p>
298
299
300<!-- *********************************************************************** -->
301</ul><table width="100%" bgcolor="#330077" border=0 cellpadding=4 cellspacing=0>
302<tr><td align=center><font color="#EEEEFF" size=+2 face="Georgia,Palatino"><b>
303<a name="using">Using AliasAnalysis results
304</b></font></td></tr></table><ul>
305<!-- *********************************************************************** -->
306
307There are several different ways to use alias analysis results. In order of
308preference, these are...<p>
309
310<!-- ======================================================================= -->
311</ul><table width="50%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
312<tr><td>&nbsp;</td><td width="100%">&nbsp;
313<font color="#EEEEFF" face="Georgia,Palatino"><b>
314<a name="loadvn">Using the <tt>-load-vn</tt> Pass
315</b></font></td></tr></table><ul>
316
317The <tt>load-vn</tt> pass uses alias analysis to provide value numbering
318information for <tt>load</tt> instructions. If your analysis or transformation
319can be modelled in a form that uses value numbering information, you don't have
320to do anything special to handle load instructions: just use the
321<tt>load-vn</tt> pass, which uses alias analysis.<p>
322
323
324<!-- ======================================================================= -->
325</ul><table width="50%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
326<tr><td>&nbsp;</td><td width="100%">&nbsp;
327<font color="#EEEEFF" face="Georgia,Palatino"><b>
328<a name="ast">Using the <tt>AliasSetTracker</tt> class
329</b></font></td></tr></table><ul>
330
331Many transformations need information about alias <b>sets</b> that are active in
332some scope, rather than information about pairwise aliasing. The <tt><a
333href="/doxygen/classAliasSetTracker.html">AliasSetTracker</a></tt> class is used
334to efficiently build these Alias Sets from the pairwise alias analysis
335information provided by the AliasAnalysis interface.<p>
336
337First you initialize the AliasSetTracker by use the "<tt>add</tt>" methods to
338add information about various potentially aliasing instructions in the scope you
339are interested in. Once all of the alias sets are completed, your pass should
340simply iterate through the constructed alias sets, using the AliasSetTracker
341<tt>begin()</tt>/<tt>end()</tt> methods.<p>
342
343The <tt>AliasSet</tt>s formed by the <tt>AliasSetTracker</tt> are guaranteed to
344be disjoint, calculate mod/ref information for the set, and keep track of
345whether or not all of the pointers in the set are Must aliases. The
346AliasSetTracker also makes sure that sets are properly folded due to call
347instructions, and can provide a list of pointers in each set.<p>
348
349As an example user of this, the <a href="/doxygen/structLICM.html">Loop
350Invariant Code Motion</a> pass uses AliasSetTrackers to build alias information
351about each loop nest. If an AliasSet in a loop is not modified, then all load
352instructions from that set may be hoisted out of the loop. If any alias sets
353are stored <b>and</b> are must alias sets, then the stores may be sunk to
354outside of the loop. Both of these transformations obviously only apply if the
355pointer argument is loop-invariant.<p>
356
357
358<!-- ======================================================================= -->
359</ul><table width="50%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
360<tr><td>&nbsp;</td><td width="100%">&nbsp;
361<font color="#EEEEFF" face="Georgia,Palatino"><b>
362<a name="direct">Using the AliasAnalysis interface directly
363</b></font></td></tr></table><ul>
364
365As a last resort, your pass could use the AliasAnalysis interface directly to
366service your pass. If you find the need to do this, please <a
367href="mailto:sabre@nondot.org">let me know</a> so I can see if something new
368needs to be added to LLVM.<p>
369
370
371<!-- *********************************************************************** -->
372</ul><table width="100%" bgcolor="#330077" border=0 cellpadding=4 cellspacing=0>
373<tr><td align=center><font color="#EEEEFF" size=+2 face="Georgia,Palatino"><b>
374<a name="tools">Helpful alias analysis related tools
375</b></font></td></tr></table><ul>
376<!-- *********************************************************************** -->
377
378If you're going to be working with the AliasAnalysis infrastructure, there are
379several nice tools that may be useful for you and are worth knowing about...<p>
380
381<!-- ======================================================================= -->
382</ul><table width="50%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
383<tr><td>&nbsp;</td><td width="100%">&nbsp;
384<font color="#EEEEFF" face="Georgia,Palatino"><b>
385<a name="no-aa">The <tt>-no-aa</tt> pass
386</b></font></td></tr></table><ul>
387
388The <tt>-no-aa</tt> analysis is just like what it sounds: an alias analysis that
389never returns any useful information. This pass can be useful if you think that
390alias analysis is doing something wrong and are trying to narrow down a problem.
391If you don't specify an alias analysis, the default will be to use the
392<tt>basicaa</tt> pass which does quite a bit of disambiguation on its own.<p>
393
394
395<!-- ======================================================================= -->
396</ul><table width="50%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
397<tr><td>&nbsp;</td><td width="100%">&nbsp;
398<font color="#EEEEFF" face="Georgia,Palatino"><b>
399<a name="print-alias-sets">The <tt>-print-alias-sets</tt> pass
400</b></font></td></tr></table><ul>
401
402The <tt>-print-alias-sets</tt> pass is exposed as part of the <tt>analyze</tt>
403tool to print out the Alias Sets formed by the <a
404href="#ast"><tt>AliasSetTracker</tt></a> class. This is useful if you're using
405the <tt>AliasSetTracker</tt>.<p>
406
407
408<!-- ======================================================================= -->
409</ul><table width="50%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
410<tr><td>&nbsp;</td><td width="100%">&nbsp;
411<font color="#EEEEFF" face="Georgia,Palatino"><b>
412<a name="count-aa">The <tt>-count-aa</tt> pass</a>
413</b></font></td></tr></table><ul>
414
415The <tt>-count-aa</tt> pass is useful to see how many queries a particular pass
416is making and what kinds of responses are returned by the alias analysis. An
417example usage is:<p>
418
419<pre>
420 $ opt -basicaa -count-aa -ds-aa -count-aa -licm
421</pre>
422
423Which will print out how many queries (and what responses are returned) by the
424<tt>-licm</tt> pass (of the <tt>-ds-aa</tt> pass) and how many queries are made
425of the <tt>-basicaa</tt> pass by the <tt>-ds-aa</tt> pass. This can be useful
426when evaluating an alias analysis for precision.<p>
427
428<!-- ======================================================================= -->
429</ul><table width="50%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
430<tr><td>&nbsp;</td><td width="100%">&nbsp;
431<font color="#EEEEFF" face="Georgia,Palatino"><b>
432<a name="aa-eval">The <tt>-aa-eval</tt> pass
433</b></font></td></tr></table><ul>
434
435The <tt>-aa-eval</tt> pass simply iterates through all pairs of pointers in a
436function and asks an alias analysis whether or not the pointers alias. This
437gives an indication of the precision of the alias analysis. Statistics are
438printed.<p>
439
440
441<!-- *********************************************************************** -->
442</ul>
443<!-- *********************************************************************** -->
444
445<hr><font size=-1>
446<address><a href="mailto:sabre@nondot.org">Chris Lattner</a></address>
447<!-- Created: Wed Feb 26 10:40:50 CST 2003 -->
448<!-- hhmts start -->
449Last modified: Tue Mar 4 13:36:53 CST 2003
450<!-- hhmts end -->
451</font></body></html>