/Users/buildslave/jenkins/sharedspace/clang-stage2-coverage-R@2/llvm/include/llvm/Transforms/Utils/MemorySSAUpdater.h
Line | Count | Source |
1 | | //===- MemorySSAUpdater.h - Memory SSA Updater-------------------*- C++ -*-===// |
2 | | // |
3 | | // The LLVM Compiler Infrastructure |
4 | | // |
5 | | // This file is distributed under the University of Illinois Open Source |
6 | | // License. See LICENSE.TXT for details. |
7 | | // |
8 | | //===----------------------------------------------------------------------===// |
9 | | // |
10 | | // \file |
11 | | // \brief An automatic updater for MemorySSA that handles arbitrary insertion, |
12 | | // deletion, and moves. It performs phi insertion where necessary, and |
13 | | // automatically updates the MemorySSA IR to be correct. |
14 | | // While updating loads or removing instructions is often easy enough to not |
15 | | // need this, updating stores should generally not be attemped outside this |
16 | | // API. |
17 | | // |
18 | | // Basic API usage: |
19 | | // Create the memory access you want for the instruction (this is mainly so |
20 | | // we know where it is, without having to duplicate the entire set of create |
21 | | // functions MemorySSA supports). |
22 | | // Call insertDef or insertUse depending on whether it's a MemoryUse or a |
23 | | // MemoryDef. |
24 | | // That's it. |
25 | | // |
26 | | // For moving, first, move the instruction itself using the normal SSA |
27 | | // instruction moving API, then just call moveBefore, moveAfter,or moveTo with |
28 | | // the right arguments. |
29 | | // |
30 | | //===----------------------------------------------------------------------===// |
31 | | |
32 | | #ifndef LLVM_TRANSFORMS_UTILS_MEMORYSSAUPDATER_H |
33 | | #define LLVM_TRANSFORMS_UTILS_MEMORYSSAUPDATER_H |
34 | | |
35 | | #include "llvm/ADT/SmallPtrSet.h" |
36 | | #include "llvm/ADT/SmallVector.h" |
37 | | #include "llvm/IR/BasicBlock.h" |
38 | | #include "llvm/IR/Dominators.h" |
39 | | #include "llvm/IR/Module.h" |
40 | | #include "llvm/IR/OperandTraits.h" |
41 | | #include "llvm/IR/Type.h" |
42 | | #include "llvm/IR/Use.h" |
43 | | #include "llvm/IR/User.h" |
44 | | #include "llvm/IR/Value.h" |
45 | | #include "llvm/Pass.h" |
46 | | #include "llvm/Support/Casting.h" |
47 | | #include "llvm/Support/ErrorHandling.h" |
48 | | #include "llvm/Transforms/Utils/MemorySSA.h" |
49 | | |
50 | | namespace llvm { |
51 | | |
52 | | class Function; |
53 | | class Instruction; |
54 | | class MemoryAccess; |
55 | | class LLVMContext; |
56 | | class raw_ostream; |
57 | | |
58 | | class MemorySSAUpdater { |
59 | | private: |
60 | | MemorySSA *MSSA; |
61 | | SmallVector<MemoryPhi *, 8> InsertedPHIs; |
62 | | SmallPtrSet<BasicBlock *, 8> VisitedBlocks; |
63 | | |
64 | | public: |
65 | 1.38M | MemorySSAUpdater(MemorySSA *MSSA) : MSSA(MSSA) {} |
66 | | /// Insert a definition into the MemorySSA IR. RenameUses will rename any use |
67 | | /// below the new def block (and any inserted phis). RenameUses should be set |
68 | | /// to true if the definition may cause new aliases for loads below it. This |
69 | | /// is not the case for hoisting or sinking or other forms of code *movement*. |
70 | | /// It *is* the case for straight code insertion. |
71 | | /// For example: |
72 | | /// store a |
73 | | /// if (foo) { } |
74 | | /// load a |
75 | | /// |
76 | | /// Moving the store into the if block, and calling insertDef, does not |
77 | | /// require RenameUses. |
78 | | /// However, changing it to: |
79 | | /// store a |
80 | | /// if (foo) { store b } |
81 | | /// load a |
82 | | /// Where a mayalias b, *does* require RenameUses be set to true. |
83 | | void insertDef(MemoryDef *Def, bool RenameUses = false); |
84 | | void insertUse(MemoryUse *Use); |
85 | | void moveBefore(MemoryUseOrDef *What, MemoryUseOrDef *Where); |
86 | | void moveAfter(MemoryUseOrDef *What, MemoryUseOrDef *Where); |
87 | | void moveToPlace(MemoryUseOrDef *What, BasicBlock *BB, |
88 | | MemorySSA::InsertionPlace Where); |
89 | | |
90 | | // The below are utility functions. Other than creation of accesses to pass |
91 | | // to insertDef, and removeAccess to remove accesses, you should generally |
92 | | // not attempt to update memoryssa yourself. It is very non-trivial to get |
93 | | // the edge cases right, and the above calls already operate in near-optimal |
94 | | // time bounds. |
95 | | |
96 | | /// \brief Create a MemoryAccess in MemorySSA at a specified point in a block, |
97 | | /// with a specified clobbering definition. |
98 | | /// |
99 | | /// Returns the new MemoryAccess. |
100 | | /// This should be called when a memory instruction is created that is being |
101 | | /// used to replace an existing memory instruction. It will *not* create PHI |
102 | | /// nodes, or verify the clobbering definition. The insertion place is used |
103 | | /// solely to determine where in the memoryssa access lists the instruction |
104 | | /// will be placed. The caller is expected to keep ordering the same as |
105 | | /// instructions. |
106 | | /// It will return the new MemoryAccess. |
107 | | /// Note: If a MemoryAccess already exists for I, this function will make it |
108 | | /// inaccessible and it *must* have removeMemoryAccess called on it. |
109 | | MemoryAccess *createMemoryAccessInBB(Instruction *I, MemoryAccess *Definition, |
110 | | const BasicBlock *BB, |
111 | | MemorySSA::InsertionPlace Point); |
112 | | |
113 | | /// \brief Create a MemoryAccess in MemorySSA before or after an existing |
114 | | /// MemoryAccess. |
115 | | /// |
116 | | /// Returns the new MemoryAccess. |
117 | | /// This should be called when a memory instruction is created that is being |
118 | | /// used to replace an existing memory instruction. It will *not* create PHI |
119 | | /// nodes, or verify the clobbering definition. |
120 | | /// |
121 | | /// Note: If a MemoryAccess already exists for I, this function will make it |
122 | | /// inaccessible and it *must* have removeMemoryAccess called on it. |
123 | | MemoryUseOrDef *createMemoryAccessBefore(Instruction *I, |
124 | | MemoryAccess *Definition, |
125 | | MemoryUseOrDef *InsertPt); |
126 | | MemoryUseOrDef *createMemoryAccessAfter(Instruction *I, |
127 | | MemoryAccess *Definition, |
128 | | MemoryAccess *InsertPt); |
129 | | |
130 | | /// \brief Remove a MemoryAccess from MemorySSA, including updating all |
131 | | /// definitions and uses. |
132 | | /// This should be called when a memory instruction that has a MemoryAccess |
133 | | /// associated with it is erased from the program. For example, if a store or |
134 | | /// load is simply erased (not replaced), removeMemoryAccess should be called |
135 | | /// on the MemoryAccess for that store/load. |
136 | | void removeMemoryAccess(MemoryAccess *); |
137 | | |
138 | | private: |
139 | | // Move What before Where in the MemorySSA IR. |
140 | | template <class WhereType> |
141 | | void moveTo(MemoryUseOrDef *What, BasicBlock *BB, WhereType Where); |
142 | | MemoryAccess *getPreviousDef(MemoryAccess *); |
143 | | MemoryAccess *getPreviousDefInBlock(MemoryAccess *); |
144 | | MemoryAccess *getPreviousDefFromEnd(BasicBlock *); |
145 | | MemoryAccess *getPreviousDefRecursive(BasicBlock *); |
146 | | MemoryAccess *recursePhi(MemoryAccess *Phi); |
147 | | template <class RangeType> |
148 | | MemoryAccess *tryRemoveTrivialPhi(MemoryPhi *Phi, RangeType &Operands); |
149 | | void fixupDefs(const SmallVectorImpl<MemoryAccess *> &); |
150 | | }; |
151 | | } // end namespace llvm |
152 | | |
153 | | #endif // LLVM_TRANSFORMS_UTILS_MEMORYSSAUPDATER_H |