24 #include "llvm/ADT/StringExtras.h"
25 #include "llvm/IR/CallSite.h"
26 #include "llvm/IR/DataLayout.h"
27 #include "llvm/IR/InlineAsm.h"
28 #include "llvm/IR/Intrinsics.h"
29 #include "llvm/IR/MDBuilder.h"
31 using namespace clang;
32 using namespace CodeGen;
49 assert(S &&
"Null statement?");
66 assert(!isa<DeclStmt>(*S) &&
"Unexpected DeclStmt!");
79 case Stmt::CXXCatchStmtClass:
80 case Stmt::SEHExceptStmtClass:
81 case Stmt::SEHFinallyStmtClass:
82 case Stmt::MSDependentExistsStmtClass:
83 llvm_unreachable(
"invalid statement class to emit generically");
84 case Stmt::NullStmtClass:
85 case Stmt::CompoundStmtClass:
86 case Stmt::DeclStmtClass:
87 case Stmt::LabelStmtClass:
88 case Stmt::AttributedStmtClass:
89 case Stmt::GotoStmtClass:
90 case Stmt::BreakStmtClass:
91 case Stmt::ContinueStmtClass:
92 case Stmt::DefaultStmtClass:
93 case Stmt::CaseStmtClass:
94 case Stmt::SEHLeaveStmtClass:
95 llvm_unreachable(
"should have emitted these statements as simple");
97 #define STMT(Type, Base)
98 #define ABSTRACT_STMT(Op)
99 #define EXPR(Type, Base) \
100 case Stmt::Type##Class:
101 #include "clang/AST/StmtNodes.inc"
104 llvm::BasicBlock *incoming =
Builder.GetInsertBlock();
105 assert(incoming &&
"expression emission must have an insertion point");
109 llvm::BasicBlock *outgoing =
Builder.GetInsertBlock();
110 assert(outgoing &&
"expression emission cleared block!");
124 if (incoming != outgoing && outgoing->use_empty()) {
125 outgoing->eraseFromParent();
131 case Stmt::IndirectGotoStmtClass:
134 case Stmt::IfStmtClass:
EmitIfStmt(cast<IfStmt>(*S));
break;
135 case Stmt::WhileStmtClass:
EmitWhileStmt(cast<WhileStmt>(*S));
break;
136 case Stmt::DoStmtClass:
EmitDoStmt(cast<DoStmt>(*S));
break;
137 case Stmt::ForStmtClass:
EmitForStmt(cast<ForStmt>(*S));
break;
139 case Stmt::ReturnStmtClass:
EmitReturnStmt(cast<ReturnStmt>(*S));
break;
141 case Stmt::SwitchStmtClass:
EmitSwitchStmt(cast<SwitchStmt>(*S));
break;
142 case Stmt::GCCAsmStmtClass:
143 case Stmt::MSAsmStmtClass:
EmitAsmStmt(cast<AsmStmt>(*S));
break;
144 case Stmt::CoroutineBodyStmtClass:
147 case Stmt::CoreturnStmtClass:
150 case Stmt::CapturedStmtClass: {
155 case Stmt::ObjCAtTryStmtClass:
158 case Stmt::ObjCAtCatchStmtClass:
160 "@catch statements should be handled by EmitObjCAtTryStmt");
161 case Stmt::ObjCAtFinallyStmtClass:
163 "@finally statements should be handled by EmitObjCAtTryStmt");
164 case Stmt::ObjCAtThrowStmtClass:
167 case Stmt::ObjCAtSynchronizedStmtClass:
170 case Stmt::ObjCForCollectionStmtClass:
173 case Stmt::ObjCAutoreleasePoolStmtClass:
177 case Stmt::CXXTryStmtClass:
180 case Stmt::CXXForRangeStmtClass:
183 case Stmt::SEHTryStmtClass:
186 case Stmt::OMPParallelDirectiveClass:
189 case Stmt::OMPSimdDirectiveClass:
192 case Stmt::OMPForDirectiveClass:
195 case Stmt::OMPForSimdDirectiveClass:
198 case Stmt::OMPSectionsDirectiveClass:
201 case Stmt::OMPSectionDirectiveClass:
204 case Stmt::OMPSingleDirectiveClass:
207 case Stmt::OMPMasterDirectiveClass:
210 case Stmt::OMPCriticalDirectiveClass:
213 case Stmt::OMPParallelForDirectiveClass:
216 case Stmt::OMPParallelForSimdDirectiveClass:
219 case Stmt::OMPParallelSectionsDirectiveClass:
222 case Stmt::OMPTaskDirectiveClass:
225 case Stmt::OMPTaskyieldDirectiveClass:
228 case Stmt::OMPBarrierDirectiveClass:
231 case Stmt::OMPTaskwaitDirectiveClass:
234 case Stmt::OMPTaskgroupDirectiveClass:
237 case Stmt::OMPFlushDirectiveClass:
240 case Stmt::OMPOrderedDirectiveClass:
243 case Stmt::OMPAtomicDirectiveClass:
246 case Stmt::OMPTargetDirectiveClass:
249 case Stmt::OMPTeamsDirectiveClass:
252 case Stmt::OMPCancellationPointDirectiveClass:
255 case Stmt::OMPCancelDirectiveClass:
258 case Stmt::OMPTargetDataDirectiveClass:
261 case Stmt::OMPTargetEnterDataDirectiveClass:
264 case Stmt::OMPTargetExitDataDirectiveClass:
267 case Stmt::OMPTargetParallelDirectiveClass:
270 case Stmt::OMPTargetParallelForDirectiveClass:
273 case Stmt::OMPTaskLoopDirectiveClass:
276 case Stmt::OMPTaskLoopSimdDirectiveClass:
279 case Stmt::OMPDistributeDirectiveClass:
282 case Stmt::OMPTargetUpdateDirectiveClass:
285 case Stmt::OMPDistributeParallelForDirectiveClass:
287 cast<OMPDistributeParallelForDirective>(*S));
289 case Stmt::OMPDistributeParallelForSimdDirectiveClass:
291 cast<OMPDistributeParallelForSimdDirective>(*S));
293 case Stmt::OMPDistributeSimdDirectiveClass:
296 case Stmt::OMPTargetParallelForSimdDirectiveClass:
298 cast<OMPTargetParallelForSimdDirective>(*S));
300 case Stmt::OMPTargetSimdDirectiveClass:
303 case Stmt::OMPTeamsDistributeDirectiveClass:
306 case Stmt::OMPTeamsDistributeSimdDirectiveClass:
308 cast<OMPTeamsDistributeSimdDirective>(*S));
310 case Stmt::OMPTeamsDistributeParallelForSimdDirectiveClass:
312 cast<OMPTeamsDistributeParallelForSimdDirective>(*S));
314 case Stmt::OMPTeamsDistributeParallelForDirectiveClass:
316 cast<OMPTeamsDistributeParallelForDirective>(*S));
318 case Stmt::OMPTargetTeamsDirectiveClass:
321 case Stmt::OMPTargetTeamsDistributeDirectiveClass:
323 cast<OMPTargetTeamsDistributeDirective>(*S));
325 case Stmt::OMPTargetTeamsDistributeParallelForDirectiveClass:
327 cast<OMPTargetTeamsDistributeParallelForDirective>(*S));
329 case Stmt::OMPTargetTeamsDistributeParallelForSimdDirectiveClass:
331 cast<OMPTargetTeamsDistributeParallelForSimdDirective>(*S));
333 case Stmt::OMPTargetTeamsDistributeSimdDirectiveClass:
335 cast<OMPTargetTeamsDistributeSimdDirective>(*S));
342 default:
return false;
343 case Stmt::NullStmtClass:
break;
344 case Stmt::CompoundStmtClass:
EmitCompoundStmt(cast<CompoundStmt>(*S));
break;
345 case Stmt::DeclStmtClass:
EmitDeclStmt(cast<DeclStmt>(*S));
break;
346 case Stmt::LabelStmtClass:
EmitLabelStmt(cast<LabelStmt>(*S));
break;
347 case Stmt::AttributedStmtClass:
349 case Stmt::GotoStmtClass:
EmitGotoStmt(cast<GotoStmt>(*S));
break;
350 case Stmt::BreakStmtClass:
EmitBreakStmt(cast<BreakStmt>(*S));
break;
351 case Stmt::ContinueStmtClass:
EmitContinueStmt(cast<ContinueStmt>(*S));
break;
352 case Stmt::DefaultStmtClass:
EmitDefaultStmt(cast<DefaultStmt>(*S));
break;
353 case Stmt::CaseStmtClass:
EmitCaseStmt(cast<CaseStmt>(*S));
break;
354 case Stmt::SEHLeaveStmtClass:
EmitSEHLeaveStmt(cast<SEHLeaveStmt>(*S));
break;
366 "LLVM IR generation of compound statement ('{}')");
390 while (
const LabelStmt *LS = dyn_cast<LabelStmt>(LastStmt)) {
392 LastStmt = LS->getSubStmt();
397 QualType ExprTy = cast<Expr>(LastStmt)->getType();
415 llvm::BranchInst *BI = dyn_cast<llvm::BranchInst>(BB->getTerminator());
424 if (!BI || !BI->isUnconditional())
428 if (BI->getIterator() != BB->begin())
431 BB->replaceAllUsesWith(BI->getSuccessor(0));
432 BI->eraseFromParent();
433 BB->eraseFromParent();
437 llvm::BasicBlock *CurBB =
Builder.GetInsertBlock();
442 if (IsFinished && BB->use_empty()) {
449 if (CurBB && CurBB->getParent())
450 CurFn->getBasicBlockList().insertAfter(CurBB->getIterator(), BB);
452 CurFn->getBasicBlockList().push_back(BB);
460 llvm::BasicBlock *CurBB =
Builder.GetInsertBlock();
462 if (!CurBB || CurBB->getTerminator()) {
474 bool inserted =
false;
475 for (llvm::User *u : block->users()) {
476 if (llvm::Instruction *insn = dyn_cast<llvm::Instruction>(u)) {
477 CurFn->getBasicBlockList().insertAfter(insn->getParent()->getIterator(),
485 CurFn->getBasicBlockList().push_back(block);
493 if (Dest.
isValid())
return Dest;
531 assert(!Labels.empty());
537 i = Labels.begin(), e = Labels.end(); i != e; ++i) {
538 assert(
CGF.LabelMap.count(*i));
540 assert(dest.getScopeDepth().isValid());
541 assert(innermostScope.encloses(dest.getScopeDepth()));
542 dest.setScopeDepth(innermostScope);
547 ParentScope->Labels.append(Labels.begin(), Labels.end());
560 case Stmt::DoStmtClass:
563 case Stmt::ForStmtClass:
566 case Stmt::WhileStmtClass:
569 case Stmt::CXXForRangeStmtClass:
597 llvm::BasicBlock *CurBB =
Builder.GetInsertBlock();
604 cast<llvm::PHINode>(IndGotoBB->begin())->addIncoming(V, CurBB);
629 std::swap(Executed, Skipped);
648 llvm::BasicBlock *ElseBlock = ContBlock;
703 BreakContinueStack.push_back(BreakContinue(LoopExit, LoopHeader));
724 bool EmitBoolCondBranch =
true;
725 if (llvm::ConstantInt *C = dyn_cast<llvm::ConstantInt>(BoolCondVal))
727 EmitBoolCondBranch =
false;
731 if (EmitBoolCondBranch) {
732 llvm::BasicBlock *ExitBlock = LoopExit.
getBlock();
736 BoolCondVal, LoopBody, ExitBlock,
739 if (ExitBlock != LoopExit.
getBlock()) {
754 BreakContinueStack.pop_back();
770 if (!EmitBoolCondBranch)
782 BreakContinueStack.push_back(BreakContinue(LoopExit, LoopCond));
808 BreakContinueStack.pop_back();
812 bool EmitBoolCondBranch =
true;
813 if (llvm::ConstantInt *C = dyn_cast<llvm::ConstantInt>(BoolCondVal))
815 EmitBoolCondBranch =
false;
818 if (EmitBoolCondBranch) {
821 BoolCondVal, LoopBody, LoopExit.
getBlock(),
822 createProfileWeightsForLoop(S.
getCond(), BackedgeCount));
832 if (!EmitBoolCondBranch)
850 llvm::BasicBlock *CondBlock = Continue.
getBlock();
866 BreakContinueStack.push_back(BreakContinue(LoopExit, Continue));
878 llvm::BasicBlock *ExitBlock = LoopExit.
getBlock();
881 if (ForScope.requiresCleanups())
891 BoolCondVal, ForBody, ExitBlock,
894 if (ExitBlock != LoopExit.
getBlock()) {
919 BreakContinueStack.pop_back();
921 ConditionScope.ForceCleanup();
926 ForScope.ForceCleanup();
959 llvm::BasicBlock *ExitBlock = LoopExit.
getBlock();
960 if (ForScope.requiresCleanups())
970 BoolCondVal, ForBody, ExitBlock,
973 if (ExitBlock != LoopExit.
getBlock()) {
985 BreakContinueStack.push_back(BreakContinue(LoopExit, Continue));
999 BreakContinueStack.pop_back();
1003 ForScope.ForceCleanup();
1011 void CodeGenFunction::EmitReturnOfRValue(
RValue RV,
QualType Ty) {
1027 if (requiresReturnValueCheck()) {
1030 new llvm::GlobalVariable(
CGM.
getModule(), SLoc->getType(),
false,
1031 llvm::GlobalVariable::PrivateLinkage, SLoc);
1032 SLocPtr->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
1034 assert(ReturnLocation.
isValid() &&
"No valid return location");
1042 Builder.ClearInsertionPoint();
1054 dyn_cast_or_null<ExprWithCleanups>(RV)) {
1056 RV = cleanups->getSubExpr();
1104 ++NumSimpleReturnExprs;
1116 for (
const auto *
I : S.
decls())
1121 assert(!BreakContinueStack.empty() &&
"break stmt not in a loop or switch!");
1133 assert(!BreakContinueStack.empty() &&
"continue stmt not in a loop!");
1148 assert(S.
getRHS() &&
"Expected RHS value in CaseStmt");
1161 if (LHS.isSigned() ? RHS.slt(LHS) : RHS.ult(LHS))
1164 llvm::APInt Range = RHS - LHS;
1166 if (Range.ult(llvm::APInt(Range.getBitWidth(), 64))) {
1169 unsigned NCases = Range.getZExtValue() + 1;
1174 uint64_t Weight = Total / NCases, Rem = Total % NCases;
1175 for (
unsigned I = 0;
I != NCases; ++
I) {
1177 SwitchWeights->push_back(Weight + (Rem ? 1 : 0));
1180 SwitchInsn->addCase(
Builder.getInt(LHS), CaseDest);
1188 llvm::BasicBlock *RestoreBB =
Builder.GetInsertBlock();
1193 llvm::BasicBlock *FalseDest = CaseRangeBlock;
1196 CurFn->getBasicBlockList().push_back(CaseRangeBlock);
1197 Builder.SetInsertPoint(CaseRangeBlock);
1201 Builder.CreateSub(SwitchInsn->getCondition(),
Builder.getInt(LHS));
1205 llvm::MDNode *Weights =
nullptr;
1206 if (SwitchWeights) {
1208 uint64_t DefaultCount = (*SwitchWeights)[0];
1209 Weights = createProfileWeights(ThisCount, DefaultCount);
1214 (*SwitchWeights)[0] += ThisCount;
1216 Builder.CreateCondBr(Cond, CaseDest, FalseDest, Weights);
1220 Builder.SetInsertPoint(RestoreBB);
1222 Builder.ClearInsertionPoint();
1242 llvm::ConstantInt *CaseVal =
1251 JumpDest Block = BreakContinueStack.back().BreakBlock;
1257 SwitchInsn->addCase(CaseVal, Block.
getBlock());
1261 if (
Builder.GetInsertBlock()) {
1263 Builder.ClearInsertionPoint();
1273 SwitchInsn->addCase(CaseVal, CaseDest);
1288 while (NextCase && NextCase->
getRHS() ==
nullptr) {
1290 llvm::ConstantInt *CaseVal =
1300 SwitchInsn->addCase(CaseVal, CaseDest);
1317 llvm::BasicBlock *DefaultBlock = SwitchInsn->getDefaultDest();
1318 assert(DefaultBlock->empty() &&
1319 "EmitDefaultStmt: Default block already defined?");
1360 if (
const SwitchCase *SC = dyn_cast<SwitchCase>(S)) {
1374 if (!Case && isa<BreakStmt>(S))
1379 if (
const CompoundStmt *CS = dyn_cast<CompoundStmt>(S)) {
1383 bool StartedInLiveCode = FoundCase;
1384 unsigned StartSize = ResultStmts.size();
1391 bool HadSkippedDecl =
false;
1395 for (; Case && I !=
E; ++
I) {
1411 for (++I; I !=
E; ++
I)
1421 assert(FoundCase &&
"Didn't find case but returned fallthrough?");
1436 assert(!HadSkippedDecl &&
"fallthrough after skipping decl");
1441 bool AnyDecls =
false;
1442 for (; I !=
E; ++
I) {
1455 for (++I; I !=
E; ++
I)
1472 ResultStmts.resize(StartSize);
1473 ResultStmts.push_back(S);
1497 ResultStmts.push_back(S);
1506 const llvm::APSInt &ConstantCondValue,
1518 if (
const DefaultStmt *DS = dyn_cast<DefaultStmt>(Case)) {
1524 const CaseStmt *CS = cast<CaseStmt>(Case);
1526 if (CS->
getRHS())
return false;
1551 bool FoundCase =
false;
1560 llvm::SwitchInst *SavedSwitchInsn = SwitchInsn;
1562 llvm::BasicBlock *SavedCRBlock = CaseRangeBlock;
1566 llvm::APSInt ConstantCondValue;
1587 SwitchInsn =
nullptr;
1591 for (
unsigned i = 0, e = CaseStmts.size(); i != e; ++i)
1597 SwitchInsn = SavedSwitchInsn;
1619 SwitchInsn =
Builder.CreateSwitch(CondV, DefaultBlock);
1622 uint64_t DefaultCount = 0;
1623 unsigned NumCases = 0;
1627 if (isa<DefaultStmt>(Case))
1632 SwitchWeights->reserve(NumCases);
1635 SwitchWeights->push_back(DefaultCount);
1637 CaseRangeBlock = DefaultBlock;
1640 Builder.ClearInsertionPoint();
1645 if (!BreakContinueStack.empty())
1646 OuterContinue = BreakContinueStack.back().ContinueBlock;
1648 BreakContinueStack.push_back(BreakContinue(SwitchExit, OuterContinue));
1653 BreakContinueStack.pop_back();
1657 SwitchInsn->setDefaultDest(CaseRangeBlock);
1660 if (!DefaultBlock->getParent()) {
1668 DefaultBlock->replaceAllUsesWith(SwitchExit.
getBlock());
1669 delete DefaultBlock;
1684 auto *FD = dyn_cast_or_null<FunctionDecl>(Call->getCalleeDecl());
1685 if (FD && FD->getBuiltinID() == Builtin::BI__builtin_unpredictable) {
1687 SwitchInsn->setMetadata(llvm::LLVMContext::MD_unpredictable,
1688 MDHelper.createUnpredictable());
1692 if (SwitchWeights) {
1693 assert(SwitchWeights->size() == 1 + SwitchInsn->getNumCases() &&
1694 "switch weights do not match switch cases");
1696 if (SwitchWeights->size() > 1)
1697 SwitchInsn->setMetadata(llvm::LLVMContext::MD_prof,
1698 createProfileWeights(*SwitchWeights));
1699 delete SwitchWeights;
1701 SwitchInsn = SavedSwitchInsn;
1702 SwitchWeights = SavedSwitchWeights;
1703 CaseRangeBlock = SavedCRBlock;
1711 while (*Constraint) {
1712 switch (*Constraint) {
1724 while (Constraint[1] && Constraint[1] !=
',')
1729 Result += *Constraint;
1730 while (Constraint[1] && Constraint[1] == *Constraint)
1741 "Must pass output names to constraints with a symbolic name");
1744 assert(result &&
"Could not resolve symbolic name"); (void)result;
1745 Result += llvm::utostr(Index);
1772 AsmLabelAttr *
Attr = Variable->
getAttr<AsmLabelAttr>();
1775 StringRef Register = Attr->getLabel();
1781 !Info.allowsRegister()) {
1787 return (EarlyClobber ?
"&{" :
"{") + Register.str() +
"}";
1793 std::string &ConstraintStr,
1802 if (Size <= 64 && llvm::isPowerOf2_64(Size)) {
1804 Ty = llvm::PointerType::getUnqual(Ty);
1810 ConstraintStr +=
'*';
1815 ConstraintStr +=
'*';
1823 const Expr *InputExpr,
1824 std::string &ConstraintStr) {
1832 "Required-immediate inlineasm arg isn't constant?");
1838 if (InputExpr->
getStmtClass() == Expr::CXXThisExprClass)
1842 return EmitAsmInputLValue(Info, Dest, InputExpr->
getType(), ConstraintStr,
1854 Locs.push_back(llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
1857 if (!StrVal.empty()) {
1860 unsigned StartToken = 0;
1861 unsigned ByteOffset = 0;
1865 for (
unsigned i = 0, e = StrVal.size() - 1; i != e; ++i) {
1866 if (StrVal[i] !=
'\n')
continue;
1868 i + 1, SM, LangOpts, CGF.
getTarget(), &StartToken, &ByteOffset);
1869 Locs.push_back(llvm::ConstantAsMetadata::get(
1887 if (
const GCCAsmStmt *GAS = dyn_cast<GCCAsmStmt>(&S))
1888 Name = GAS->getOutputName(i);
1891 assert(IsValid &&
"Failed to parse output constraint");
1892 OutputConstraintInfos.push_back(Info);
1895 for (
unsigned i = 0, e = S.
getNumInputs(); i != e; i++) {
1897 if (
const GCCAsmStmt *GAS = dyn_cast<GCCAsmStmt>(&S))
1898 Name = GAS->getInputName(i);
1902 assert(IsValid &&
"Failed to parse input constraint"); (void)IsValid;
1903 InputConstraintInfos.push_back(Info);
1906 std::string Constraints;
1908 std::vector<LValue> ResultRegDests;
1909 std::vector<QualType> ResultRegQualTys;
1910 std::vector<llvm::Type *> ResultRegTypes;
1911 std::vector<llvm::Type *> ResultTruncRegTypes;
1912 std::vector<llvm::Type *> ArgTypes;
1913 std::vector<llvm::Value*> Args;
1916 std::string InOutConstraints;
1917 std::vector<llvm::Value*> InOutArgs;
1918 std::vector<llvm::Type*> InOutArgTypes;
1926 bool ReadOnly =
true, ReadNone =
true;
1944 if (!Constraints.empty())
1950 Constraints +=
"=" + OutputConstraint;
1951 ResultRegQualTys.push_back(OutExpr->getType());
1952 ResultRegDests.push_back(Dest);
1954 ResultTruncRegTypes.push_back(ResultRegTypes.back());
1961 for (InputNo = 0; InputNo != S.
getNumInputs(); ++InputNo) {
1966 assert(InputNo != S.
getNumInputs() &&
"Didn't find matching input!");
1969 QualType OutputType = OutExpr->getType();
1979 ResultRegTypes.back()))
1980 ResultRegTypes.back() = AdjTy;
1983 diag::err_asm_invalid_type_in_input)
1984 << OutExpr->getType() << OutputConstraint;
1987 ArgTypes.push_back(Dest.getAddress().getType());
1988 Args.push_back(Dest.getPointer());
1989 Constraints +=
"=*";
1990 Constraints += OutputConstraint;
1991 ReadOnly = ReadNone =
false;
1995 InOutConstraints +=
',';
2008 InOutConstraints += llvm::utostr(i);
2010 InOutConstraints += OutputConstraint;
2012 InOutArgTypes.push_back(Arg->getType());
2013 InOutArgs.push_back(Arg);
2019 if (isa<MSAsmStmt>(&S)) {
2025 *
this, ReturnSlot, Constraints, ResultRegTypes, ResultTruncRegTypes,
2031 for (
unsigned i = 0, e = S.
getNumInputs(); i != e; i++) {
2039 if (!Constraints.empty())
2045 &OutputConstraintInfos);
2051 llvm::Value *Arg = EmitAsmInput(Info, InputExpr, Constraints);
2060 QualType OutputType = S.getOutputExpr(Output)->getType();
2066 if (isa<llvm::PointerType>(Arg->getType()))
2069 if (isa<llvm::IntegerType>(OutputTy))
2070 Arg =
Builder.CreateZExt(Arg, OutputTy);
2071 else if (isa<llvm::PointerType>(OutputTy))
2074 assert(OutputTy->isFloatingPointTy() &&
"Unexpected output type");
2075 Arg =
Builder.CreateFPExt(Arg, OutputTy);
2085 << InputExpr->
getType() << InputConstraint;
2087 ArgTypes.push_back(Arg->getType());
2088 Args.push_back(Arg);
2089 Constraints += InputConstraint;
2093 for (
unsigned i = 0, e = InOutArgs.size(); i != e; i++) {
2094 ArgTypes.push_back(InOutArgTypes[i]);
2095 Args.push_back(InOutArgs[i]);
2097 Constraints += InOutConstraints;
2103 if (Clobber ==
"memory")
2104 ReadOnly = ReadNone =
false;
2105 else if (Clobber !=
"cc")
2108 if (!Constraints.empty())
2111 Constraints +=
"~{";
2112 Constraints += Clobber;
2118 if (!MachineClobbers.empty()) {
2119 if (!Constraints.empty())
2121 Constraints += MachineClobbers;
2125 if (ResultRegTypes.empty())
2127 else if (ResultRegTypes.size() == 1)
2128 ResultType = ResultRegTypes[0];
2130 ResultType = llvm::StructType::get(
getLLVMContext(), ResultRegTypes);
2132 llvm::FunctionType *FTy =
2133 llvm::FunctionType::get(ResultType, ArgTypes,
false);
2136 llvm::InlineAsm::AsmDialect AsmDialect = isa<MSAsmStmt>(&
S) ?
2137 llvm::InlineAsm::AD_Intel : llvm::InlineAsm::AD_ATT;
2138 llvm::InlineAsm *IA =
2139 llvm::InlineAsm::get(FTy, AsmString, Constraints, HasSideEffect,
2141 llvm::CallInst *Result =
Builder.CreateCall(IA, Args);
2142 Result->addAttribute(llvm::AttributeList::FunctionIndex,
2143 llvm::Attribute::NoUnwind);
2146 if (!HasSideEffect) {
2148 Result->addAttribute(llvm::AttributeList::FunctionIndex,
2149 llvm::Attribute::ReadNone);
2151 Result->addAttribute(llvm::AttributeList::FunctionIndex,
2152 llvm::Attribute::ReadOnly);
2157 if (
const GCCAsmStmt *gccAsmStmt = dyn_cast<GCCAsmStmt>(&S)) {
2163 Result->setMetadata(
"srcloc",
2165 llvm::ConstantAsMetadata::get(Loc)));
2172 Result->addAttribute(llvm::AttributeList::FunctionIndex,
2173 llvm::Attribute::Convergent);
2177 std::vector<llvm::Value*> RegResults;
2178 if (ResultRegTypes.size() == 1) {
2179 RegResults.push_back(Result);
2181 for (
unsigned i = 0, e = ResultRegTypes.size(); i != e; ++i) {
2183 RegResults.push_back(Tmp);
2187 assert(RegResults.size() == ResultRegTypes.size());
2188 assert(RegResults.size() == ResultTruncRegTypes.size());
2189 assert(RegResults.size() == ResultRegDests.size());
2190 for (
unsigned i = 0, e = RegResults.size(); i != e; ++i) {
2195 if (ResultRegTypes[i] != ResultTruncRegTypes[i]) {
2196 llvm::Type *TruncTy = ResultTruncRegTypes[i];
2200 if (TruncTy->isFloatingPointTy())
2201 Tmp =
Builder.CreateFPTrunc(Tmp, TruncTy);
2202 else if (TruncTy->isPointerTy() && Tmp->getType()->isIntegerTy()) {
2204 Tmp =
Builder.CreateTrunc(Tmp,
2206 Tmp =
Builder.CreateIntToPtr(Tmp, TruncTy);
2207 }
else if (Tmp->getType()->isPointerTy() && TruncTy->isIntegerTy()) {
2209 Tmp =
Builder.CreatePtrToInt(Tmp,
2211 Tmp =
Builder.CreateTrunc(Tmp, TruncTy);
2212 }
else if (TruncTy->isIntegerTy()) {
2213 Tmp =
Builder.CreateTrunc(Tmp, TruncTy);
2214 }
else if (TruncTy->isVectorTy()) {
2234 I !=
E; ++
I, ++CurField) {
2236 if (CurField->hasCapturedVLAType()) {
2237 auto VAT = CurField->getCapturedVLAType();
2274 "CapturedStmtInfo should be set when generating the captured function");
2278 assert(CD->
hasBody() &&
"missing CapturedDecl body");
2296 F->addFnAttr(llvm::Attribute::NoUnwind);
2308 Ctx.getTagDeclType(RD));
2309 for (
auto *FD : RD->
fields()) {
2310 if (FD->hasCapturedVLAType()) {
2313 auto VAT = FD->getCapturedVLAType();
2314 VLASizeMap[VAT->getSizeExpr()] = ExprArg;
const CGFunctionInfo & arrangeBuiltinFunctionDeclaration(QualType resultType, const FunctionArgList &args)
A builtin function is a freestanding function using the default C conventions.
void EmitIndirectGotoStmt(const IndirectGotoStmt &S)
const SwitchCase * getNextSwitchCase() const
SourceLocation getEnd() const
void EmitCoroutineBody(const CoroutineBodyStmt &S)
virtual void EmitBody(CodeGenFunction &CGF, const Stmt *S)
Emit the captured statement body.
StmtClass getStmtClass() const
This represents a GCC inline-assembly statement extension.
unsigned getNumOutputs() const
void EmitOMPTaskwaitDirective(const OMPTaskwaitDirective &S)
StringRef getName() const
getName - Get the name of identifier for this declaration as a StringRef.
A (possibly-)qualified type.
capture_init_iterator capture_init_begin()
Retrieve the first initialization argument.
void EmitSEHLeaveStmt(const SEHLeaveStmt &S)
llvm::Value * getPointer() const
CodeGenTypes & getTypes()
const TargetCodeGenInfo & getTargetHooks() const
llvm::Type * ConvertTypeForMem(QualType T)
void EmitBranchOnBoolExpr(const Expr *Cond, llvm::BasicBlock *TrueBlock, llvm::BasicBlock *FalseBlock, uint64_t TrueCount)
EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g.
void EmitGotoStmt(const GotoStmt &S)
void EmitAttributedStmt(const AttributedStmt &S)
bool hasMatchingInput() const
Return true if this output operand has a matching (tied) input operand.
llvm::Module & getModule() const
void EmitOMPDistributeDirective(const OMPDistributeDirective &S)
void EmitCXXTryStmt(const CXXTryStmt &S)
Stmt - This represents one statement.
const TargetInfo & getTarget() const
IfStmt - This represents an if/then/else.
std::pair< llvm::Value *, llvm::Value * > getComplexVal() const
getComplexVal - Return the real/imag components of this complex value.
static stable_iterator stable_end()
Create a stable reference to the bottom of the EH stack.
void EmitOMPTargetSimdDirective(const OMPTargetSimdDirective &S)
const Expr * getOutputExpr(unsigned i) const
Address getAddress() const
Defines the PrettyStackTraceEntry class, which is used to make crashes give more contextual informati...
llvm::Value * getTypeSize(QualType Ty)
Returns calculated size of the specified type.
Represents an attribute applied to a statement.
void EmitAutoVarDecl(const VarDecl &D)
EmitAutoVarDecl - Emit an auto variable declaration.
const llvm::DataLayout & getDataLayout() const
void EmitOMPOrderedDirective(const OMPOrderedDirective &S)
bool validateOutputConstraint(ConstraintInfo &Info) const
void EmitStoreThroughLValue(RValue Src, LValue Dst, bool isInit=false)
EmitStoreThroughLValue - Store the specified rvalue into the specified lvalue, where both are guarant...
void EmitComplexExprIntoLValue(const Expr *E, LValue dest, bool isInit)
EmitComplexExprIntoLValue - Emit the given expression of complex type and place its result into the s...
Address GenerateCapturedStmtArgument(const CapturedStmt &S)
QualType getRecordType(const RecordDecl *Decl) const
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
bool validateInputConstraint(MutableArrayRef< ConstraintInfo > OutputConstraints, ConstraintInfo &info) const
void ForceCleanup(std::initializer_list< llvm::Value ** > ValuesToReload={})
Force the emission of cleanups now, instead of waiting until this object is destroyed.
const Stmt * getElse() const
SourceLocation getLocStart() const LLVM_READONLY
const LangOptions & getLangOpts() const
LValue EmitLValueForFieldInitialization(LValue Base, const FieldDecl *Field)
EmitLValueForFieldInitialization - Like EmitLValueForField, except that if the Field is a reference...
SourceLocation getLocStart() const LLVM_READONLY
unsigned getRawEncoding() const
When a SourceLocation itself cannot be used, this returns an (opaque) 32-bit integer encoding for it...
VarDecl * getConditionVariable() const
Retrieve the variable declared in this "for" statement, if any.
bool ConstantFoldsToSimpleInteger(const Expr *Cond, bool &Result, bool AllowLabels=false)
ConstantFoldsToSimpleInteger - If the specified expression does not fold to a constant, or if it does but contains a label, return false.
void EmitOMPParallelForSimdDirective(const OMPParallelForSimdDirective &S)
Address GetAddrOfLocalVar(const VarDecl *VD)
GetAddrOfLocalVar - Return the address of a local variable.
VarDecl - An instance of this class is created to represent a variable declaration or definition...
void EmitOMPCriticalDirective(const OMPCriticalDirective &S)
uint64_t getProfileCount(const Stmt *S)
Get the profiler's count for the given statement.
field_iterator field_begin() const
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
This class gathers all debug information during compilation and is responsible for emitting to llvm g...
static bool mightAddDeclToScope(const Stmt *S)
Determine if the given statement might introduce a declaration into the current scope, by being a (possibly-labelled) DeclStmt.
void EmitLabel(const LabelDecl *D)
EmitLabel - Emit the block for the given label.
CapturedRegionKind getCapturedRegionKind() const
Retrieve the captured region kind.
Represents an expression – generally a full-expression – that introduces cleanups to be run at the en...
void EmitOMPTeamsDistributeDirective(const OMPTeamsDistributeDirective &S)
void SimplifyForwardingBlocks(llvm::BasicBlock *BB)
SimplifyForwardingBlocks - If the given basic block is only a branch to another basic block...
The collection of all-type qualifiers we support.
A jump destination is an abstract label, branching to which may require a jump out through normal cle...
void EmitOMPTargetTeamsDistributeParallelForSimdDirective(const OMPTargetTeamsDistributeParallelForSimdDirective &S)
LabelStmt - Represents a label, which has a substatement.
void EmitOMPTaskLoopSimdDirective(const OMPTaskLoopSimdDirective &S)
JumpDest getJumpDestForLabel(const LabelDecl *S)
getBasicBlockForLabel - Return the LLVM basicblock that the specified label maps to.
RecordDecl - Represents a struct/union/class.
void EmitCXXForRangeStmt(const CXXForRangeStmt &S, ArrayRef< const Attr * > Attrs=None)
void EmitOMPSimdDirective(const OMPSimdDirective &S)
void setScopeDepth(EHScopeStack::stable_iterator depth)
unsigned getNumInputs() const
CGDebugInfo * getDebugInfo()
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
void addLabel(const LabelDecl *label)
virtual llvm::Type * adjustInlineAsmType(CodeGen::CodeGenFunction &CGF, StringRef Constraint, llvm::Type *Ty) const
Corrects the low-level LLVM type for a given constraint and "usual" type.
RValue EmitReferenceBindingToExpr(const Expr *E)
Emits a reference binding to the passed in expression.
bool isReferenceType() const
FieldDecl - An instance of this class is created by Sema::ActOnField to represent a member of a struc...
void rescopeLabels()
Change the cleanup scope of the labels in this lexical scope to match the scope of the enclosing cont...
virtual void setContextValue(llvm::Value *V)
llvm::CallSite EmitCallOrInvoke(llvm::Value *Callee, ArrayRef< llvm::Value * > Args, const Twine &Name="")
Emits a call or invoke instruction to the given function, depending on the current state of the EH st...
SourceLocation getLBracLoc() const
static bool FindCaseStatementsForValue(const SwitchStmt &S, const llvm::APSInt &ConstantCondValue, SmallVectorImpl< const Stmt * > &ResultStmts, ASTContext &C, const SwitchCase *&ResultCase)
FindCaseStatementsForValue - Find the case statement being jumped to and then invoke CollectStatement...
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
StorageClass getStorageClass() const
Returns the storage class as written in the source.
void EmitOMPDistributeParallelForSimdDirective(const OMPDistributeParallelForSimdDirective &S)
void EmitInitializerForField(FieldDecl *Field, LValue LHS, Expr *Init)
const VarDecl * getNRVOCandidate() const
Retrieve the variable that might be used for the named return value optimization. ...
RValue EmitAnyExpr(const Expr *E, AggValueSlot aggSlot=AggValueSlot::ignored(), bool ignoreResult=false)
EmitAnyExpr - Emit code to compute the specified expression which can have any type.
IndirectGotoStmt - This represents an indirect goto.
Stmt * getBody() const override
getBody - If this Decl represents a declaration for a body of code, such as a function or method defi...
static bool hasScalarEvaluationKind(QualType T)
bool resolveSymbolicName(const char *&Name, ArrayRef< ConstraintInfo > OutputConstraints, unsigned &Index) const
void EmitOMPTargetTeamsDistributeSimdDirective(const OMPTargetTeamsDistributeSimdDirective &S)
ForStmt - This represents a 'for (init;cond;inc)' stmt.
StringRef getOutputConstraint(unsigned i) const
getOutputConstraint - Return the constraint string for the specified output operand.
void EmitDoStmt(const DoStmt &S, ArrayRef< const Attr * > Attrs=None)
void pop()
End the current loop.
bool isValidGCCRegisterName(StringRef Name) const
Returns whether the passed in string is a valid register name according to GCC.
void EmitOMPCancellationPointDirective(const OMPCancellationPointDirective &S)
RAII for correct setting/restoring of CapturedStmtInfo.
field_range fields() const
void EmitOMPTeamsDistributeParallelForSimdDirective(const OMPTeamsDistributeParallelForSimdDirective &S)
void EmitContinueStmt(const ContinueStmt &S)
void EmitOMPTargetDirective(const OMPTargetDirective &S)
CXXForRangeStmt - This represents C++0x [stmt.ranged]'s ranged for statement, represented as 'for (ra...
bool IsOutlinedSEHHelper
True if the current function is an outlined SEH helper.
ABIArgInfo - Helper class to encapsulate information about how a specific C type should be passed to ...
void EmitOMPTargetUpdateDirective(const OMPTargetUpdateDirective &S)
void EmitSwitchStmt(const SwitchStmt &S)
If a crash happens while one of these objects are live, the message is printed out along with the spe...
LabelStmt * getStmt() const
bool isObviouslyBranchWithoutCleanups(JumpDest Dest) const
isObviouslyBranchWithoutCleanups - Return true if a branch to the specified destination obviously has...
Scope - A scope is a transient data structure that is used while parsing the program.
void EmitStmt(const Stmt *S)
EmitStmt - Emit the code for the statement.
void EmitOMPParallelDirective(const OMPParallelDirective &S)
llvm::BasicBlock * createBasicBlock(const Twine &name="", llvm::Function *parent=nullptr, llvm::BasicBlock *before=nullptr)
createBasicBlock - Create an LLVM basic block.
void EmitIgnoredExpr(const Expr *E)
EmitIgnoredExpr - Emit an expression in a context which ignores the result.
void assignRegionCounters(GlobalDecl GD, llvm::Function *Fn)
Assign counters to regions and configure them for PGO of a given function.
llvm::Function * EmitCapturedStmt(const CapturedStmt &S, CapturedRegionKind K)
Generate an outlined function for the body of a CapturedStmt, store any captured variables into the c...
bool requiresCleanups() const
Determine whether this scope requires any cleanups.
virtual FieldDecl * getThisFieldDecl() const
void EmitDefaultStmt(const DefaultStmt &S)
static bool ContainsLabel(const Stmt *S, bool IgnoreCaseStmts=false)
ContainsLabel - Return true if the statement contains a label in it.
const RecordDecl * getCapturedRecordDecl() const
Retrieve the record declaration for captured variables.
void EmitCaseStmtRange(const CaseStmt &S)
EmitCaseStmtRange - If case statement range is not too big then add multiple cases to switch instruct...
void incrementProfileCounter(const Stmt *S, llvm::Value *StepV=nullptr)
Increment the profiler's counter for the given statement by StepV.
uint64_t getCurrentProfileCount()
Get the profiler's current count.
This represents the body of a CapturedStmt, and serves as its DeclContext.
detail::InMemoryDirectory::const_iterator I
LValue EmitLValueForField(LValue Base, const FieldDecl *Field)
CompoundStmt - This represents a group of statements like { stmt stmt }.
SourceLocation getAsmLoc() const
void EmitOMPParallelSectionsDirective(const OMPParallelSectionsDirective &S)
const TargetCodeGenInfo & getTargetCodeGenInfo()
Expr * IgnoreParenNoopCasts(ASTContext &Ctx) LLVM_READONLY
IgnoreParenNoopCasts - Ignore parentheses and casts that do not change the value (including ptr->int ...
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...
RValue - This trivial value class is used to represent the result of an expression that is evaluated...
virtual std::string convertConstraint(const char *&Constraint) const
SourceLocation getBodyRBrace() const
getBodyRBrace - Gets the right brace of the body, if a body exists.
std::string generateAsmString(const ASTContext &C) const
Assemble final IR asm string.
Exposes information about the current target.
virtual StringRef getHelperName() const
Get the name of the capture helper.
static TypeEvaluationKind getEvaluationKind(QualType T)
hasAggregateLLVMType - Return true if the specified AST type will map into an aggregate LLVM type or ...
LabelDecl * getDecl() const
bool empty() const
Determines whether the exception-scopes stack is empty.
ValueDecl - Represent the declaration of a variable (in which case it is an lvalue) a function (in wh...
Expr - This represents one expression.
const Expr * getInputExpr(unsigned i) const
Enters a new scope for capturing cleanups, all of which will be executed once the scope is exited...
void EmitCaseStmt(const CaseStmt &S)
VarDecl * getConditionVariable() const
Retrieve the variable declared in this "while" statement, if any.
void EmitOMPTeamsDirective(const OMPTeamsDirective &S)
void SetInternalFunctionAttributes(const Decl *D, llvm::Function *F, const CGFunctionInfo &FI)
Set the attributes on the LLVM function for the given decl and function info.
Address EmitCompoundStmt(const CompoundStmt &S, bool GetLast=false, AggValueSlot AVS=AggValueSlot::ignored())
EmitCompoundStmt - Emit a compound statement {..} node.
LabelDecl * getConstantTarget()
getConstantTarget - Returns the fixed target of this indirect goto, if one exists.
bool haveRegionCounts() const
Whether or not we have PGO region data for the current function.
void EmitSEHTryStmt(const SEHTryStmt &S)
ASTContext & getContext() const
llvm::BasicBlock * getBlock() const
EHScopeStack::stable_iterator getScopeDepth() const
static llvm::MDNode * getAsmSrcLocInfo(const StringLiteral *Str, CodeGenFunction &CGF)
getAsmSrcLocInfo - Return the !srcloc metadata node to attach to an inline asm call instruction...
stable_iterator stable_begin() const
Create a stable reference to the top of the EH stack.
llvm::LLVMContext & getLLVMContext()
llvm::BasicBlock * GetIndirectGotoBlock()
llvm::IntegerType * Int32Ty
const SwitchCase * getSwitchCaseList() const
void EmitOMPMasterDirective(const OMPMasterDirective &S)
bool EvaluateAsInt(llvm::APSInt &Result, const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects) const
EvaluateAsInt - Return true if this is a constant which we can fold and convert to an integer...
llvm::Function * GenerateCapturedStmtFunction(const CapturedStmt &S)
Creates the outlined function for a CapturedStmt.
ReturnStmt - This represents a return, optionally of an expression: return; return 4;...
LValue MakeNaturalAlignAddrLValue(llvm::Value *V, QualType T)
void ResolveBranchFixups(llvm::BasicBlock *Target)
void EmitOMPBarrierDirective(const OMPBarrierDirective &S)
static CSFC_Result CollectStatementsForCase(const Stmt *S, const SwitchCase *Case, bool &FoundCase, SmallVectorImpl< const Stmt * > &ResultStmts)
virtual llvm::Value * getContextValue() const
unsigned getTiedOperand() const
StringRef getInputConstraint(unsigned i) const
getInputConstraint - Return the specified input constraint.
static AggValueSlot forAddr(Address addr, Qualifiers quals, IsDestructed_t isDestructed, NeedsGCBarriers_t needsGC, IsAliased_t isAliased, IsZeroed_t isZeroed=IsNotZeroed)
forAddr - Make a slot for an aggregate value.
llvm::StoreInst * CreateFlagStore(bool Value, llvm::Value *Addr)
Emit a store to an i1 flag variable.
GlobalDecl - represents a global declaration.
bool isCXXThisExprCaptured() const
DoStmt - This represents a 'do/while' stmt.
AsmStmt is the base class for GCCAsmStmt and MSAsmStmt.
void EmitDeclStmt(const DeclStmt &S)
The l-value was considered opaque, so the alignment was determined from a type.
LabelDecl * getLabel() const
void EmitOMPFlushDirective(const OMPFlushDirective &S)
bool HaveInsertPoint() const
HaveInsertPoint - True if an insertion point is defined.
bool SawAsmBlock
Whether we processed a Microsoft-style asm block during CodeGen.
Address CreateBitCast(Address Addr, llvm::Type *Ty, const llvm::Twine &Name="")
This captures a statement into a function.
ASTContext & getContext() const
Encodes a location in the source.
void EnsureInsertPoint()
EnsureInsertPoint - Ensure that an insertion point is defined so that emitted IR has a place to go...
void EmitOMPForDirective(const OMPForDirective &S)
A saved depth on the scope stack.
llvm::Value * EvaluateExprAsBool(const Expr *E)
EvaluateExprAsBool - Perform the usual unary conversions on the specified expression and compare the ...
void EmitObjCForCollectionStmt(const ObjCForCollectionStmt &S)
static OMPLinearClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, OpenMPLinearClauseKind Modifier, SourceLocation ModifierLoc, SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef< Expr * > VL, ArrayRef< Expr * > PL, ArrayRef< Expr * > IL, Expr *Step, Expr *CalcStep, Stmt *PreInit, Expr *PostUpdate)
Creates clause with a list of variables VL and a linear step Step.
DeclStmt - Adaptor class for mixing declarations with statements and expressions. ...
LabelDecl - Represents the declaration of a label.
const Expr * getCond() const
llvm::APSInt EvaluateKnownConstInt(const ASTContext &Ctx, SmallVectorImpl< PartialDiagnosticAt > *Diag=nullptr) const
EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded integer.
bool allowsMemory() const
param_iterator param_begin() const
Retrieve an iterator pointing to the first parameter decl.
void EmitOMPTaskgroupDirective(const OMPTaskgroupDirective &S)
void EmitOMPTargetParallelForSimdDirective(const OMPTargetParallelForSimdDirective &S)
void EmitOMPTeamsDistributeSimdDirective(const OMPTeamsDistributeSimdDirective &S)
const CodeGenOptions & getCodeGenOpts() const
void EmitOMPSingleDirective(const OMPSingleDirective &S)
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.
const LangOptions & getLangOpts() const
VarDecl * getConditionVariable() const
Retrieve the variable declared in this "switch" statement, if any.
SourceLocation getBegin() const
void EmitOMPForSimdDirective(const OMPForSimdDirective &S)
void EmitOMPAtomicDirective(const OMPAtomicDirective &S)
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...
void EmitOMPSectionDirective(const OMPSectionDirective &S)
void EmitOMPSectionsDirective(const OMPSectionsDirective &S)
void EmitForStmt(const ForStmt &S, ArrayRef< const Attr * > Attrs=None)
void EmitOMPTaskLoopDirective(const OMPTaskLoopDirective &S)
const CGFunctionInfo * CurFnInfo
void enterFullExpression(const ExprWithCleanups *E)
void EmitDecl(const Decl &D)
EmitDecl - Emit a declaration.
void FinishFunction(SourceLocation EndLoc=SourceLocation())
FinishFunction - Complete IR generation of the current function.
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
llvm::Value * EmitScalarExpr(const Expr *E, bool IgnoreResultAssign=false)
EmitScalarExpr - Emit the computation of the specified expression of LLVM scalar type, returning the result.
FunctionArgList - Type for representing both the decl and type of parameters to a function...
void EmitObjCAtSynchronizedStmt(const ObjCAtSynchronizedStmt &S)
void ErrorUnsupported(const Stmt *S, const char *Type)
Print out an error that codegen doesn't support the specified stmt yet.
CGFunctionInfo - Class to encapsulate the information about a function definition.
VarDecl * getConditionVariable() const
Retrieve the variable declared in this "if" statement, if any.
This class organizes the cross-function state that is used while generating LLVM code.
void EmitOMPTargetTeamsDirective(const OMPTargetTeamsDirective &S)
void EmitOMPTaskyieldDirective(const OMPTaskyieldDirective &S)
LValue InitCapturedStruct(const CapturedStmt &S)
void EmitOMPTargetParallelDirective(const OMPTargetParallelDirective &S)
const Stmt * getBody() const
llvm::Value * getScalarVal() const
getScalarVal() - Return the Value* of this scalar value.
void EmitOMPParallelForDirective(const OMPParallelForDirective &S)
CSFC_Result
CollectStatementsForCase - Given the body of a 'switch' statement and a constant value that is being ...
void push(llvm::BasicBlock *Header, const llvm::DebugLoc &StartLoc, const llvm::DebugLoc &EndLoc)
Begin a new structured loop.
bool hasTiedOperand() const
Return true if this input operand is a matching constraint that ties it to an output operand...
void EmitOMPTargetParallelForDirective(const OMPTargetParallelForDirective &S)
llvm::LoadInst * CreateLoad(Address Addr, const llvm::Twine &Name="")
llvm::IntegerType * IntPtrTy
void EmitOMPTeamsDistributeParallelForDirective(const OMPTeamsDistributeParallelForDirective &S)
StringRef getString() const
detail::InMemoryDirectory::const_iterator E
void EmitAggregateCopy(Address DestPtr, Address SrcPtr, QualType EltTy, bool isVolatile=false, bool isAssignment=false)
EmitAggregateCopy - Emit an aggregate copy.
void EmitOMPCancelDirective(const OMPCancelDirective &S)
llvm::StoreInst * CreateStore(llvm::Value *Val, Address Addr, bool IsVolatile=false)
const Expr * getRetValue() const
void EmitObjCAtThrowStmt(const ObjCAtThrowStmt &S)
body_iterator body_begin()
Stmt *const * const_body_iterator
specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext, providing only those that are of type SpecificDecl (or a class derived from it).
void EmitAggExpr(const Expr *E, AggValueSlot AS)
EmitAggExpr - Emit the computation of the specified expression of aggregate type. ...
void EmitCoreturnStmt(const CoreturnStmt &S)
const Stmt * getThen() const
JumpDest ReturnBlock
ReturnBlock - Unified return block.
static bool hasAggregateEvaluationKind(QualType T)
SwitchStmt - This represents a 'switch' stmt.
bool isEvaluatable(const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects) const
isEvaluatable - Call EvaluateAsRValue to see if this expression can be constant folded without side-e...
static stable_iterator invalid()
API for captured statement code generation.
static std::string SimplifyConstraint(const char *Constraint, const TargetInfo &Target, SmallVectorImpl< TargetInfo::ConstraintInfo > *OutCons=nullptr)
void EmitBlockWithFallThrough(llvm::BasicBlock *BB, const Stmt *S)
When instrumenting to collect profile data, the counts for some blocks such as switch cases need to n...
llvm::DebugLoc SourceLocToDebugLoc(SourceLocation Location)
Converts Location to a DebugLoc, if debug information is enabled.
void EmitStoreOfComplex(ComplexPairTy V, LValue dest, bool isInit)
EmitStoreOfComplex - Store a complex number into the specified l-value.
void EmitAsmStmt(const AsmStmt &S)
static std::string AddVariableConstraints(const std::string &Constraint, const Expr &AsmExpr, const TargetInfo &Target, CodeGenModule &CGM, const AsmStmt &Stmt, const bool EarlyClobber)
AddVariableConstraints - Look at AsmExpr and if it is a variable declared as using a particular regis...
llvm::PointerType * Int8PtrTy
const TargetInfo & Target
StringRef getNormalizedGCCRegisterName(StringRef Name, bool ReturnCanonical=false) const
Returns the "normalized" GCC register name.
bool allowsRegister() const
bool hasProfileClangInstr() const
Check if Clang profile instrumenation is on.
bool isNRVOVariable() const
Determine whether this local variable can be used with the named return value optimization (NRVO)...
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
SourceLocation getLocStart() const LLVM_READONLY
StringRef getClobber(unsigned i) const
ImplicitParamDecl * getContextParam() const
Retrieve the parameter containing captured variables.
void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false)
EmitBlock - Emit the given block.
void EmitOMPTargetEnterDataDirective(const OMPTargetEnterDataDirective &S)
ABIArgInfo & getReturnInfo()
SourceManager & getSourceManager()
void EmitOMPDistributeSimdDirective(const OMPDistributeSimdDirective &S)
DeclStmt * getRangeStmt()
void EmitStopPoint(const Stmt *S)
EmitStopPoint - Emit a debug stoppoint if we are emitting debug info.
GotoStmt - This represents a direct goto.
ArrayRef< const Attr * > getAttrs() const
unsigned NextCleanupDestIndex
param_iterator param_end() const
Retrieve an iterator one past the last parameter decl.
CapturedDecl * getCapturedDecl()
Retrieve the outlined function declaration.
void setCurrentStmt(const Stmt *S)
If the execution count for the current statement is known, record that as the current count...
llvm::DenseMap< const VarDecl *, llvm::Value * > NRVOFlags
A mapping from NRVO variables to the flags used to indicate when the NRVO has been applied to this va...
DiagnosticsEngine & getDiags() const
void EmitOMPTargetTeamsDistributeDirective(const OMPTargetTeamsDistributeDirective &S)
void EmitIfStmt(const IfStmt &S)
ContinueStmt - This represents a continue.
void EmitBranch(llvm::BasicBlock *Block)
EmitBranch - Emit a branch to the specified basic block from the current insert block, taking care to avoid creation of branches from dummy blocks.
void EmitReturnStmt(const ReturnStmt &S)
EmitReturnStmt - Note that due to GCC extensions, this can have an operand if the function returns vo...
llvm::Type * ConvertType(QualType T)
LValue MakeAddrLValue(Address Addr, QualType T, LValueBaseInfo BaseInfo=LValueBaseInfo(AlignmentSource::Type))
WhileStmt - This represents a 'while' stmt.
LValue EmitLValue(const Expr *E)
EmitLValue - Emit code to compute a designator that specifies the location of the expression...
const Expr * getCond() const
Address ReturnValue
ReturnValue - The temporary alloca to hold the return value.
void EmitLabelStmt(const LabelStmt &S)
Address getAggregateAddress() const
getAggregateAddr() - Return the Value* of the address of the aggregate.
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
RValue EmitLoadOfLValue(LValue V, SourceLocation Loc)
EmitLoadOfLValue - Given an expression that represents a value lvalue, this method emits the address ...
bool hasNormalCleanups() const
Determines whether there are any normal cleanups on the stack.
StringLiteral - This represents a string literal expression, e.g.
Defines the clang::TargetInfo interface.
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
CGCapturedStmtInfo * CapturedStmtInfo
stable_iterator getInnermostNormalCleanup() const
Returns the innermost normal cleanup on the stack, or stable_end() if there are no normal cleanups...
void EmitOMPTargetExitDataDirective(const OMPTargetExitDataDirective &S)
A reference to a declared variable, function, enum, etc.
static RValue get(llvm::Value *V)
bool EmitSimpleStmt(const Stmt *S)
EmitSimpleStmt - Try to emit a "simple" statement which does not necessarily require an insertion poi...
BreakStmt - This represents a break.
void EmitOMPTargetDataDirective(const OMPTargetDataDirective &S)
CapturedRegionKind
The different kinds of captured statement.
void EmitBranchThroughCleanup(JumpDest Dest)
EmitBranchThroughCleanup - Emit a branch from the current insert block through the normal cleanup han...
static ApplyDebugLocation CreateEmpty(CodeGenFunction &CGF)
Set the IRBuilder to not attach debug locations.
llvm::Constant * EmitCheckSourceLocation(SourceLocation Loc)
Emit a description of a source location in a format suitable for passing to a runtime sanitizer handl...
Address EmitCompoundStmtWithoutScope(const CompoundStmt &S, bool GetLast=false, AggValueSlot AVS=AggValueSlot::ignored())
void EmitOMPDistributeParallelForDirective(const OMPDistributeParallelForDirective &S)
DeclStmt * getLoopVarStmt()
unsigned getNumClobbers() const
A trivial tuple used to represent a source range.
SourceLocation getLocation() const
void EmitObjCAtTryStmt(const ObjCAtTryStmt &S)
LValue - This represents an lvalue references.
void EmitWhileStmt(const WhileStmt &S, ArrayRef< const Attr * > Attrs=None)
SourceLocation getLocationOfByte(unsigned ByteNo, const SourceManager &SM, const LangOptions &Features, const TargetInfo &Target, unsigned *StartToken=nullptr, unsigned *StartTokenByteOffset=nullptr) const
getLocationOfByte - Return a source location that points to the specified byte of this string literal...
SanitizerMetadata * getSanitizerMetadata()
void EmitBlockAfterUses(llvm::BasicBlock *BB)
EmitBlockAfterUses - Emit the given block somewhere hopefully near its uses, and leave the insertion ...
DeclStmt * getBeginStmt()
void EmitBreakStmt(const BreakStmt &S)
Expr *const * const_capture_init_iterator
Const iterator that walks over the capture initialization arguments.
void EmitObjCAutoreleasePoolStmt(const ObjCAutoreleasePoolStmt &S)
static bool containsBreak(const Stmt *S)
containsBreak - Return true if the statement contains a break out of it.
SourceLocation getLocStart() const LLVM_READONLY
capture_init_iterator capture_init_end()
Retrieve the iterator pointing one past the last initialization argument.
Address CreateMemTemp(QualType T, const Twine &Name="tmp", bool CastToDefaultAddrSpace=true)
CreateMemTemp - Create a temporary memory object of the given type, with appropriate alignment...
virtual bool hasBody() const
Returns true if this Decl represents a declaration for a body of code, such as a function or method d...
This class handles loading and caching of source files into memory.
Defines enum values for all the target-independent builtin functions.
void EmitOMPTaskDirective(const OMPTaskDirective &S)
bool requiresImmediateConstant() const
A class which abstracts out some details necessary for making a call.
Attr - This represents one attribute.
void EmitOMPTargetTeamsDistributeParallelForDirective(const OMPTargetTeamsDistributeParallelForDirective &S)
virtual void addReturnRegisterOutputs(CodeGen::CodeGenFunction &CGF, CodeGen::LValue ReturnValue, std::string &Constraints, std::vector< llvm::Type * > &ResultRegTypes, std::vector< llvm::Type * > &ResultTruncRegTypes, std::vector< CodeGen::LValue > &ResultRegDests, std::string &AsmString, unsigned NumOutputs) const
Adds constraints and types for result registers.
virtual const char * getClobbers() const =0
Returns a string of target-specific clobbers, in LLVM format.
llvm::FunctionType * GetFunctionType(const CGFunctionInfo &Info)
GetFunctionType - Get the LLVM function type for.