LLVM  15.0.0git
CodeGenCommonISel.h
Go to the documentation of this file.
1 //===- CodeGenCommonISel.h - Common code between ISels ---------*- 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 common utilities that are shared between SelectionDAG and
10 // GlobalISel frameworks.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_CODEGEN_CODEGENCOMMONISEL_H
15 #define LLVM_CODEGEN_CODEGENCOMMONISEL_H
16 
18 #include <cassert>
19 namespace llvm {
20 
21 class BasicBlock;
22 /// Encapsulates all of the information needed to generate a stack protector
23 /// check, and signals to isel when initialized that one needs to be generated.
24 ///
25 /// *NOTE* The following is a high level documentation of SelectionDAG Stack
26 /// Protector Generation. This is now also ported be shared with GlobalISel,
27 /// but without any significant changes.
28 ///
29 /// High Level Overview of ISel Stack Protector Generation:
30 ///
31 /// Previously, the "stack protector" IR pass handled stack protector
32 /// generation. This necessitated splitting basic blocks at the IR level to
33 /// create the success/failure basic blocks in the tail of the basic block in
34 /// question. As a result of this, calls that would have qualified for the
35 /// sibling call optimization were no longer eligible for optimization since
36 /// said calls were no longer right in the "tail position" (i.e. the immediate
37 /// predecessor of a ReturnInst instruction).
38 ///
39 /// Since the sibling call optimization causes the callee to reuse the caller's
40 /// stack, if we could delay the generation of the stack protector check until
41 /// later in CodeGen after the sibling call decision was made, we get both the
42 /// tail call optimization and the stack protector check!
43 ///
44 /// A few goals in solving this problem were:
45 ///
46 /// 1. Preserve the architecture independence of stack protector generation.
47 ///
48 /// 2. Preserve the normal IR level stack protector check for platforms like
49 /// OpenBSD for which we support platform-specific stack protector
50 /// generation.
51 ///
52 /// The main problem that guided the present solution is that one can not
53 /// solve this problem in an architecture independent manner at the IR level
54 /// only. This is because:
55 ///
56 /// 1. The decision on whether or not to perform a sibling call on certain
57 /// platforms (for instance i386) requires lower level information
58 /// related to available registers that can not be known at the IR level.
59 ///
60 /// 2. Even if the previous point were not true, the decision on whether to
61 /// perform a tail call is done in LowerCallTo in SelectionDAG (or
62 /// CallLowering in GlobalISel) which occurs after the Stack Protector
63 /// Pass. As a result, one would need to put the relevant callinst into the
64 /// stack protector check success basic block (where the return inst is
65 /// placed) and then move it back later at ISel/MI time before the
66 /// stack protector check if the tail call optimization failed. The MI
67 /// level option was nixed immediately since it would require
68 /// platform-specific pattern matching. The ISel level option was
69 /// nixed because SelectionDAG only processes one IR level basic block at a
70 /// time implying one could not create a DAG Combine to move the callinst.
71 ///
72 /// To get around this problem:
73 ///
74 /// 1. SelectionDAG can only process one block at a time, we can generate
75 /// multiple machine basic blocks for one IR level basic block.
76 /// This is how we handle bit tests and switches.
77 ///
78 /// 2. At the MI level, tail calls are represented via a special return
79 /// MIInst called "tcreturn". Thus if we know the basic block in which we
80 /// wish to insert the stack protector check, we get the correct behavior
81 /// by always inserting the stack protector check right before the return
82 /// statement. This is a "magical transformation" since no matter where
83 /// the stack protector check intrinsic is, we always insert the stack
84 /// protector check code at the end of the BB.
85 ///
86 /// Given the aforementioned constraints, the following solution was devised:
87 ///
88 /// 1. On platforms that do not support ISel stack protector check
89 /// generation, allow for the normal IR level stack protector check
90 /// generation to continue.
91 ///
92 /// 2. On platforms that do support ISel stack protector check
93 /// generation:
94 ///
95 /// a. Use the IR level stack protector pass to decide if a stack
96 /// protector is required/which BB we insert the stack protector check
97 /// in by reusing the logic already therein.
98 ///
99 /// b. After we finish selecting the basic block, we produce the validation
100 /// code with one of these techniques:
101 /// 1) with a call to a guard check function
102 /// 2) with inlined instrumentation
103 ///
104 /// 1) We insert a call to the check function before the terminator.
105 ///
106 /// 2) We first find a splice point in the parent basic block
107 /// before the terminator and then splice the terminator of said basic
108 /// block into the success basic block. Then we code-gen a new tail for
109 /// the parent basic block consisting of the two loads, the comparison,
110 /// and finally two branches to the success/failure basic blocks. We
111 /// conclude by code-gening the failure basic block if we have not
112 /// code-gened it already (all stack protector checks we generate in
113 /// the same function, use the same failure basic block).
115 public:
116  StackProtectorDescriptor() = default;
117 
118  /// Returns true if all fields of the stack protector descriptor are
119  /// initialized implying that we should/are ready to emit a stack protector.
121  return ParentMBB && SuccessMBB && FailureMBB;
122  }
123 
125  return ParentMBB && !SuccessMBB && !FailureMBB;
126  }
127 
128  /// Initialize the stack protector descriptor structure for a new basic
129  /// block.
131  bool FunctionBasedInstrumentation) {
132  // Make sure we are not initialized yet.
133  assert(!shouldEmitStackProtector() && "Stack Protector Descriptor is "
134  "already initialized!");
135  ParentMBB = MBB;
136  if (!FunctionBasedInstrumentation) {
137  SuccessMBB = addSuccessorMBB(BB, MBB, /* IsLikely */ true);
138  FailureMBB = addSuccessorMBB(BB, MBB, /* IsLikely */ false, FailureMBB);
139  }
140  }
141 
142  /// Reset state that changes when we handle different basic blocks.
143  ///
144  /// This currently includes:
145  ///
146  /// 1. The specific basic block we are generating a
147  /// stack protector for (ParentMBB).
148  ///
149  /// 2. The successor machine basic block that will contain the tail of
150  /// parent mbb after we create the stack protector check (SuccessMBB). This
151  /// BB is visited only on stack protector check success.
153  ParentMBB = nullptr;
154  SuccessMBB = nullptr;
155  }
156 
157  /// Reset state that only changes when we switch functions.
158  ///
159  /// This currently includes:
160  ///
161  /// 1. FailureMBB since we reuse the failure code path for all stack
162  /// protector checks created in an individual function.
163  ///
164  /// 2.The guard variable since the guard variable we are checking against is
165  /// always the same.
166  void resetPerFunctionState() { FailureMBB = nullptr; }
167 
168  MachineBasicBlock *getParentMBB() { return ParentMBB; }
169  MachineBasicBlock *getSuccessMBB() { return SuccessMBB; }
170  MachineBasicBlock *getFailureMBB() { return FailureMBB; }
171 
172 private:
173  /// The basic block for which we are generating the stack protector.
174  ///
175  /// As a result of stack protector generation, we will splice the
176  /// terminators of this basic block into the successor mbb SuccessMBB and
177  /// replace it with a compare/branch to the successor mbbs
178  /// SuccessMBB/FailureMBB depending on whether or not the stack protector
179  /// was violated.
180  MachineBasicBlock *ParentMBB = nullptr;
181 
182  /// A basic block visited on stack protector check success that contains the
183  /// terminators of ParentMBB.
184  MachineBasicBlock *SuccessMBB = nullptr;
185 
186  /// This basic block visited on stack protector check failure that will
187  /// contain a call to __stack_chk_fail().
188  MachineBasicBlock *FailureMBB = nullptr;
189 
190  /// Add a successor machine basic block to ParentMBB. If the successor mbb
191  /// has not been created yet (i.e. if SuccMBB = 0), then the machine basic
192  /// block will be created. Assign a large weight if IsLikely is true.
193  MachineBasicBlock *addSuccessorMBB(const BasicBlock *BB,
194  MachineBasicBlock *ParentMBB,
195  bool IsLikely,
196  MachineBasicBlock *SuccMBB = nullptr);
197 };
198 
199 /// Find the split point at which to splice the end of BB into its success stack
200 /// protector check machine basic block.
201 ///
202 /// On many platforms, due to ABI constraints, terminators, even before register
203 /// allocation, use physical registers. This creates an issue for us since
204 /// physical registers at this point can not travel across basic
205 /// blocks. Luckily, selectiondag always moves physical registers into vregs
206 /// when they enter functions and moves them through a sequence of copies back
207 /// into the physical registers right before the terminator creating a
208 /// ``Terminator Sequence''. This function is searching for the beginning of the
209 /// terminator sequence so that we can ensure that we splice off not just the
210 /// terminator, but additionally the copies that move the vregs into the
211 /// physical registers.
213 findSplitPointForStackProtector(MachineBasicBlock *BB,
214  const TargetInstrInfo &TII);
215 /// Evaluates if the specified FP class test is an inversion of a simpler test.
216 /// An example is the test "inf|normal|subnormal|zero", which is an inversion
217 /// of "nan".
218 /// \param Test The test as specified in 'is_fpclass' intrinsic invocation.
219 /// \returns The inverted test, or zero, if inversion does not produce simpler
220 /// test.
221 unsigned getInvertedFPClassTest(unsigned Test);
222 
223 } // namespace llvm
224 
225 #endif // LLVM_CODEGEN_CODEGENCOMMONISEL_H
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:17
llvm::getInvertedFPClassTest
unsigned getInvertedFPClassTest(unsigned Test)
Evaluates if the specified FP class test is an inversion of a simpler test.
Definition: CodeGenCommonISel.cpp:173
llvm::StackProtectorDescriptor::getSuccessMBB
MachineBasicBlock * getSuccessMBB()
Definition: CodeGenCommonISel.h:169
MachineBasicBlock.h
llvm::BasicBlock
LLVM Basic Block Representation.
Definition: BasicBlock.h:55
llvm::StackProtectorDescriptor
Encapsulates all of the information needed to generate a stack protector check, and signals to isel w...
Definition: CodeGenCommonISel.h:114
TII
const HexagonInstrInfo * TII
Definition: HexagonCopyToCombine.cpp:125
llvm::MachineBasicBlock
Definition: MachineBasicBlock.h:94
llvm::StackProtectorDescriptor::resetPerBBState
void resetPerBBState()
Reset state that changes when we handle different basic blocks.
Definition: CodeGenCommonISel.h:152
llvm::StackProtectorDescriptor::getFailureMBB
MachineBasicBlock * getFailureMBB()
Definition: CodeGenCommonISel.h:170
llvm::StackProtectorDescriptor::shouldEmitStackProtector
bool shouldEmitStackProtector() const
Returns true if all fields of the stack protector descriptor are initialized implying that we should/...
Definition: CodeGenCommonISel.h:120
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::ISD::BasicBlock
@ BasicBlock
Various leaf nodes.
Definition: ISDOpcodes.h:71
llvm::MachineBasicBlock::iterator
MachineInstrBundleIterator< MachineInstr > iterator
Definition: MachineBasicBlock.h:242
llvm::StackProtectorDescriptor::resetPerFunctionState
void resetPerFunctionState()
Reset state that only changes when we switch functions.
Definition: CodeGenCommonISel.h:166
llvm::StackProtectorDescriptor::getParentMBB
MachineBasicBlock * getParentMBB()
Definition: CodeGenCommonISel.h:168
MBB
MachineBasicBlock & MBB
Definition: AArch64SLSHardening.cpp:74
llvm::StackProtectorDescriptor::StackProtectorDescriptor
StackProtectorDescriptor()=default
llvm::StackProtectorDescriptor::shouldEmitFunctionBasedCheckStackProtector
bool shouldEmitFunctionBasedCheckStackProtector() const
Definition: CodeGenCommonISel.h:124
llvm::StackProtectorDescriptor::initialize
void initialize(const BasicBlock *BB, MachineBasicBlock *MBB, bool FunctionBasedInstrumentation)
Initialize the stack protector descriptor structure for a new basic block.
Definition: CodeGenCommonISel.h:130
BB
Common register allocation spilling lr str ldr sxth r3 ldr mla r4 can lr mov lr str ldr sxth r3 mla r4 and then merge mul and lr str ldr sxth r3 mla r4 It also increase the likelihood the store may become dead bb27 Successors according to LLVM BB
Definition: README.txt:39
llvm::findSplitPointForStackProtector
MachineBasicBlock::iterator findSplitPointForStackProtector(MachineBasicBlock *BB, const TargetInstrInfo &TII)
Find the split point at which to splice the end of BB into its success stack protector check machine ...
Definition: CodeGenCommonISel.cpp:124