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