LLVM 20.0.0git
MachineSSAUpdater.h
Go to the documentation of this file.
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
18
19namespace llvm {
20
22class MachineFunction;
23class MachineInstr;
24class MachineOperand;
26class TargetInstrInfo;
28template<typename T> class SmallVectorImpl;
29template<typename T> class SSAUpdaterTraits;
30
31/// MachineSSAUpdater - This class updates SSA form for a set of virtual
32/// registers defined in multiple blocks. This is used when code duplication
33/// or another unstructured transformation wants to rewrite a set of uses of one
34/// vreg with uses of a set of vregs.
37
38private:
39 /// AvailableVals - This keeps track of which value to use on a per-block
40 /// basis. When we insert PHI nodes, we keep track of them here.
41 //typedef DenseMap<MachineBasicBlock*, Register> AvailableValsTy;
42 void *AV = nullptr;
43
44 /// Register class or bank and LLT of current virtual register.
46
47 /// InsertedPHIs - If this is non-null, the MachineSSAUpdater adds all PHI
48 /// nodes that it creates to the vector.
50
51 const TargetInstrInfo *TII = nullptr;
52 MachineRegisterInfo *MRI = nullptr;
53
54public:
55 /// MachineSSAUpdater constructor. If InsertedPHIs is specified, it will be
56 /// filled in with all PHI Nodes created by rewriting.
58 SmallVectorImpl<MachineInstr*> *NewPHI = nullptr);
62
63 /// Initialize - Reset this object to get ready for a new set of SSA
64 /// updates.
65 void Initialize(Register V);
66
67 /// AddAvailableValue - Indicate that a rewritten value is available at the
68 /// end of the specified block with the specified value.
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.
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.
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
109private:
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
unsigned const MachineRegisterInfo * MRI
const HexagonInstrInfo * TII
Representation of each machine instruction.
Definition: MachineInstr.h:69
MachineOperand class - Representation of each machine instruction operand.
MachineRegisterInfo - Keep track of information for virtual and physical registers,...
MachineSSAUpdater - This class updates SSA form for a set of virtual registers defined in multiple bl...
void Initialize(Register V)
Initialize - Reset this object to get ready for a new set of SSA updates.
Register GetValueInMiddleOfBlock(MachineBasicBlock *BB, bool ExistingValueOnly=false)
GetValueInMiddleOfBlock - Construct SSA form, materializing a value that is live in the middle of the...
MachineSSAUpdater(const MachineSSAUpdater &)=delete
void RewriteUse(MachineOperand &U)
RewriteUse - Rewrite a use of the symbolic value.
MachineSSAUpdater & operator=(const MachineSSAUpdater &)=delete
Register GetValueAtEndOfBlock(MachineBasicBlock *BB)
GetValueAtEndOfBlock - Construct SSA form, materializing a value that is live at the end of the speci...
void AddAvailableValue(MachineBasicBlock *BB, Register V)
AddAvailableValue - Indicate that a rewritten value is available at the end of the specified block wi...
bool HasValueForBlock(MachineBasicBlock *BB) const
HasValueForBlock - Return true if the MachineSSAUpdater already has a value for the specified block.
Wrapper class representing virtual and physical registers.
Definition: Register.h:19
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: SmallVector.h:586
TargetInstrInfo - Interface to description of machine instruction set.
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
All attributes(register class or bank and low-level type) a virtual register can have.