77#define DEBUG_TYPE "safe-stack"
81STATISTIC(NumFunctions,
"Total number of functions");
82STATISTIC(NumUnsafeStackFunctions,
"Number of functions with unsafe stack");
84 "Number of functions that use setjmp or exceptions");
87STATISTIC(NumUnsafeStaticAllocas,
"Number of unsafe static allocas");
88STATISTIC(NumUnsafeDynamicAllocas,
"Number of unsafe dynamic allocas");
89STATISTIC(NumUnsafeByValArguments,
"Number of unsafe byval arguments");
90STATISTIC(NumUnsafeStackRestorePoints,
"Number of setjmps and landingpads");
101 cl::desc(
"enable safe stack coloring"),
122 Value *UnsafeStackPtr =
nullptr;
130 static constexpr Align StackAlignment = Align::Constant<16>();
171 Value *StaticTop,
bool NeedDynamicTop);
176 void moveDynamicAllocasToUnsafeStack(
Function &F,
Value *UnsafeStackPtr,
180 bool IsSafeStackAlloca(
const Value *AllocaPtr,
uint64_t AllocaSize);
187 bool ShouldInlinePointerAddress(
CallInst &CI);
188 void TryInlinePointerAddress();
193 :
F(
F), TL(TL),
DL(
DL), DTU(DTU), SE(SE),
194 StackPtrTy(
DL.getAllocaPtrType(
F.getContext())),
195 IntPtrTy(
DL.getIntPtrType(
F.getContext())),
196 Int32Ty(
Type::getInt32Ty(
F.getContext())) {}
203constexpr Align SafeStack::StackAlignment;
211 Size *=
C->getZExtValue();
218 const SCEV *AddrExpr = SE.getSCEV(
Addr);
219 const auto *
Base = dyn_cast<SCEVUnknown>(SE.getPointerBase(AddrExpr));
220 if (!
Base ||
Base->getValue() != AllocaPtr) {
222 dbgs() <<
"[SafeStack] "
223 << (isa<AllocaInst>(AllocaPtr) ?
"Alloca " :
"ByValArgument ")
224 << *AllocaPtr <<
"\n"
225 <<
"SCEV " << *AddrExpr <<
" not directly based on alloca\n");
229 const SCEV *Expr = SE.removePointerBase(AddrExpr);
237 bool Safe = AllocaRange.
contains(AccessRange);
240 dbgs() <<
"[SafeStack] "
241 << (isa<AllocaInst>(AllocaPtr) ?
"Alloca " :
"ByValArgument ")
242 << *AllocaPtr <<
"\n"
243 <<
" Access " << *
Addr <<
"\n"
245 <<
" U: " << SE.getUnsignedRange(Expr)
246 <<
", S: " << SE.getSignedRange(Expr) <<
"\n"
247 <<
" Range " << AccessRange <<
"\n"
248 <<
" AllocaRange " << AllocaRange <<
"\n"
249 <<
" " << (Safe ?
"safe" :
"unsafe") <<
"\n");
255 const Value *AllocaPtr,
257 if (
auto MTI = dyn_cast<MemTransferInst>(
MI)) {
258 if (MTI->getRawSource() != U && MTI->getRawDest() != U)
261 if (
MI->getRawDest() != U)
265 auto Len =
MI->getLengthInBytes();
267 if (!Len)
return false;
268 return IsAccessSafe(U,
Len->getZExtValue(), AllocaPtr, AllocaSize);
274bool SafeStack::IsSafeStackAlloca(
const Value *AllocaPtr,
uint64_t AllocaSize) {
283 while (!WorkList.
empty()) {
285 for (
const Use &UI :
V->uses()) {
286 auto I = cast<const Instruction>(UI.getUser());
289 switch (
I->getOpcode()) {
290 case Instruction::Load:
291 if (!IsAccessSafe(UI,
DL.getTypeStoreSize(
I->getType()), AllocaPtr,
296 case Instruction::VAArg:
299 case Instruction::Store:
300 if (V ==
I->getOperand(0)) {
303 <<
"[SafeStack] Unsafe alloca: " << *AllocaPtr
304 <<
"\n store of address: " << *
I <<
"\n");
308 if (!IsAccessSafe(UI,
DL.getTypeStoreSize(
I->getOperand(0)->getType()),
309 AllocaPtr, AllocaSize))
313 case Instruction::Ret:
317 case Instruction::Call:
318 case Instruction::Invoke: {
321 if (
I->isLifetimeStartOrEnd())
325 if (!IsMemIntrinsicSafe(
MI, UI, AllocaPtr, AllocaSize)) {
327 <<
"[SafeStack] Unsafe alloca: " << *AllocaPtr
328 <<
"\n unsafe memintrinsic: " << *
I <<
"\n");
342 for (
const auto *
A =
B;
A != E; ++
A)
347 <<
"\n unsafe call: " << *
I <<
"\n");
355 WorkList.
push_back(cast<const Instruction>(
I));
365 Value *StackGuardVar = TL.getIRStackGuard(IRB);
368 if (!StackGuardVar) {
369 TL.insertSSPDeclarations(*M);
373 return IRB.
CreateLoad(StackPtrTy, StackGuardVar,
"StackGuard");
383 if (
auto AI = dyn_cast<AllocaInst>(&
I)) {
387 if (IsSafeStackAlloca(AI,
Size))
391 ++NumUnsafeStaticAllocas;
394 ++NumUnsafeDynamicAllocas;
397 }
else if (
auto RI = dyn_cast<ReturnInst>(&
I)) {
398 if (
CallInst *CI =
I.getParent()->getTerminatingMustTailCall())
402 }
else if (
auto CI = dyn_cast<CallInst>(&
I)) {
404 if (CI->getCalledFunction() && CI->canReturnTwice())
406 }
else if (
auto LP = dyn_cast<LandingPadInst>(&
I)) {
409 }
else if (
auto II = dyn_cast<IntrinsicInst>(&
I)) {
410 if (
II->getIntrinsicID() == Intrinsic::gcroot)
412 "gcroot intrinsic not compatible with safestack attribute");
416 if (!Arg.hasByValAttr())
419 if (IsSafeStackAlloca(&Arg,
Size))
422 ++NumUnsafeByValArguments;
430 Value *StaticTop,
bool NeedDynamicTop) {
431 assert(StaticTop &&
"The stack top isn't set.");
433 if (StackRestorePoints.
empty())
443 if (NeedDynamicTop) {
447 "unsafe_stack_dynamic_ptr");
453 ++NumUnsafeStackRestorePoints;
457 DynamicTop ? IRB.
CreateLoad(StackPtrTy, DynamicTop) : StaticTop;
473 FailureProb.getNumerator());
478 const char *StackChkFailName =
479 TL.getLibcallName(RTLIB::STACKPROTECTOR_CHECK_FAIL);
480 if (!StackChkFailName) {
481 F.getContext().emitError(
482 "no libcall available for stackprotector check fail");
487 F.getParent()->getOrInsertFunction(StackChkFailName, IRB.
getVoidTy());
488 IRBFail.CreateCall(StackChkFail, {});
494Value *SafeStack::moveStaticAllocasToUnsafeStack(
498 if (StaticAllocas.
empty() && ByValArguments.
empty())
503 StackLifetime SSC(
F, StaticAllocas, StackLifetime::LivenessType::May);
508 for (
const auto *
I : SSC.getMarkers()) {
509 auto *
Op = dyn_cast<Instruction>(
I->getOperand(1));
512 if (
Op &&
Op->use_empty())
513 Op->eraseFromParent();
518 if (StackGuardSlot) {
521 SSL.addObject(StackGuardSlot, getStaticAllocaAllocationSize(StackGuardSlot),
522 Align, SSC.getFullLiveRange());
525 for (
Argument *Arg : ByValArguments) {
526 Type *Ty = Arg->getParamByValType();
533 if (
auto A = Arg->getParamAlign())
535 SSL.addObject(Arg,
Size,
Align, SSC.getFullLiveRange());
548 ClColoring ? SSC.getLiveRange(AI) : NoColoringRange);
552 Align FrameAlignment = SSL.getFrameAlignment();
556 if (FrameAlignment > StackAlignment) {
562 ConstantInt::get(IntPtrTy, ~(FrameAlignment.
value() - 1))),
568 if (StackGuardSlot) {
569 unsigned Offset = SSL.getObjectOffset(StackGuardSlot);
580 for (
Argument *Arg : ByValArguments) {
581 unsigned Offset = SSL.getObjectOffset(Arg);
583 Type *Ty = Arg->getParamByValType();
592 Arg->getName() +
".unsafe-byval");
597 Arg->replaceAllUsesWith(NewArg);
605 unsigned Offset = SSL.getObjectOffset(AI);
612 std::string
Name = std::string(AI->
getName()) +
".unsafe";
619 if (
User->isLifetimeStartOrEnd()) {
620 User->eraseFromParent();
625 if (
auto *
PHI = dyn_cast<PHINode>(
User))
626 InsertBefore =
PHI->getIncomingBlock(U)->getTerminator();
632 IRBUser.CreatePtrAdd(BasePointer, ConstantInt::get(Int32Ty, -
Offset));
634 IRBUser.CreateAddrSpaceCast(Off, AI->
getType(),
Name);
636 if (
auto *
PHI = dyn_cast<PHINode>(
User))
639 PHI->setIncomingValueForBlock(
PHI->getIncomingBlock(U), Replacement);
650 unsigned FrameSize =
alignTo(SSL.getFrameSize(), StackAlignment);
654 Data.push_back(MDB.createString(
"unsafe-stack-size"));
655 Data.push_back(MDB.createConstant(ConstantInt::get(Int32Ty, FrameSize)));
657 F.setMetadata(LLVMContext::MD_annotation, MD);
663 IRB.
CreatePtrAdd(BasePointer, ConstantInt::get(Int32Ty, -FrameSize),
664 "unsafe_stack_static_top");
669void SafeStack::moveDynamicAllocasToUnsafeStack(
679 if (ArraySize->
getType() != IntPtrTy)
691 auto Align = std::max(std::max(
DL.getPrefTypeAlign(Ty), AI->
getAlign()),
705 if (AI->
hasName() && isa<Instruction>(NewAI))
713 if (!DynamicAllocas.empty()) {
716 auto *
II = dyn_cast<IntrinsicInst>(&
I);
720 if (
II->getIntrinsicID() == Intrinsic::stacksave) {
724 II->replaceAllUsesWith(LI);
725 II->eraseFromParent();
726 }
else if (
II->getIntrinsicID() == Intrinsic::stackrestore) {
731 II->eraseFromParent();
737bool SafeStack::ShouldInlinePointerAddress(
CallInst &CI) {
739 if (CI.
hasFnAttr(Attribute::AlwaysInline) &&
742 if (
Callee->isInterposable() ||
Callee->hasFnAttribute(Attribute::NoInline) ||
748void SafeStack::TryInlinePointerAddress() {
749 auto *CI = dyn_cast<CallInst>(UnsafeStackPtr);
757 if (!Callee ||
Callee->isDeclaration())
760 if (!ShouldInlinePointerAddress(*CI))
767bool SafeStack::run() {
768 assert(
F.hasFnAttribute(Attribute::SafeStack) &&
769 "Can't run SafeStack on a function without the attribute");
770 assert(!
F.isDeclaration() &&
"Can't run SafeStack on a function declaration");
788 findInsts(
F, StaticAllocas, DynamicAllocas, ByValArguments, Returns,
791 if (StaticAllocas.
empty() && DynamicAllocas.
empty() &&
792 ByValArguments.
empty() && StackRestorePoints.
empty())
795 if (!StaticAllocas.
empty() || !DynamicAllocas.
empty() ||
796 !ByValArguments.
empty())
797 ++NumUnsafeStackFunctions;
799 if (!StackRestorePoints.
empty())
800 ++NumUnsafeStackRestorePointsFunctions;
802 IRBuilder<> IRB(&
F.front(),
F.begin()->getFirstInsertionPt());
807 DILocation::get(
SP->getContext(),
SP->getScopeLine(), 0, SP));
809 const char *SafestackPointerAddressName =
810 TL.getLibcallName(RTLIB::SAFESTACK_POINTER_ADDRESS);
811 if (!SafestackPointerAddressName) {
812 F.getContext().emitError(
813 "no libcall available for safestack pointer address");
818 SafestackPointerAddressName, IRB.
getPtrTy(0));
821 UnsafeStackPtr = TL.getSafeStackPointerLocation(IRB);
827 IRB.
CreateLoad(StackPtrTy, UnsafeStackPtr,
false,
"unsafe_stack_ptr");
832 if (
F.hasFnAttribute(Attribute::StackProtect) ||
833 F.hasFnAttribute(Attribute::StackProtectStrong) ||
834 F.hasFnAttribute(Attribute::StackProtectReq)) {
841 checkStackGuard(IRBRet,
F, *RI, StackGuardSlot, StackGuard);
847 Value *StaticTop = moveStaticAllocasToUnsafeStack(
848 IRB,
F, StaticAllocas, ByValArguments, BasePointer, StackGuardSlot);
856 AllocaInst *DynamicTop = createStackRestorePoints(
857 IRB,
F, StackRestorePoints, StaticTop, !DynamicAllocas.
empty());
860 moveDynamicAllocasToUnsafeStack(
F, UnsafeStackPtr, DynamicTop,
869 TryInlinePointerAddress();
895 if (!
F.hasFnAttribute(Attribute::SafeStack)) {
897 " for this function\n");
901 if (
F.isDeclaration()) {
903 " is not available\n");
908 auto *TL =
TM->getSubtargetImpl(
F)->getTargetLowering();
912 auto *
DL = &
F.getDataLayout();
913 auto &TLI = getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(
F);
914 auto &ACT = getAnalysis<AssumptionCacheTracker>().getAssumptionCache(
F);
921 bool ShouldPreserveDominatorTree;
922 std::optional<DominatorTree> LazilyComputedDomTree;
927 if (
auto *DTWP = getAnalysisIfAvailable<DominatorTreeWrapperPass>()) {
928 DT = &DTWP->getDomTree();
929 ShouldPreserveDominatorTree =
true;
932 LazilyComputedDomTree.emplace(
F);
933 DT = &*LazilyComputedDomTree;
934 ShouldPreserveDominatorTree =
false;
944 return SafeStack(
F, *TL, *
DL, ShouldPreserveDominatorTree ? &DTU :
nullptr,
956 if (!
F.hasFnAttribute(Attribute::SafeStack)) {
958 " for this function\n");
962 if (
F.isDeclaration()) {
964 " is not available\n");
968 auto *TL = TM->getSubtargetImpl(
F)->getTargetLowering();
972 auto &
DL =
F.getDataLayout();
979 bool Changed = SafeStack(
F, *TL,
DL, &DTU, SE).run();
988char SafeStackLegacyPass::ID = 0;
991 "Safe Stack instrumentation pass",
false,
false)
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
This file implements a class to represent arbitrary precision integral constant values and operations...
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
VarLocInsertPt getNextNode(const DbgRecord *DVR)
Expand Atomic instructions
This file contains the simple types necessary to represent the attributes associated with functions a...
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
This file contains the declarations for the subclasses of Constant, which represent the different fla...
global merge Global merge function pass
Module.h This file contains the declarations for the Module class.
This defines the Use class.
uint64_t IntrinsicInst * II
FunctionAnalysisManager FAM
#define INITIALIZE_PASS_DEPENDENCY(depName)
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
#define INITIALIZE_PASS_BEGIN(passName, arg, name, cfg, analysis)
static cl::opt< bool > SafeStackUsePointerAddress("safestack-use-pointer-address", cl::init(false), cl::Hidden)
Use __safestack_pointer_address even if the platform has a faster way of access safe stack pointer.
static cl::opt< bool > ClColoring("safe-stack-coloring", cl::desc("enable safe stack coloring"), cl::Hidden, cl::init(true))
This file defines the SmallPtrSet class.
This file defines the SmallVector class.
static Value * getStackGuard(const TargetLoweringBase *TLI, Module *M, IRBuilder<> &B, bool *SupportsSelectionDAGSP=nullptr)
Create a stack guard loading and populate whether SelectionDAG SSP is supported.
This file defines the 'Statistic' class, which is designed to be an easy way to expose various metric...
#define STATISTIC(VARNAME, DESC)
This file describes how to lower LLVM code to machine code.
Target-Independent Code Generator Pass Configuration Options pass.
Class for arbitrary precision integers.
an instruction to allocate memory on the stack
LLVM_ABI bool isStaticAlloca() const
Return true if this alloca is in the entry block of the function and is a constant size.
Align getAlign() const
Return the alignment of the memory that is being allocated by the instruction.
PointerType * getType() const
Overload to return most specific pointer type.
Type * getAllocatedType() const
Return the type that is being allocated by the instruction.
LLVM_ABI bool isArrayAllocation() const
Return true if there is an allocation size parameter to the allocation instruction that is not 1.
const Value * getArraySize() const
Get the number of elements allocated.
A container for analyses that lazily runs them and caches their results.
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
Represent the analysis usage information of a pass.
AnalysisUsage & addRequired()
AnalysisUsage & addPreserved()
Add the specified Pass class to the set of analyses preserved by this pass.
This class represents an incoming formal argument to a Function.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
bool empty() const
empty - Check if the array is empty.
An immutable pass that tracks lazily created AssumptionCache objects.
static BranchProbability getBranchProbStackProtector(bool IsLikely)
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
bool doesNotCapture(unsigned OpNo) const
Determine whether this data operand is not captured.
Function * getCalledFunction() const
Returns the function called, or null if this is an indirect function invocation or the function signa...
bool doesNotAccessMemory(unsigned OpNo) const
bool hasFnAttr(Attribute::AttrKind Kind) const
Determine whether this call has the given attribute.
User::op_iterator arg_begin()
Return the iterator pointing to the beginning of the argument list.
bool isNoInline() const
Return true if the call should not be inlined.
User::op_iterator arg_end()
Return the iterator pointing to the end of the argument list.
This class represents a function call, abstracting a target machine's calling convention.
This class represents a range of values.
LLVM_ABI ConstantRange add(const ConstantRange &Other) const
Return a new range representing the possible values resulting from an addition of a value in this ran...
LLVM_ABI bool contains(const APInt &Val) const
Return true if the specified value is in the set.
Subprogram description. Uses SubclassData1.
This class represents an Operation in the Expression.
A parsed version of the target data layout string in and methods for querying it.
Analysis pass which computes a DominatorTree.
Legacy analysis pass which computes a DominatorTree.
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
A handy container for a FunctionType+Callee-pointer pair, which can be passed around as a single enti...
FunctionPass class - This class is used to implement most global optimizations.
virtual bool runOnFunction(Function &F)=0
runOnFunction - Virtual method overriden by subclasses to do the per-function processing of the pass.
AllocaInst * CreateAlloca(Type *Ty, unsigned AddrSpace, Value *ArraySize=nullptr, const Twine &Name="")
CallInst * CreateMemCpy(Value *Dst, MaybeAlign DstAlign, Value *Src, MaybeAlign SrcAlign, uint64_t Size, bool isVolatile=false, const AAMDNodes &AAInfo=AAMDNodes())
Create and insert a memcpy between the specified pointers.
Value * CreatePointerCast(Value *V, Type *DestTy, const Twine &Name="")
Value * CreateIntToPtr(Value *V, Type *DestTy, const Twine &Name="")
Value * CreatePtrAdd(Value *Ptr, Value *Offset, const Twine &Name="", GEPNoWrapFlags NW=GEPNoWrapFlags::none())
void SetCurrentDebugLocation(DebugLoc L)
Set location information used by debugging information.
Value * CreateICmpNE(Value *LHS, Value *RHS, const Twine &Name="")
LLVM_ABI CallInst * CreateIntrinsic(Intrinsic::ID ID, ArrayRef< Type * > Types, ArrayRef< Value * > Args, FMFSource FMFSource={}, const Twine &Name="")
Create a call to intrinsic ID with Args, mangled using Types.
Value * CreateSub(Value *LHS, Value *RHS, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
Value * CreateBitCast(Value *V, Type *DestTy, const Twine &Name="")
LoadInst * CreateLoad(Type *Ty, Value *Ptr, const char *Name)
Provided to resolve 'CreateLoad(Ty, Ptr, "...")' correctly, instead of converting the string to 'bool...
Value * CreateAnd(Value *LHS, Value *RHS, const Twine &Name="")
StoreInst * CreateStore(Value *Val, Value *Ptr, bool isVolatile=false)
Value * CreatePtrToInt(Value *V, Type *DestTy, const Twine &Name="")
CallInst * CreateCall(FunctionType *FTy, Value *Callee, ArrayRef< Value * > Args={}, const Twine &Name="", MDNode *FPMathTag=nullptr)
PointerType * getPtrTy(unsigned AddrSpace=0)
Fetch the type representing a pointer.
Value * CreateIntCast(Value *V, Type *DestTy, bool isSigned, const Twine &Name="")
void SetInsertPoint(BasicBlock *TheBB)
This specifies that created instructions should be appended to the end of the specified block.
Type * getVoidTy()
Fetch the type representing void.
Value * CreateMul(Value *LHS, Value *RHS, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
This class captures the data input to the InlineFunction call, and records the auxiliary results prod...
LLVM_ABI InstListType::iterator eraseFromParent()
This method unlinks 'this' from the containing basic block and deletes it.
A wrapper class for inspecting calls to intrinsic functions.
LLVM_ABI MDNode * createBranchWeights(uint32_t TrueWeight, uint32_t FalseWeight, bool IsExpected=false)
Return metadata containing two branch weights.
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
This is the common base class for memset/memcpy/memmove.
A Module instance is used to store all the information related to an LLVM module.
static LLVM_ABI PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
virtual void getAnalysisUsage(AnalysisUsage &) const
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...
A set of analyses that are preserved following a run of a transformation pass.
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
PreservedAnalyses & preserve()
Mark an analysis as preserved.
This class represents an analyzed expression in the program.
LLVM_ABI Type * getType() const
Return the LLVM type of this SCEV expression.
PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM)
Analysis pass that exposes the ScalarEvolution for a function.
The main scalar evolution driver.
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
This class represents a set of interesting instructions where an alloca is live.
Compute live ranges of allocas.
This base class for TargetLowering contains the SelectionDAG-independent parts that can be used from ...
Primary interface to the complete machine description for the target machine.
Target-Independent Code Generator Pass Configuration Options.
The instances of the Type class are immutable: once they are created, they are never changed.
A Use represents the edge between a Value definition and its users.
LLVM Value Representation.
Type * getType() const
All values are typed, get the type of this value.
LLVM_ABI void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
LLVM_ABI StringRef getName() const
Return a constant reference to the value's name.
LLVM_ABI void takeName(Value *V)
Transfer the name from V to this value.
NodeTy * getNextNode()
Get the next node, or nullptr for the list tail.
Compute the layout of an unsafe stack frame.
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
@ C
The default llvm calling convention, compatible with C.
initializer< Ty > init(const Ty &Val)
PointerTypeMap run(const Module &M)
Compute the PointerTypeMap for the module M.
This is an optimization pass for GlobalISel generic memory operations.
LLVM_ABI InlineResult InlineFunction(CallBase &CB, InlineFunctionInfo &IFI, bool MergeAttributes=false, AAResults *CalleeAAR=nullptr, bool InsertLifetime=true, Function *ForwardVarArgsTo=nullptr, OptimizationRemarkEmitter *ORE=nullptr)
This function inlines the called function into the basic block of the caller.
LLVM_ABI FunctionPass * createSafeStackPass()
This pass splits the stack into a safe stack and an unsafe stack to protect against stack-based overf...
iterator_range< early_inc_iterator_impl< detail::IterOfRange< RangeT > > > make_early_inc_range(RangeT &&Range)
Make a range that does early increment to allow mutation of the underlying range without disrupting i...
LLVM_ABI InlineResult isInlineViable(Function &Callee)
Check if it is mechanically possible to inline the function Callee, based on the contents of the func...
LLVM_ABI void initializeSafeStackLegacyPassPass(PassRegistry &)
LLVM_ABI raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
LLVM_ABI void report_fatal_error(Error Err, bool gen_crash_diag=true)
uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
LLVM_ABI void replaceDbgValueForAlloca(AllocaInst *AI, Value *NewAllocaAddress, DIBuilder &Builder, int Offset=0)
Replaces multiple dbg.value records when the alloca it describes is replaced with a new value.
constexpr unsigned BitWidth
LLVM_ABI Instruction * SplitBlockAndInsertIfThen(Value *Cond, BasicBlock::iterator SplitBefore, bool Unreachable, MDNode *BranchWeights=nullptr, DomTreeUpdater *DTU=nullptr, LoopInfo *LI=nullptr, BasicBlock *ThenBlock=nullptr)
Split the containing block at the specified instruction - everything before SplitBefore stays in the ...
LLVM_ABI bool replaceDbgDeclare(Value *Address, Value *NewAddress, DIBuilder &Builder, uint8_t DIExprFlags, int Offset)
Replaces dbg.declare record when the address it describes is replaced with a new value.
This struct is a compact representation of a valid (non-zero power of two) alignment.
uint64_t value() const
This is a hole in the type system and should not be abused.
This struct is a compact representation of a valid (power of two) or undefined (0) alignment.