1 | //===- MachineSSAUpdater.h - Unstructured SSA Update Tool -------*- C++ -*-===// |
2 | // |
3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
4 | // See https://llvm.org/LICENSE.txt for license information. |
5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
6 | // |
7 | //===----------------------------------------------------------------------===// |
8 | // |
9 | // This file declares the MachineSSAUpdater class. |
10 | // |
11 | //===----------------------------------------------------------------------===// |
12 | |
13 | #ifndef LLVM_CODEGEN_MACHINESSAUPDATER_H |
14 | #define LLVM_CODEGEN_MACHINESSAUPDATER_H |
15 | |
16 | #include "llvm/CodeGen/Register.h" |
17 | |
18 | namespace llvm { |
19 | |
20 | class MachineBasicBlock; |
21 | class MachineFunction; |
22 | class MachineInstr; |
23 | class MachineOperand; |
24 | class MachineRegisterInfo; |
25 | class TargetInstrInfo; |
26 | class TargetRegisterClass; |
27 | template<typename T> class SmallVectorImpl; |
28 | template<typename T> class SSAUpdaterTraits; |
29 | |
30 | /// MachineSSAUpdater - This class updates SSA form for a set of virtual |
31 | /// registers defined in multiple blocks. This is used when code duplication |
32 | /// or another unstructured transformation wants to rewrite a set of uses of one |
33 | /// vreg with uses of a set of vregs. |
34 | class MachineSSAUpdater { |
35 | friend class SSAUpdaterTraits<MachineSSAUpdater>; |
36 | |
37 | private: |
38 | /// AvailableVals - This keeps track of which value to use on a per-block |
39 | /// basis. When we insert PHI nodes, we keep track of them here. |
40 | //typedef DenseMap<MachineBasicBlock*, Register> AvailableValsTy; |
41 | void *AV = nullptr; |
42 | |
43 | /// VRC - Register class of the current virtual register. |
44 | const TargetRegisterClass *VRC = nullptr; |
45 | |
46 | /// InsertedPHIs - If this is non-null, the MachineSSAUpdater adds all PHI |
47 | /// nodes that it creates to the vector. |
48 | SmallVectorImpl<MachineInstr*> *InsertedPHIs; |
49 | |
50 | const TargetInstrInfo *TII = nullptr; |
51 | MachineRegisterInfo *MRI = nullptr; |
52 | |
53 | public: |
54 | /// MachineSSAUpdater constructor. If InsertedPHIs is specified, it will be |
55 | /// filled in with all PHI Nodes created by rewriting. |
56 | explicit MachineSSAUpdater(MachineFunction &MF, |
57 | SmallVectorImpl<MachineInstr*> *NewPHI = nullptr); |
58 | MachineSSAUpdater(const MachineSSAUpdater &) = delete; |
59 | MachineSSAUpdater &operator=(const MachineSSAUpdater &) = delete; |
60 | ~MachineSSAUpdater(); |
61 | |
62 | /// Initialize - Reset this object to get ready for a new set of SSA |
63 | /// updates. |
64 | void Initialize(Register V); |
65 | void Initialize(const TargetRegisterClass *RC); |
66 | |
67 | /// AddAvailableValue - Indicate that a rewritten value is available at the |
68 | /// end of the specified block with the specified value. |
69 | void AddAvailableValue(MachineBasicBlock *BB, Register V); |
70 | |
71 | /// HasValueForBlock - Return true if the MachineSSAUpdater already has a |
72 | /// value for the specified block. |
73 | bool HasValueForBlock(MachineBasicBlock *BB) const; |
74 | |
75 | /// GetValueAtEndOfBlock - Construct SSA form, materializing a value that is |
76 | /// live at the end of the specified block. |
77 | Register GetValueAtEndOfBlock(MachineBasicBlock *BB); |
78 | |
79 | /// GetValueInMiddleOfBlock - Construct SSA form, materializing a value that |
80 | /// is live in the middle of the specified block. If ExistingValueOnly is |
81 | /// true then this will only return an existing value or $noreg; otherwise new |
82 | /// instructions may be inserted to materialize a value. |
83 | /// |
84 | /// GetValueInMiddleOfBlock is the same as GetValueAtEndOfBlock except in one |
85 | /// important case: if there is a definition of the rewritten value after the |
86 | /// 'use' in BB. Consider code like this: |
87 | /// |
88 | /// X1 = ... |
89 | /// SomeBB: |
90 | /// use(X) |
91 | /// X2 = ... |
92 | /// br Cond, SomeBB, OutBB |
93 | /// |
94 | /// In this case, there are two values (X1 and X2) added to the AvailableVals |
95 | /// set by the client of the rewriter, and those values are both live out of |
96 | /// their respective blocks. However, the use of X happens in the *middle* of |
97 | /// a block. Because of this, we need to insert a new PHI node in SomeBB to |
98 | /// merge the appropriate values, and this value isn't live out of the block. |
99 | Register GetValueInMiddleOfBlock(MachineBasicBlock *BB, |
100 | bool ExistingValueOnly = false); |
101 | |
102 | /// RewriteUse - Rewrite a use of the symbolic value. This handles PHI nodes, |
103 | /// which use their value in the corresponding predecessor. Note that this |
104 | /// will not work if the use is supposed to be rewritten to a value defined in |
105 | /// the same block as the use, but above it. Any 'AddAvailableValue's added |
106 | /// for the use's block will be considered to be below it. |
107 | void RewriteUse(MachineOperand &U); |
108 | |
109 | private: |
110 | // If ExistingValueOnly is true, will not create any new instructions. Used |
111 | // for debug values, which cannot modify Codegen. |
112 | Register GetValueAtEndOfBlockInternal(MachineBasicBlock *BB, |
113 | bool ExistingValueOnly = false); |
114 | }; |
115 | |
116 | } // end namespace llvm |
117 | |
118 | #endif // LLVM_CODEGEN_MACHINESSAUPDATER_H |
119 | |