class StackProtectorDescriptor

Declaration

class StackProtectorDescriptor { /* full declaration omitted */ };

Description

Encapsulates all of the information needed to generate a stack protector check, and signals to isel when initialized that one needs to be generated. *NOTE* The following is a high level documentation of SelectionDAG Stack Protector Generation. This is now also ported be shared with GlobalISel, but without any significant changes. High Level Overview of ISel Stack Protector Generation: Previously, the "stack protector" IR pass handled stack protector generation. This necessitated splitting basic blocks at the IR level to create the success/failure basic blocks in the tail of the basic block in question. As a result of this, calls that would have qualified for the sibling call optimization were no longer eligible for optimization since said calls were no longer right in the "tail position" (i.e. the immediate predecessor of a ReturnInst instruction). Since the sibling call optimization causes the callee to reuse the caller's stack, if we could delay the generation of the stack protector check until later in CodeGen after the sibling call decision was made, we get both the tail call optimization and the stack protector check! A few goals in solving this problem were: 1. Preserve the architecture independence of stack protector generation. 2. Preserve the normal IR level stack protector check for platforms like OpenBSD for which we support platform-specific stack protector generation. The main problem that guided the present solution is that one can not solve this problem in an architecture independent manner at the IR level only. This is because: 1. The decision on whether or not to perform a sibling call on certain platforms (for instance i386) requires lower level information related to available registers that can not be known at the IR level. 2. Even if the previous point were not true, the decision on whether to perform a tail call is done in LowerCallTo in SelectionDAG (or CallLowering in GlobalISel) which occurs after the Stack Protector Pass. As a result, one would need to put the relevant callinst into the stack protector check success basic block (where the return inst is placed) and then move it back later at ISel/MI time before the stack protector check if the tail call optimization failed. The MI level option was nixed immediately since it would require platform-specific pattern matching. The ISel level option was nixed because SelectionDAG only processes one IR level basic block at a time implying one could not create a DAG Combine to move the callinst. To get around this problem: 1. SelectionDAG can only process one block at a time, we can generate multiple machine basic blocks for one IR level basic block. This is how we handle bit tests and switches. 2. At the MI level, tail calls are represented via a special return MIInst called "tcreturn". Thus if we know the basic block in which we wish to insert the stack protector check, we get the correct behavior by always inserting the stack protector check right before the return statement. This is a "magical transformation" since no matter where the stack protector check intrinsic is, we always insert the stack protector check code at the end of the BB. Given the aforementioned constraints, the following solution was devised: 1. On platforms that do not support ISel stack protector check generation, allow for the normal IR level stack protector check generation to continue. 2. On platforms that do support ISel stack protector check generation: a. Use the IR level stack protector pass to decide if a stack protector is required/which BB we insert the stack protector check in by reusing the logic already therein. b. After we finish selecting the basic block, we produce the validation code with one of these techniques: 1) with a call to a guard check function 2) with inlined instrumentation 1) We insert a call to the check function before the terminator. 2) We first find a splice point in the parent basic block before the terminator and then splice the terminator of said basic block into the success basic block. Then we code-gen a new tail for the parent basic block consisting of the two loads, the comparison, and finally two branches to the success/failure basic blocks. We conclude by code-gening the failure basic block if we have not code-gened it already (all stack protector checks we generate in the same function, use the same failure basic block).

Declared at: llvm/include/llvm/CodeGen/CodeGenCommonISel.h:114

Member Variables

private llvm::MachineBasicBlock* ParentMBB = nullptr
As a result of stack protector generation, we will splice the terminators of this basic block into the successor mbb SuccessMBB and replace it with a compare/branch to the successor mbbs SuccessMBB/FailureMBB depending on whether or not the stack protector was violated.
private llvm::MachineBasicBlock* SuccessMBB = nullptr
A basic block visited on stack protector check success that contains the terminators of ParentMBB.
private llvm::MachineBasicBlock* FailureMBB = nullptr
This basic block visited on stack protector check failure that will contain a call to __stack_chk_fail().

Method Overview

Methods

StackProtectorDescriptor()

Declared at: llvm/include/llvm/CodeGen/CodeGenCommonISel.h:116

llvm::MachineBasicBlock* addSuccessorMBB(
    const llvm::BasicBlock* BB,
    llvm::MachineBasicBlock* ParentMBB,
    bool IsLikely,
    llvm::MachineBasicBlock* SuccMBB = nullptr)

Description

Add a successor machine basic block to ParentMBB. If the successor mbb has not been created yet (i.e. if SuccMBB = 0), then the machine basic block will be created. Assign a large weight if IsLikely is true.

Declared at: llvm/include/llvm/CodeGen/CodeGenCommonISel.h:193

Parameters

const llvm::BasicBlock* BB
llvm::MachineBasicBlock* ParentMBB
bool IsLikely
llvm::MachineBasicBlock* SuccMBB = nullptr

llvm::MachineBasicBlock* getFailureMBB()

Declared at: llvm/include/llvm/CodeGen/CodeGenCommonISel.h:170

llvm::MachineBasicBlock* getParentMBB()

Declared at: llvm/include/llvm/CodeGen/CodeGenCommonISel.h:168

llvm::MachineBasicBlock* getSuccessMBB()

Declared at: llvm/include/llvm/CodeGen/CodeGenCommonISel.h:169

void initialize(const llvm::BasicBlock* BB,
                llvm::MachineBasicBlock* MBB,
                bool FunctionBasedInstrumentation)

Description

Initialize the stack protector descriptor structure for a new basic block.

Declared at: llvm/include/llvm/CodeGen/CodeGenCommonISel.h:130

Parameters

const llvm::BasicBlock* BB
llvm::MachineBasicBlock* MBB
bool FunctionBasedInstrumentation

void resetPerBBState()

Description

Reset state that changes when we handle different basic blocks. This currently includes: 1. The specific basic block we are generating a stack protector for (ParentMBB). 2. The successor machine basic block that will contain the tail of parent mbb after we create the stack protector check (SuccessMBB). This BB is visited only on stack protector check success.

Declared at: llvm/include/llvm/CodeGen/CodeGenCommonISel.h:152

void resetPerFunctionState()

Description

Reset state that only changes when we switch functions. This currently includes: 1. FailureMBB since we reuse the failure code path for all stack protector checks created in an individual function. 2.The guard variable since the guard variable we are checking against is always the same.

Declared at: llvm/include/llvm/CodeGen/CodeGenCommonISel.h:166

bool shouldEmitFunctionBasedCheckStackProtector()
    const

Declared at: llvm/include/llvm/CodeGen/CodeGenCommonISel.h:124

bool shouldEmitStackProtector() const

Description

Returns true if all fields of the stack protector descriptor are initialized implying that we should/are ready to emit a stack protector.

Declared at: llvm/include/llvm/CodeGen/CodeGenCommonISel.h:120