25#include "llvm/IR/IntrinsicInst.h"
26#include "llvm/IR/Intrinsics.h"
27#include "llvm/IR/IntrinsicsWebAssembly.h"
28#include "llvm/Support/SaveAndRestore.h"
31using namespace CodeGen;
36 llvm::FunctionType *FTy =
43 llvm::FunctionType *FTy =
44 llvm::FunctionType::get(CGM.
VoidTy,
false);
49 llvm::FunctionType *FTy =
50 llvm::FunctionType::get(CGM.
VoidTy,
false);
57 llvm::FunctionType *FTy =
66 llvm::FunctionType *FTy =
67 llvm::FunctionType::get(
VoidTy,
false);
74 name =
"_ZSt9terminatev";
78 name =
"__std_terminate";
80 name =
"?terminate@@YAXXZ";
83 name =
"objc_terminate";
91 llvm::FunctionType *FTy =
133 const llvm::Triple &T =
Target.getTriple();
134 if (T.isWindowsMSVCEnvironment())
147 const llvm::Triple &T =
Target.getTriple();
148 if (T.isWindowsMSVCEnvironment())
170 llvm_unreachable(
"bad runtime kind");
175 const llvm::Triple &T =
Target.getTriple();
176 if (T.isWindowsMSVCEnvironment())
195 if (
Target.getTriple().isWindowsMSVCEnvironment())
221 llvm_unreachable(
"bad runtime kind");
225 if (T.getArch() == llvm::Triple::x86)
253 return get(CGF.
CGM, dyn_cast_or_null<FunctionDecl>(FD));
260 llvm::AttributeList(),
true);
266 llvm::PointerType* Int8PtrTy = llvm::PointerType::get(
270 return llvm::ConstantExpr::getBitCast(cast<llvm::Constant>(Fn.getCallee()),
276 for (
unsigned I = 0, E = LPI->getNumClauses(); I != E; ++I) {
279 llvm::Value *Val = LPI->getClause(I)->stripPointerCasts();
280 if (LPI->isCatch(I)) {
282 if (llvm::GlobalVariable *GV = dyn_cast<llvm::GlobalVariable>(Val))
285 if (GV->getName().startswith(
"OBJC_EHTYPE"))
289 llvm::Constant *CVal = cast<llvm::Constant>(Val);
290 for (llvm::User::op_iterator
291 II = CVal->op_begin(), IE = CVal->op_end(); II != IE; ++II) {
292 if (llvm::GlobalVariable *GV =
293 cast<llvm::GlobalVariable>((*II)->stripPointerCasts()))
296 if (GV->getName().startswith(
"OBJC_EHTYPE"))
307 for (llvm::User *
U : Fn->users()) {
309 if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(
U)) {
310 if (CE->getOpcode() != llvm::Instruction::BitCast)
return false;
317 llvm::Function *F = dyn_cast<llvm::Function>(
U);
318 if (!F)
return false;
320 for (
auto BB = F->begin(), E = F->end(); BB != E; ++BB) {
321 if (BB->isLandingPad())
334void CodeGenModule::SimplifyPersonality() {
336 if (!LangOpts.CPlusPlus || !LangOpts.ObjC || !LangOpts.Exceptions)
349 assert(std::strcmp(
ObjCXX.PersonalityFn,
CXX.PersonalityFn) != 0 &&
350 "Different EHPersonalities using the same personality function.");
355 if (!Fn || Fn->use_empty())
return;
365 if (Fn->getType() != CXXFn.getCallee()->getType())
368 Fn->replaceAllUsesWith(CXXFn.getCallee());
369 Fn->eraseFromParent();
376 return llvm::ConstantPointerNull::get(CGF.
Int8PtrTy);
384 FreeException(llvm::Value *exn) : exn(exn) {}
418 cast<llvm::Instruction>(typedAddr.
getPointer()));
442 bool KeepInsertionPoint) {
444 QualType ThrowType = SubExpr->getType();
458 if (KeepInsertionPoint)
466 const FunctionDecl* FD = dyn_cast_or_null<FunctionDecl>(D);
469 if (
const CapturedDecl* CD = dyn_cast_or_null<CapturedDecl>(D)) {
497 diag::warn_wasm_dynamic_exception_spec_ignored)
511 diag::warn_wasm_dynamic_exception_spec_ignored)
517 for (
unsigned I = 0; I != NumExceptions; ++I) {
522 Filter->setFilter(I, EHType);
535 if (!dispatchBlock)
return;
536 if (dispatchBlock->use_empty()) {
537 delete dispatchBlock;
550 llvm::Value *zero = CGF.
Builder.getInt32(0);
551 llvm::Value *failsFilter =
552 CGF.
Builder.CreateICmpSLT(selector, zero,
"ehspec.fails");
553 CGF.
Builder.CreateCondBr(failsFilter, unexpectedBB,
565 ->setDoesNotReturn();
566 CGF.
Builder.CreateUnreachable();
573 const FunctionDecl* FD = dyn_cast_or_null<FunctionDecl>(D);
576 if (
const CapturedDecl* CD = dyn_cast_or_null<CapturedDecl>(D)) {
618 unsigned NumHandlers = S.getNumHandlers();
621 for (
unsigned I = 0; I != NumHandlers; ++I) {
625 if (
C->getExceptionDecl()) {
634 C->getCaughtType().getNonReferenceType(), CaughtTypeQuals);
641 CaughtType,
C->getCaughtType());
668 if (!dispatchBlock) {
698 return dispatchBlock;
713 return DispatchBlock;
723 DispatchBlock->setName(
"catch.dispatch");
727 DispatchBlock->setName(
"ehcleanup");
731 llvm_unreachable(
"exception specifications not handled yet!");
734 DispatchBlock->setName(
"terminate");
738 return DispatchBlock;
745 switch (S.getKind()) {
747 return !cast<EHCleanupScope>(S).isEHCleanup();
754 llvm_unreachable(
"Invalid EHScope Kind!");
766 if (!LO.Exceptions || LO.IgnoreExceptions) {
767 if (!LO.Borland && !LO.MicrosoftExt)
774 if (LO.CUDA && LO.CUDAIsDevice)
784 if (!
CurFn->hasPersonalityFn())
800 ir->setCachedLandingPad(LP);
810 "LandingPad should not be emitted when -fignore-exceptions are in "
813 switch (innermostEHScope.
getKind()) {
825 CGBuilderTy::InsertPoint savedIP =
Builder.saveAndClearIP();
832 llvm::LandingPadInst *LPadInst =
835 llvm::Value *LPadExn =
Builder.CreateExtractValue(LPadInst, 0);
837 llvm::Value *LPadSel =
Builder.CreateExtractValue(LPadInst, 1);
846 bool hasCatchAll =
false;
847 bool hasCleanup =
false;
848 bool hasFilter =
false;
854 switch (I->getKind()) {
857 hasCleanup = (hasCleanup || cast<EHCleanupScope>(*I).isEHCleanup());
861 assert(I.next() ==
EHStack.
end() &&
"EH filter is not end of EH stack");
862 assert(!hasCatchAll &&
"EH filter reached after catch-all");
869 for (
unsigned i = 0, e = filter.
getNumFilters(); i != e; ++i)
870 filterTypes.push_back(filter.
getFilter(i));
876 assert(!hasCatchAll);
885 for (
unsigned hi = 0, he = catchScope.
getNumHandlers(); hi != he; ++hi) {
888 "landingpads do not support catch handler flags");
892 assert(!hasCatchAll);
898 if (catchTypes.insert(handler.
Type.
RTTI).second)
900 LPadInst->addClause(handler.
Type.
RTTI);
906 assert(!(hasCatchAll && hasFilter));
912 }
else if (hasFilter) {
917 llvm::ArrayType *AType =
918 llvm::ArrayType::get(!filterTypes.empty() ?
922 for (
unsigned i = 0, e = filterTypes.size(); i != e; ++i)
923 Filters.push_back(cast<llvm::Constant>(filterTypes[i]));
924 llvm::Constant *FilterArray = llvm::ConstantArray::get(AType, Filters);
925 LPadInst->addClause(FilterArray);
929 LPadInst->setCleanup(
true);
932 }
else if (hasCleanup) {
933 LPadInst->setCleanup(
true);
936 assert((LPadInst->getNumClauses() > 0 || LPadInst->isCleanup()) &&
937 "landingpad instruction has no clauses!");
950 assert(DispatchBlock);
952 CGBuilderTy::InsertPoint SavedIP = CGF.
Builder.saveIP();
958 llvm::BasicBlock *UnwindBB =
962 llvm::CatchSwitchInst *CatchSwitch =
963 CGF.
Builder.CreateCatchSwitch(ParentPad, UnwindBB, NumHandlers);
966 for (
unsigned I = 0; I < NumHandlers; ++I) {
978 llvm::Constant::getNullValue(CGF.
VoidPtrTy)});
983 CatchSwitch->addHandler(Handler.
Block);
985 CGF.
Builder.restoreIP(SavedIP);
994 assert(DispatchBlock);
996 CGBuilderTy::InsertPoint SavedIP = CGF.
Builder.saveIP();
1002 llvm::BasicBlock *UnwindBB =
1006 llvm::CatchSwitchInst *CatchSwitch =
1007 CGF.
Builder.CreateCatchSwitch(ParentPad, UnwindBB, NumHandlers);
1011 llvm::BasicBlock *WasmCatchStartBlock = CGF.
createBasicBlock(
"catch.start");
1012 CatchSwitch->addHandler(WasmCatchStartBlock);
1017 for (
unsigned I = 0, E = NumHandlers; I < E; ++I) {
1022 CatchTypes.push_back(
TypeInfo.RTTI);
1024 auto *CPI = CGF.
Builder.CreateCatchPad(CatchSwitch, CatchTypes);
1029 llvm::Function *GetExnFn =
1031 llvm::Function *GetSelectorFn =
1033 llvm::CallInst *Exn = CGF.
Builder.CreateCall(GetExnFn, CPI);
1035 llvm::CallInst *
Selector = CGF.
Builder.CreateCall(GetSelectorFn, CPI);
1037 llvm::Function *TypeIDFn = CGF.
CGM.
getIntrinsic(llvm::Intrinsic::eh_typeid_for);
1043 CGF.
Builder.restoreIP(SavedIP);
1048 for (
unsigned I = 0, E = NumHandlers;; ++I) {
1049 assert(I < E &&
"ran off end of handlers!");
1056 llvm::BasicBlock *NextBlock;
1058 bool EmitNextBlock =
false, NextIsEnd =
false;
1065 EmitNextBlock =
true;
1077 EmitNextBlock =
true;
1081 llvm::CallInst *TypeIndex = CGF.
Builder.CreateCall(TypeIDFn,
TypeInfo.RTTI);
1082 TypeIndex->setDoesNotThrow();
1084 llvm::Value *MatchesTypeIndex =
1086 CGF.
Builder.CreateCondBr(MatchesTypeIndex, Handler.
Block, NextBlock);
1094 CGF.
Builder.restoreIP(SavedIP);
1107 assert(dispatchBlock);
1117 CGBuilderTy::InsertPoint savedIP = CGF.
Builder.saveIP();
1121 llvm::Function *llvm_eh_typeid_for =
1129 assert(i < e &&
"ran off end of handlers!");
1132 llvm::Value *typeValue = handler.
Type.
RTTI;
1134 "landingpads do not support catch handler flags");
1135 assert(typeValue &&
"fell into catch-all case!");
1140 llvm::BasicBlock *nextBlock;
1161 llvm::CallInst *typeIndex =
1162 CGF.
Builder.CreateCall(llvm_eh_typeid_for, typeValue);
1163 typeIndex->setDoesNotThrow();
1165 llvm::Value *matchesTypeIndex =
1166 CGF.
Builder.CreateICmpEQ(selector, typeIndex,
"matches");
1167 CGF.
Builder.CreateCondBr(matchesTypeIndex, handler.
Block, nextBlock);
1171 CGF.
Builder.restoreIP(savedIP);
1187 unsigned NumHandlers = S.getNumHandlers();
1205 CatchScope.
begin(), CatchScope.
begin() + NumHandlers);
1218 bool doImplicitRethrow =
false;
1220 doImplicitRethrow = isa<CXXDestructorDecl>(
CurCodeDecl) ||
1227 llvm::BasicBlock *WasmCatchStartBlock =
nullptr;
1230 cast<llvm::CatchSwitchInst>(DispatchBlock->getFirstNonPHI());
1231 WasmCatchStartBlock = CatchSwitch->hasUnwindDest()
1232 ? CatchSwitch->getSuccessor(1)
1233 : CatchSwitch->getSuccessor(0);
1234 auto *CPI = cast<llvm::CatchPadInst>(WasmCatchStartBlock->getFirstNonPHI());
1245 bool HasCatchAll =
false;
1246 for (
unsigned I = NumHandlers; I != 0; --I) {
1247 HasCatchAll |= Handlers[I - 1].isCatchAll();
1248 llvm::BasicBlock *CatchBlock = Handlers[I-1].Block;
1256 RunCleanupsScope CatchScope(*
this);
1280 Builder.ClearInsertionPoint();
1284 CatchScope.ForceCleanup();
1296 assert(WasmCatchStartBlock);
1301 llvm::BasicBlock *RethrowBlock = WasmCatchStartBlock;
1302 while (llvm::Instruction *TI = RethrowBlock->getTerminator()) {
1303 auto *BI = cast<llvm::BranchInst>(TI);
1304 assert(BI->isConditional());
1305 RethrowBlock = BI->getSuccessor(1);
1307 assert(RethrowBlock != WasmCatchStartBlock && RethrowBlock->empty());
1308 Builder.SetInsertPoint(RethrowBlock);
1309 llvm::Function *RethrowInCatchFn =
1320 llvm::Value *ForEHVar;
1321 llvm::FunctionCallee EndCatchFn;
1322 CallEndCatchForFinally(llvm::Value *ForEHVar,
1323 llvm::FunctionCallee EndCatchFn)
1324 : ForEHVar(ForEHVar), EndCatchFn(EndCatchFn) {}
1328 llvm::BasicBlock *CleanupContBB =
1331 llvm::Value *ShouldEndCatch =
1333 CGF.
Builder.CreateCondBr(ShouldEndCatch, EndCatchBB, CleanupContBB);
1342 llvm::Value *ForEHVar;
1343 llvm::FunctionCallee EndCatchFn;
1344 llvm::FunctionCallee RethrowFn;
1345 llvm::Value *SavedExnVar;
1347 PerformFinally(
const Stmt *Body, llvm::Value *ForEHVar,
1348 llvm::FunctionCallee EndCatchFn,
1349 llvm::FunctionCallee RethrowFn, llvm::Value *SavedExnVar)
1350 : Body(Body), ForEHVar(ForEHVar), EndCatchFn(EndCatchFn),
1351 RethrowFn(RethrowFn), SavedExnVar(SavedExnVar) {}
1357 ForEHVar, EndCatchFn);
1361 llvm::Value *SavedCleanupDest =
1363 "cleanup.dest.saved");
1374 llvm::Value *ShouldRethrow =
1376 CGF.
Builder.CreateCondBr(ShouldRethrow, RethrowBB, ContBB);
1386 CGF.
Builder.CreateUnreachable();
1399 CGBuilderTy::InsertPoint SavedIP = CGF.
Builder.saveAndClearIP();
1401 CGF.
Builder.restoreIP(SavedIP);
1415 llvm::FunctionCallee beginCatchFn,
1416 llvm::FunctionCallee endCatchFn,
1417 llvm::FunctionCallee rethrowFn) {
1418 assert((!!beginCatchFn) == (!!endCatchFn) &&
1419 "begin/end catch functions not paired");
1420 assert(rethrowFn &&
"rethrow function is required");
1422 BeginCatchFn = beginCatchFn;
1430 llvm::FunctionType *rethrowFnTy = rethrowFn.getFunctionType();
1431 SavedExnVar =
nullptr;
1432 if (rethrowFnTy->getNumParams())
1458 ForEHVar, endCatchFn,
1459 rethrowFn, SavedExnVar);
1475 if (catchBB->use_empty()) {
1478 CGBuilderTy::InsertPoint savedIP = CGF.
Builder.saveAndClearIP();
1481 llvm::Value *exn =
nullptr;
1501 CGF.
Builder.restoreIP(savedIP);
1509 if (TerminateLandingPad)
1510 return TerminateLandingPad;
1512 CGBuilderTy::InsertPoint SavedIP =
Builder.saveAndClearIP();
1516 Builder.SetInsertPoint(TerminateLandingPad);
1521 if (!
CurFn->hasPersonalityFn())
1524 llvm::LandingPadInst *LPadInst =
1528 llvm::Value *Exn =
nullptr;
1530 Exn =
Builder.CreateExtractValue(LPadInst, 0);
1531 llvm::CallInst *terminateCall =
1533 terminateCall->setDoesNotReturn();
1539 return TerminateLandingPad;
1543 if (TerminateHandler)
1544 return TerminateHandler;
1549 CGBuilderTy::InsertPoint SavedIP =
Builder.saveAndClearIP();
1550 Builder.SetInsertPoint(TerminateHandler);
1552 llvm::Value *Exn =
nullptr;
1555 llvm::CallInst *terminateCall =
1557 terminateCall->setDoesNotReturn();
1563 return TerminateHandler;
1568 "use getTerminateLandingPad for non-funclet EH");
1571 if (TerminateFunclet)
1572 return TerminateFunclet;
1574 CGBuilderTy::InsertPoint SavedIP =
Builder.saveAndClearIP();
1579 Builder.SetInsertPoint(TerminateFunclet);
1590 llvm::CallInst *terminateCall =
1592 terminateCall->setDoesNotReturn();
1598 return TerminateFunclet;
1604 CGBuilderTy::InsertPoint SavedIP =
Builder.saveIP();
1615 if (RethrowName !=
nullptr && !isCleanup) {
1627 llvm::Type *LPadType = llvm::StructType::get(Exn->getType(), Sel->getType());
1628 llvm::Value *LPadVal = llvm::PoisonValue::get(LPadType);
1629 LPadVal =
Builder.CreateInsertValue(LPadVal, Exn, 0,
"lpad.val");
1630 LPadVal =
Builder.CreateInsertValue(LPadVal, Sel, 1,
"lpad.val");
1632 Builder.CreateResume(LPadVal);
1644 llvm::BasicBlock *TryBB =
nullptr;
1649 TryBB =
Builder.GetInsertBlock();
1662 if (!TryExit.getBlock()->use_empty())
1665 delete TryExit.getBlock();
1675 !
V.insert(BB).second ||
1676 !BB->getParent() || BB->empty())
1679 if (!BB->isEHPad()) {
1680 for (llvm::BasicBlock::iterator J = BB->begin(), JE = BB->end(); J != JE;
1682 if (
auto LI = dyn_cast<llvm::LoadInst>(J)) {
1683 LI->setVolatile(
true);
1684 }
else if (
auto SI = dyn_cast<llvm::StoreInst>(J)) {
1685 SI->setVolatile(
true);
1686 }
else if (
auto* MCI = dyn_cast<llvm::MemIntrinsic>(J)) {
1687 MCI->setVolatile(llvm::ConstantInt::get(
Builder.getInt1Ty(), 1));
1691 const llvm::Instruction *TI = BB->getTerminator();
1693 unsigned N = TI->getNumSuccessors();
1694 for (
unsigned I = 0; I < N; I++)
1701 llvm::Function *OutlinedFinally;
1702 PerformSEHFinally(llvm::Function *OutlinedFinally)
1703 : OutlinedFinally(OutlinedFinally) {}
1713 llvm::Value *FP =
nullptr;
1716 FP = &CGF.
CurFn->arg_begin()[1];
1718 llvm::Function *LocalAddrFn =
1720 FP = CGF.
Builder.CreateCall(LocalAddrFn);
1723 llvm::Value *IsForEH =
1724 llvm::ConstantInt::get(CGF.
ConvertType(ArgTys[0]), F.isForEHCleanup());
1731 if (!F.isForEHCleanup() && F.hasExitSwitch()) {
1734 llvm::Value *
Zero = llvm::Constant::getNullValue(CGM.
Int32Ty);
1735 IsForEH = CGF.
Builder.CreateICmpNE(Load, Zero);
1759 : ParentCGF(ParentCGF), ParentThis(ParentThis) {}
1762 bool foundCaptures() {
1763 return !Captures.empty() || SEHCodeSlot.
isValid();
1766 void Visit(
const Stmt *S) {
1769 for (
const Stmt *Child : S->children())
1777 Captures.insert(ParentThis);
1779 const auto *D = dyn_cast<VarDecl>(E->
getDecl());
1780 if (D && D->isLocalVarDeclOrParm() && D->hasLocalStorage())
1785 Captures.insert(ParentThis);
1788 void VisitCallExpr(
const CallExpr *E) {
1795 case Builtin::BI__exception_code:
1796 case Builtin::BI_exception_code:
1810 llvm::Value *ParentFP) {
1811 llvm::CallInst *RecoverCall =
nullptr;
1813 if (
auto *ParentAlloca = dyn_cast<llvm::AllocaInst>(ParentVar.
getPointer())) {
1816 auto InsertPair =
ParentCGF.EscapedLocals.insert(
1817 std::make_pair(ParentAlloca,
ParentCGF.EscapedLocals.size()));
1818 int FrameEscapeIdx = InsertPair.first->second;
1820 llvm::Function *FrameRecoverFn = llvm::Intrinsic::getDeclaration(
1822 llvm::Constant *ParentI8Fn =
1824 RecoverCall =
Builder.CreateCall(
1825 FrameRecoverFn, {ParentI8Fn, ParentFP,
1826 llvm::ConstantInt::get(
Int32Ty, FrameEscapeIdx)});
1832 auto *ParentRecover =
1833 cast<llvm::IntrinsicInst>(ParentVar.
getPointer()->stripPointerCasts());
1834 assert(ParentRecover->getIntrinsicID() == llvm::Intrinsic::localrecover &&
1835 "expected alloca or localrecover in parent LocalDeclMap");
1836 RecoverCall = cast<llvm::CallInst>(ParentRecover->clone());
1837 RecoverCall->setArgOperand(1, ParentFP);
1842 llvm::Value *ChildVar =
1844 ChildVar->setName(ParentVar.
getName());
1849 const Stmt *OutlinedStmt,
1853 Finder.Visit(OutlinedStmt);
1857 if (!Finder.foundCaptures() &&
1864 llvm::Value *EntryFP =
nullptr;
1872 {Builder.getInt32(1)});
1876 auto AI =
CurFn->arg_begin();
1881 llvm::Value *ParentFP = EntryFP;
1886 llvm::Function *RecoverFPIntrin =
1888 llvm::Constant *ParentI8Fn =
1890 ParentFP =
Builder.CreateCall(RecoverFPIntrin, {ParentI8Fn, EntryFP});
1902 llvm::AllocaInst *FramePtrAddrAlloca =
nullptr;
1903 for (
auto &I :
ParentCGF.LocalDeclMap) {
1904 const VarDecl *D = cast<VarDecl>(I.first);
1905 if (isa<ImplicitParamDecl>(D) &&
1907 assert(D->
getName().startswith(
"frame_pointer"));
1908 FramePtrAddrAlloca = cast<llvm::AllocaInst>(I.second.getPointer());
1912 assert(FramePtrAddrAlloca);
1913 auto InsertPair =
ParentCGF.EscapedLocals.insert(
1914 std::make_pair(FramePtrAddrAlloca,
ParentCGF.EscapedLocals.size()));
1915 int FrameEscapeIdx = InsertPair.first->second;
1923 llvm::Function *FrameRecoverFn = llvm::Intrinsic::getDeclaration(
1925 llvm::Constant *ParentI8Fn =
1927 ParentFP =
Builder.CreateCall(
1928 FrameRecoverFn, {ParentI8Fn, ParentFP,
1929 llvm::ConstantInt::get(
Int32Ty, FrameEscapeIdx)});
1937 for (
const VarDecl *VD : Finder.Captures) {
1943 "captured non-local variable");
1953 auto I =
ParentCGF.LocalDeclMap.find(VD);
1957 Address ParentVar = I->second;
1960 setAddrOfLocalVar(VD, Recovered);
1962 if (isa<ImplicitParamDecl>(VD)) {
1963 CXXABIThisAlignment =
ParentCGF.CXXABIThisAlignment;
1964 CXXThisAlignment =
ParentCGF.CXXThisAlignment;
1979 CXXThisValue = CXXABIThisValue;
1984 if (Finder.SEHCodeSlot.isValid()) {
1998 const Stmt *OutlinedStmt) {
2004 llvm::raw_svector_ostream
OS(Name);
2006 assert(ParentSEHFn &&
"No CurSEHParent!");
2021 &
getContext().Idents.get(
"exception_pointers"),
2026 &
getContext().Idents.get(
"abnormal_termination"),
2041 llvm::Function *Fn = llvm::Function::Create(
2042 FnTy, llvm::GlobalValue::InternalLinkage, Name.str(), &
CGM.
getModule());
2089 llvm::Value *ParentFP,
2090 llvm::Value *EntryFP) {
2117 llvm::Type *RecordTy =
CGM.
Int32Ty->getPointerTo();
2118 llvm::Type *PtrsTy = llvm::StructType::get(RecordTy,
CGM.
VoidPtrTy);
2119 llvm::Value *Ptrs =
Builder.CreateBitCast(
SEHInfo, PtrsTy->getPointerTo());
2123 assert(!
SEHCodeSlotStack.empty() &&
"emitting EH code outside of __except");
2131 return llvm::UndefValue::get(
Int8PtrTy);
2137 assert(!
SEHCodeSlotStack.empty() &&
"emitting EH code outside of __except");
2144 auto AI =
CurFn->arg_begin();
2149 llvm::Function *FinallyFunc) {
2150 EHStack.pushCleanup<PerformSEHFinally>(
Kind, FinallyFunc);
2155 HelperCGF.ParentCGF =
this;
2158 llvm::Function *FinallyFunc =
2159 HelperCGF.GenerateSEHFinallyFunction(*
this, *Finally);
2187 llvm::Function *FilterFunc =
2188 HelperCGF.GenerateSEHFilterFunction(*
this, *Except);
2189 llvm::Constant *OpaqueFunc =
2190 llvm::ConstantExpr::getBitCast(FilterFunc,
Int8PtrTy);
2196 if (S.getFinallyHandler()) {
2209 assert(Except &&
"__try must have __finally xor __except");
2240 llvm::CatchPadInst *CPI =
2241 cast<llvm::CatchPadInst>(CatchPadBB->getFirstNonPHI());
2243 Builder.CreateCatchRet(CPI, ExceptBB);
2248 llvm::Function *SEHCodeIntrin =
2250 llvm::Value *Code =
Builder.CreateCall(SEHCodeIntrin, {CPI});
2277 Builder.ClearInsertionPoint();
static llvm::FunctionCallee getUnexpectedFn(CodeGenModule &CGM)
static const EHPersonality & getObjCPersonality(const TargetInfo &Target, const LangOptions &L)
static const EHPersonality & getSEHPersonalityMSVC(const llvm::Triple &T)
static const EHPersonality & getCXXPersonality(const TargetInfo &Target, const LangOptions &L)
static llvm::FunctionCallee getPersonalityFn(CodeGenModule &CGM, const EHPersonality &Personality)
static void emitFilterDispatchBlock(CodeGenFunction &CGF, EHFilterScope &filterScope)
Emit the dispatch block for a filter scope if necessary.
static void emitCatchPadBlock(CodeGenFunction &CGF, EHCatchScope &CatchScope)
static llvm::FunctionCallee getFreeExceptionFn(CodeGenModule &CGM)
static llvm::FunctionCallee getSehTryEndFn(CodeGenModule &CGM)
static bool LandingPadHasOnlyCXXUses(llvm::LandingPadInst *LPI)
Check whether a landingpad instruction only uses C++ features.
static bool PersonalityHasOnlyCXXUses(llvm::Constant *Fn)
Check whether a personality function could reasonably be swapped for a C++ personality function.
static void emitCatchDispatchBlock(CodeGenFunction &CGF, EHCatchScope &catchScope)
Emit the structure of the dispatch block for the given catch scope.
static llvm::Constant * getOpaquePersonalityFn(CodeGenModule &CGM, const EHPersonality &Personality)
static bool isNonEHScope(const EHScope &S)
Check whether this is a non-EH scope, i.e.
static llvm::FunctionCallee getCatchallRethrowFn(CodeGenModule &CGM, StringRef Name)
static llvm::FunctionCallee getSehTryBeginFn(CodeGenModule &CGM)
static llvm::Constant * getCatchAllValue(CodeGenFunction &CGF)
Returns the value to inject into a selector to indicate the presence of a catch-all.
static const EHPersonality & getObjCXXPersonality(const TargetInfo &Target, const LangOptions &L)
Determines the personality function to use when both C++ and Objective-C exceptions are being caught.
static void emitWasmCatchPadBlock(CodeGenFunction &CGF, EHCatchScope &CatchScope)
static const EHPersonality & getCPersonality(const TargetInfo &Target, const LangOptions &L)
Defines the Objective-C statement AST node classes.
Enumerates target-specific builtins in their own namespaces within namespace clang.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
QualType getUnqualifiedArrayType(QualType T, Qualifiers &Quals)
Return this type as a completely-unqualified array type, capturing the qualifiers in Quals.
CanQualType UnsignedCharTy
CXXCatchStmt - This represents a C++ catch block.
Represents the this expression in C++.
A C++ throw-expression (C++ [except.throw]).
const Expr * getSubExpr() const
CXXTryStmt - A C++ try block, including all handlers.
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
unsigned getBuiltinCallee() const
getBuiltinCallee - If this is a call to a builtin, return the builtin ID of the callee.
Represents the body of a CapturedStmt, and serves as its DeclContext.
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
Address withPointer(llvm::Value *NewPointer, KnownNonNull_t IsKnownNonNull) const
Return address with different pointer, but same element type and alignment.
llvm::Value * getPointer() const
llvm::StringRef getName() const
Return the IR name of the pointer value.
llvm::PointerType * getType() const
Return the type of the pointer value.
static ApplyDebugLocation CreateDefaultArtificial(CodeGenFunction &CGF, SourceLocation TemporaryLocation)
Apply TemporaryLocation if it is valid.
llvm::StoreInst * CreateFlagStore(bool Value, llvm::Value *Addr)
Emit a store to an i1 flag variable.
llvm::StoreInst * CreateStore(llvm::Value *Val, Address Addr, bool IsVolatile=false)
llvm::StoreInst * CreateAlignedStore(llvm::Value *Val, llvm::Value *Addr, CharUnits Align, bool IsVolatile=false)
Address CreateElementBitCast(Address Addr, llvm::Type *Ty, const llvm::Twine &Name="")
Cast the element type of the given address to a different type, preserving information like the align...
Address CreateStructGEP(Address Addr, unsigned Index, const llvm::Twine &Name="")
llvm::LoadInst * CreateLoad(Address Addr, const llvm::Twine &Name="")
llvm::LoadInst * CreateFlagLoad(llvm::Value *Addr, const llvm::Twine &Name="")
Emit a load from an i1 flag variable.
llvm::LoadInst * CreateAlignedLoad(llvm::Type *Ty, llvm::Value *Addr, CharUnits Align, const llvm::Twine &Name="")
virtual void emitBeginCatch(CodeGenFunction &CGF, const CXXCatchStmt *C)=0
virtual void emitRethrow(CodeGenFunction &CGF, bool isNoReturn)=0
virtual llvm::CallInst * emitTerminateForUnexpectedException(CodeGenFunction &CGF, llvm::Value *Exn)
virtual CatchTypeInfo getCatchAllTypeInfo()
virtual void emitThrow(CodeGenFunction &CGF, const CXXThrowExpr *E)=0
virtual CatchTypeInfo getAddrOfCXXCatchHandlerType(QualType Ty, QualType CatchHandlerType)=0
MangleContext & getMangleContext()
Gets the mangle context.
static CGCallee forDirect(llvm::Constant *functionPtr, const CGCalleeInfo &abstractInfo=CGCalleeInfo())
CGFunctionInfo - Class to encapsulate the information about a function definition.
virtual llvm::Constant * GetEHType(QualType T)=0
Get the type constant to catch for the given ObjC pointer type.
virtual void EmitThrowStmt(CodeGen::CodeGenFunction &CGF, const ObjCAtThrowStmt &S, bool ClearInsertionPoint=true)=0
CallArgList - Type for representing both the value and type of arguments in a call.
void add(RValue rvalue, QualType type)
void exit(CodeGenFunction &CGF)
void enter(CodeGenFunction &CGF, const Stmt *Finally, llvm::FunctionCallee beginCatchFn, llvm::FunctionCallee endCatchFn, llvm::FunctionCallee rethrowFn)
Enters a finally block for an implementation using zero-cost exceptions.
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
llvm::BasicBlock * getEHDispatchBlock(EHScopeStack::stable_iterator scope)
void FinishFunction(SourceLocation EndLoc=SourceLocation())
FinishFunction - Complete IR generation of the current function.
void DeactivateCleanupBlock(EHScopeStack::stable_iterator Cleanup, llvm::Instruction *DominatingIP)
DeactivateCleanupBlock - Deactivates the given cleanup block.
void EnterSEHTryStmt(const SEHTryStmt &S)
Address getExceptionSlot()
Returns a pointer to the function's exception object and selector slot, which is assigned in every la...
void PopCleanupBlock(bool FallThroughIsBranchThrough=false)
PopCleanupBlock - Will pop the cleanup entry on the stack and process all branch fixups.
void VolatilizeTryBlocks(llvm::BasicBlock *BB, llvm::SmallPtrSet< llvm::BasicBlock *, 10 > &V)
llvm::Function * GenerateSEHFinallyFunction(CodeGenFunction &ParentCGF, const SEHFinallyStmt &Finally)
llvm::Function * GenerateSEHFilterFunction(CodeGenFunction &ParentCGF, const SEHExceptStmt &Except)
JumpDest getJumpDestInCurrentScope(llvm::BasicBlock *Target)
The given basic block lies in the current EH scope, but may be a target of a potentially scope-crossi...
llvm::BasicBlock * getInvokeDestImpl()
bool IsOutlinedSEHHelper
True if the current function is an outlined SEH helper.
void startOutlinedSEHHelper(CodeGenFunction &ParentCGF, bool IsFilter, const Stmt *OutlinedStmt)
SmallVector< Address, 1 > SEHCodeSlotStack
A stack of exception code slots.
FieldDecl * LambdaThisCaptureField
void EmitCXXTryStmt(const CXXTryStmt &S)
void popCatchScope()
popCatchScope - Pops the catch scope at the top of the EHScope stack, emitting any required code (oth...
void EmitEndEHSpec(const Decl *D)
EmitEndEHSpec - Emit the end of the exception spec.
void EmitAnyExprToExn(const Expr *E, Address Addr)
bool isSEHTryScope() const
Returns true inside SEH __try blocks.
void EmitSEHExceptionCodeSave(CodeGenFunction &ParentCGF, llvm::Value *ParentFP, llvm::Value *EntryEBP)
llvm::BasicBlock * getEHResumeBlock(bool isCleanup)
llvm::BasicBlock * createBasicBlock(const Twine &name="", llvm::Function *parent=nullptr, llvm::BasicBlock *before=nullptr)
createBasicBlock - Create an LLVM basic block.
llvm::Value * EmitSEHExceptionInfo()
const LangOptions & getLangOpts() const
llvm::BasicBlock * EHResumeBlock
EHResumeBlock - Unified block containing a call to llvm.eh.resume.
void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false)
EmitBlock - Emit the given block.
llvm::AllocaInst * CreateTempAlloca(llvm::Type *Ty, const Twine &Name="tmp", llvm::Value *ArraySize=nullptr)
CreateTempAlloca - This creates an alloca and inserts it into the entry block if ArraySize is nullptr...
llvm::AllocaInst * EHSelectorSlot
The selector slot.
RValue EmitLoadOfLValue(LValue V, SourceLocation Loc)
EmitLoadOfLValue - Given an expression that represents a value lvalue, this method emits the address ...
void EmitAnyExprToMem(const Expr *E, Address Location, Qualifiers Quals, bool IsInitializer)
EmitAnyExprToMem - Emits the code necessary to evaluate an arbitrary expression into the given memory...
void EmitBlockAfterUses(llvm::BasicBlock *BB)
EmitBlockAfterUses - Emit the given block somewhere hopefully near its uses, and leave the insertion ...
llvm::BasicBlock * getTerminateFunclet()
getTerminateLandingPad - Return a cleanup funclet that just calls terminate.
RValue EmitCall(const CGFunctionInfo &CallInfo, const CGCallee &Callee, ReturnValueSlot ReturnValue, const CallArgList &Args, llvm::CallBase **callOrInvoke, bool IsMustTail, SourceLocation Loc)
EmitCall - Generate a call of the given function, expecting the given result type,...
llvm::Type * ConvertTypeForMem(QualType T)
const Decl * CurCodeDecl
CurCodeDecl - This is the inner-most code context, which includes blocks.
llvm::BasicBlock * getUnreachableBlock()
llvm::AssertingVH< llvm::Instruction > AllocaInsertPt
AllocaInsertPoint - This is an instruction in the entry block before which we prefer to insert alloca...
bool currentFunctionUsesSEHTry() const
llvm::SmallVector< const JumpDest *, 2 > SEHTryEpilogueStack
CodeGenFunction * ParentCGF
llvm::Value * ExceptionSlot
The exception slot.
void EmitSEHLeaveStmt(const SEHLeaveStmt &S)
const TargetInfo & getTarget() const
Address getNormalCleanupDestSlot()
llvm::Value * EmitSEHExceptionCode()
void pushSEHCleanup(CleanupKind kind, llvm::Function *FinallyFunc)
void StartFunction(GlobalDecl GD, QualType RetTy, llvm::Function *Fn, const CGFunctionInfo &FnInfo, const FunctionArgList &Args, SourceLocation Loc=SourceLocation(), SourceLocation StartLoc=SourceLocation())
Emit code for the start of a function.
bool HaveInsertPoint() const
HaveInsertPoint - True if an insertion point is defined.
Address recoverAddrOfEscapedLocal(CodeGenFunction &ParentCGF, Address ParentVar, llvm::Value *ParentFP)
Recovers the address of a local in a parent function.
void EmitSEHTryStmt(const SEHTryStmt &S)
void ExitSEHTryStmt(const SEHTryStmt &S)
llvm::BasicBlock * getTerminateLandingPad()
getTerminateLandingPad - Return a landing pad that just calls terminate.
llvm::BasicBlock * getTerminateHandler()
getTerminateHandler - Return a handler (not a landing pad, just a catch handler) that just calls term...
void EnterCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock=false)
void EmitStartEHSpec(const Decl *D)
EmitStartEHSpec - Emit the start of the exception spec.
llvm::CallInst * EmitNounwindRuntimeCall(llvm::FunctionCallee callee, const Twine &name="")
ASTContext & getContext() const
Address CreateMemTemp(QualType T, const Twine &Name="tmp", Address *Alloca=nullptr)
CreateMemTemp - Create a temporary memory object of the given type, with appropriate alignmen and cas...
void EmitCXXThrowExpr(const CXXThrowExpr *E, bool KeepInsertionPoint=true)
void EmitBranchThroughCleanup(JumpDest Dest)
EmitBranchThroughCleanup - Emit a branch from the current insert block through the normal cleanup han...
llvm::Value * SEHInfo
Value returned by __exception_info intrinsic.
llvm::BasicBlock * EmitLandingPad()
Emits a landing pad for the current EH stack.
llvm::DenseMap< const ValueDecl *, FieldDecl * > LambdaCaptureFields
llvm::CallInst * EmitRuntimeCall(llvm::FunctionCallee callee, const Twine &name="")
llvm::Type * ConvertType(QualType T)
void EmitNoreturnRuntimeCallOrInvoke(llvm::FunctionCallee callee, ArrayRef< llvm::Value * > args)
llvm::CallBase * EmitRuntimeCallOrInvoke(llvm::FunctionCallee callee, ArrayRef< llvm::Value * > args, const Twine &name="")
void EmitCapturedLocals(CodeGenFunction &ParentCGF, const Stmt *OutlinedStmt, bool IsFilter)
Scan the outlined statement for captures from the parent function.
llvm::BasicBlock * getFuncletEHDispatchBlock(EHScopeStack::stable_iterator scope)
llvm::Value * EmitSEHAbnormalTermination()
Address ReturnValue
ReturnValue - The temporary alloca to hold the return value.
void EmitStopPoint(const Stmt *S)
EmitStopPoint - Emit a debug stoppoint if we are emitting debug info.
void ExitCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock=false)
llvm::Instruction * CurrentFuncletPad
void EmitStmt(const Stmt *S, ArrayRef< const Attr * > Attrs=std::nullopt)
EmitStmt - Emit the code for the statement.
void EnsureInsertPoint()
EnsureInsertPoint - Ensure that an insertion point is defined so that emitted IR has a place to go.
llvm::LLVMContext & getLLVMContext()
llvm::Value * EmitScalarExpr(const Expr *E, bool IgnoreResultAssign=false)
EmitScalarExpr - Emit the computation of the specified expression of LLVM scalar type,...
void incrementProfileCounter(const Stmt *S, llvm::Value *StepV=nullptr)
Increment the profiler's counter for the given statement by StepV.
llvm::Value * getSelectorFromSlot()
llvm::Value * getExceptionFromSlot()
Returns the contents of the function's exception object and selector slots.
Address getEHSelectorSlot()
LValue EmitLValueForLambdaField(const FieldDecl *Field)
This class organizes the cross-function state that is used while generating LLVM code.
void SetInternalFunctionAttributes(GlobalDecl GD, llvm::Function *F, const CGFunctionInfo &FI)
Set the attributes on the LLVM function for the given decl and function info.
llvm::Module & getModule() const
llvm::FunctionCallee CreateRuntimeFunction(llvm::FunctionType *Ty, StringRef Name, llvm::AttributeList ExtraAttrs=llvm::AttributeList(), bool Local=false, bool AssumeConvergent=false)
Create or return a runtime function declaration with the specified type and name.
llvm::Constant * GetAddrOfRTTIDescriptor(QualType Ty, bool ForEH=false)
Get the address of the RTTI descriptor for the given type.
DiagnosticsEngine & getDiags() const
void ErrorUnsupported(const Stmt *S, const char *Type)
Print out an error that codegen doesn't support the specified stmt yet.
const LangOptions & getLangOpts() const
CodeGenTypes & getTypes()
const TargetInfo & getTarget() const
const llvm::DataLayout & getDataLayout() const
CGCXXABI & getCXXABI() const
ASTContext & getContext() const
llvm::FunctionCallee getTerminateFn()
Get the declaration of std::terminate for the platform.
llvm::LLVMContext & getLLVMContext()
CGObjCRuntime & getObjCRuntime()
Return a reference to the configured Objective-C runtime.
llvm::Function * getIntrinsic(unsigned IID, ArrayRef< llvm::Type * > Tys=std::nullopt)
llvm::FunctionType * GetFunctionType(const CGFunctionInfo &Info)
GetFunctionType - Get the LLVM function type for.
const CGFunctionInfo & arrangeBuiltinFunctionDeclaration(QualType resultType, const FunctionArgList &args)
A builtin function is a freestanding function using the default C conventions.
const CGFunctionInfo & arrangeBuiltinFunctionCall(QualType resultType, const CallArgList &args)
llvm::Constant * tryEmitAbstract(const Expr *E, QualType T)
Try to emit the result of the given expression as an abstract constant.
A scope which attempts to handle some, possibly all, types of exceptions.
const Handler & getHandler(unsigned I) const
void setHandler(unsigned I, llvm::Constant *Type, llvm::BasicBlock *Block)
void setCatchAllHandler(unsigned I, llvm::BasicBlock *Block)
void clearHandlerBlocks()
unsigned getNumHandlers() const
An exceptions scope which filters exceptions thrown through it.
llvm::Value * getFilter(unsigned i) const
unsigned getNumFilters() const
Information for lazily generating a cleanup.
A non-stable pointer into the scope stack.
A saved depth on the scope stack.
class EHFilterScope * pushFilter(unsigned NumFilters)
Push an exceptions filter on the stack.
stable_iterator stable_begin() const
Create a stable reference to the top of the EH stack.
stable_iterator getInnermostEHScope() const
bool requiresLandingPad() const
bool empty() const
Determines whether the exception-scopes stack is empty.
iterator end() const
Returns an iterator pointing to the outermost EH scope.
void popFilter()
Pops an exceptions filter off the stack.
iterator begin() const
Returns an iterator pointing to the innermost EH scope.
void popCatch()
Pops a catch scope off the stack. This is private to CGException.cpp.
class EHCatchScope * pushCatch(unsigned NumHandlers)
Push a set of catch handlers on the stack.
iterator find(stable_iterator save) const
Turn a stable reference to a scope depth into a unstable pointer to the EH stack.
static stable_iterator stable_end()
Create a stable reference to the bottom of the EH stack.
void popTerminate()
Pops a terminate handler off the stack.
void pushTerminate()
Push a terminate handler on the stack.
A protected scope for zero-cost EH handling.
llvm::BasicBlock * getCachedLandingPad() const
EHScopeStack::stable_iterator getEnclosingEHScope() const
llvm::BasicBlock * getCachedEHDispatchBlock() const
void setCachedEHDispatchBlock(llvm::BasicBlock *block)
bool hasEHBranches() const
FunctionArgList - Type for representing both the decl and type of parameters to a function.
LValue - This represents an lvalue references.
Address getAddress(CodeGenFunction &CGF) const
static RValue get(llvm::Value *V)
llvm::Value * getScalarVal() const
getScalarVal() - Return the Value* of this scalar value.
ReturnValueSlot - Contains the address where the return value of a function can be stored,...
ConstStmtVisitor - This class implements a simple visitor for Stmt subclasses.
A reference to a declared variable, function, enum, etc.
bool refersToEnclosingVariableOrCapture() const
Does this DeclRefExpr refer to an enclosing local or a captured variable?
Decl - This represents one declaration (or definition), e.g.
SourceLocation getLocation() const
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
This represents one expression.
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Represents a function declaration or definition.
bool usesSEHTry() const
Indicates the function uses __try.
SourceRange getExceptionSpecSourceRange() const
Attempt to compute an informative source range covering the function exception specification,...
Represents a prototype with parameter type info, e.g.
ExceptionSpecificationType getExceptionSpecType() const
Get the kind of exception specification on this function.
QualType getExceptionType(unsigned i) const
Return the ith exception type, where 0 <= i < getNumExceptions().
unsigned getNumExceptions() const
Return the number of types in the exception specification.
CanThrowResult canThrow() const
Determine whether this function type has a non-throwing exception specification.
GlobalDecl - represents a global declaration.
const Decl * getDecl() const
@ Other
Other implicit parameter.
static ImplicitParamDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, ImplicitParamKind ParamKind)
Create implicit parameter.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
bool hasWasmExceptions() const
clang::ObjCRuntime ObjCRuntime
bool hasSjLjExceptions() const
bool hasDWARFExceptions() const
bool hasSEHExceptions() const
MangleContext - Context for tracking state which persists across multiple calls to the C++ name mangl...
virtual void mangleSEHFilterExpression(GlobalDecl EnclosingDecl, raw_ostream &Out)=0
virtual void mangleSEHFinallyBlock(GlobalDecl EnclosingDecl, raw_ostream &Out)=0
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
Represents Objective-C's @throw statement.
The basic abstraction for the target Objective-C runtime.
bool hasTerminate() const
Does this runtime provide an objc_terminate function?
bool isNeXTFamily() const
Is this runtime basically of the NeXT family of runtimes?
const VersionTuple & getVersion() const
@ MacOSX
'macosx' is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the non-fragile AB...
@ FragileMacOSX
'macosx-fragile' is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the fragil...
@ GNUstep
'gnustep' is the modern non-fragile GNUstep runtime.
@ ObjFW
'objfw' is the Objective-C runtime included in ObjFW
@ iOS
'ios' is the Apple-provided NeXT-derived runtime on iOS or the iOS simulator; it is always non-fragil...
@ GCC
'gcc' is the Objective-C runtime shipped with GCC, implementing a fragile Objective-C ABI
@ WatchOS
'watchos' is a variant of iOS for Apple's watchOS.
A (possibly-)qualified type.
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
The collection of all-type qualifiers we support.
CompoundStmt * getBlock() const
Expr * getFilterExpr() const
CompoundStmt * getBlock() const
Represents a __leave statement.
Smart pointer class that efficiently represents Objective-C method names.
Encodes a location in the source.
Stmt - This represents one statement.
SourceLocation getEndLoc() const LLVM_READONLY
SourceLocation getBeginLoc() const LLVM_READONLY
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
Exposes information about the current target.
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
bool isSignedIntegerType() const
Return true if this is an integer type that is signed, according to C99 6.2.5p4 [char,...
bool isPointerType() const
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
bool isObjCObjectPointerType() const
const T * getAs() const
Member-template getAs<specific type>'.
Represents a variable declaration or definition.
bool isLocalVarDeclOrParm() const
Similar to isLocalVarDecl but also includes parameters.
@ NormalCleanup
Denotes a cleanup that should run when a scope is exited using normal control flow (falling off the e...
@ EHCleanup
Denotes a cleanup that should run when a scope is exited using exceptional control flow (a throw stat...
bool Zero(InterpState &S, CodePtr OpPC)
bool Load(InterpState &S, CodePtr OpPC)
@ C
Languages that the frontend can parse and compile.
ExceptionSpecificationType
The various types of exception specifications that exist in C++11.
@ EST_Dynamic
throw(T1, T2)
The MS C++ ABI needs a pointer to RTTI data plus some flags to describe the type of a catch handler,...
llvm::PointerType * VoidPtrTy
CharUnits getIntAlign() const
llvm::IntegerType * Int8Ty
i8, i16, i32, and i64
llvm::PointerType * VoidPtrPtrTy
llvm::IntegerType * Int32Ty
llvm::IntegerType * IntTy
int
llvm::PointerType * Int8PtrTy
CharUnits getPointerAlign() const
llvm::PointerType * AllocaInt8PtrTy
CatchTypeInfo Type
A type info value, or null (C++ null, not an LLVM null pointer) for a catch-all.
llvm::BasicBlock * Block
The catch handler for this type.
The exceptions personality for a function.
static const EHPersonality & get(CodeGenModule &CGM, const FunctionDecl *FD)
static const EHPersonality XL_CPlusPlus
static const EHPersonality GNU_ObjC_SJLJ
bool isWasmPersonality() const
static const EHPersonality GNUstep_ObjC
static const EHPersonality MSVC_CxxFrameHandler3
bool usesFuncletPads() const
Does this personality use landingpads or the family of pad instructions designed to form funclets?
static const EHPersonality MSVC_C_specific_handler
static const EHPersonality GNU_CPlusPlus_SEH
static const EHPersonality GNU_ObjC
static const EHPersonality GNU_CPlusPlus_SJLJ
static const EHPersonality GNU_C_SJLJ
static const EHPersonality GNU_C
static const EHPersonality NeXT_ObjC
const char * CatchallRethrowFn
static const EHPersonality GNU_CPlusPlus
static const EHPersonality GNU_ObjCXX
static const EHPersonality GNU_C_SEH
static const EHPersonality MSVC_except_handler
static const EHPersonality GNU_ObjC_SEH
const char * PersonalityFn
static const EHPersonality GNU_Wasm_CPlusPlus