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;
41 Loc = S->getLocStart();
49 assert(S &&
"Null statement?");
66 assert(!isa<DeclStmt>(*S) &&
"Unexpected DeclStmt!");
77 switch (S->getStmtClass()) {
78 case Stmt::NoStmtClass:
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:
145 case Stmt::CoreturnStmtClass:
148 case Stmt::CapturedStmtClass: {
153 case Stmt::ObjCAtTryStmtClass:
156 case Stmt::ObjCAtCatchStmtClass:
158 "@catch statements should be handled by EmitObjCAtTryStmt");
159 case Stmt::ObjCAtFinallyStmtClass:
161 "@finally statements should be handled by EmitObjCAtTryStmt");
162 case Stmt::ObjCAtThrowStmtClass:
165 case Stmt::ObjCAtSynchronizedStmtClass:
168 case Stmt::ObjCForCollectionStmtClass:
171 case Stmt::ObjCAutoreleasePoolStmtClass:
175 case Stmt::CXXTryStmtClass:
178 case Stmt::CXXForRangeStmtClass:
181 case Stmt::SEHTryStmtClass:
184 case Stmt::OMPParallelDirectiveClass:
187 case Stmt::OMPSimdDirectiveClass:
190 case Stmt::OMPForDirectiveClass:
193 case Stmt::OMPForSimdDirectiveClass:
196 case Stmt::OMPSectionsDirectiveClass:
199 case Stmt::OMPSectionDirectiveClass:
202 case Stmt::OMPSingleDirectiveClass:
205 case Stmt::OMPMasterDirectiveClass:
208 case Stmt::OMPCriticalDirectiveClass:
211 case Stmt::OMPParallelForDirectiveClass:
214 case Stmt::OMPParallelForSimdDirectiveClass:
217 case Stmt::OMPParallelSectionsDirectiveClass:
220 case Stmt::OMPTaskDirectiveClass:
223 case Stmt::OMPTaskyieldDirectiveClass:
226 case Stmt::OMPBarrierDirectiveClass:
229 case Stmt::OMPTaskwaitDirectiveClass:
232 case Stmt::OMPTaskgroupDirectiveClass:
235 case Stmt::OMPFlushDirectiveClass:
238 case Stmt::OMPOrderedDirectiveClass:
241 case Stmt::OMPAtomicDirectiveClass:
244 case Stmt::OMPTargetDirectiveClass:
247 case Stmt::OMPTeamsDirectiveClass:
250 case Stmt::OMPCancellationPointDirectiveClass:
253 case Stmt::OMPCancelDirectiveClass:
256 case Stmt::OMPTargetDataDirectiveClass:
259 case Stmt::OMPTargetEnterDataDirectiveClass:
262 case Stmt::OMPTargetExitDataDirectiveClass:
265 case Stmt::OMPTargetParallelDirectiveClass:
268 case Stmt::OMPTargetParallelForDirectiveClass:
271 case Stmt::OMPTaskLoopDirectiveClass:
274 case Stmt::OMPTaskLoopSimdDirectiveClass:
277 case Stmt::OMPDistributeDirectiveClass:
280 case Stmt::OMPTargetUpdateDirectiveClass:
283 case Stmt::OMPDistributeParallelForDirectiveClass:
285 cast<OMPDistributeParallelForDirective>(*S));
287 case Stmt::OMPDistributeParallelForSimdDirectiveClass:
289 cast<OMPDistributeParallelForSimdDirective>(*S));
291 case Stmt::OMPDistributeSimdDirectiveClass:
294 case Stmt::OMPTargetParallelForSimdDirectiveClass:
296 cast<OMPTargetParallelForSimdDirective>(*S));
302 switch (S->getStmtClass()) {
303 default:
return false;
304 case Stmt::NullStmtClass:
break;
305 case Stmt::CompoundStmtClass:
EmitCompoundStmt(cast<CompoundStmt>(*S));
break;
306 case Stmt::DeclStmtClass:
EmitDeclStmt(cast<DeclStmt>(*S));
break;
307 case Stmt::LabelStmtClass:
EmitLabelStmt(cast<LabelStmt>(*S));
break;
308 case Stmt::AttributedStmtClass:
310 case Stmt::GotoStmtClass:
EmitGotoStmt(cast<GotoStmt>(*S));
break;
311 case Stmt::BreakStmtClass:
EmitBreakStmt(cast<BreakStmt>(*S));
break;
312 case Stmt::ContinueStmtClass:
EmitContinueStmt(cast<ContinueStmt>(*S));
break;
313 case Stmt::DefaultStmtClass:
EmitDefaultStmt(cast<DefaultStmt>(*S));
break;
314 case Stmt::CaseStmtClass:
EmitCaseStmt(cast<CaseStmt>(*S));
break;
315 case Stmt::SEHLeaveStmtClass:
EmitSEHLeaveStmt(cast<SEHLeaveStmt>(*S));
break;
327 "LLVM IR generation of compound statement ('{}')");
351 while (
const LabelStmt *LS = dyn_cast<LabelStmt>(LastStmt)) {
353 LastStmt = LS->getSubStmt();
358 QualType ExprTy = cast<Expr>(LastStmt)->getType();
376 llvm::BranchInst *BI = dyn_cast<llvm::BranchInst>(BB->getTerminator());
385 if (!BI || !BI->isUnconditional())
389 if (BI->getIterator() != BB->begin())
392 BB->replaceAllUsesWith(BI->getSuccessor(0));
393 BI->eraseFromParent();
394 BB->eraseFromParent();
398 llvm::BasicBlock *CurBB =
Builder.GetInsertBlock();
403 if (IsFinished && BB->use_empty()) {
410 if (CurBB && CurBB->getParent())
411 CurFn->getBasicBlockList().insertAfter(CurBB->getIterator(), BB);
413 CurFn->getBasicBlockList().push_back(BB);
421 llvm::BasicBlock *CurBB =
Builder.GetInsertBlock();
423 if (!CurBB || CurBB->getTerminator()) {
435 bool inserted =
false;
436 for (llvm::User *u : block->users()) {
437 if (llvm::Instruction *insn = dyn_cast<llvm::Instruction>(u)) {
438 CurFn->getBasicBlockList().insertAfter(insn->getParent()->getIterator(),
446 CurFn->getBasicBlockList().push_back(block);
454 if (Dest.
isValid())
return Dest;
492 assert(!Labels.empty());
498 i = Labels.begin(), e = Labels.end(); i != e; ++i) {
499 assert(
CGF.LabelMap.count(*i));
501 assert(dest.getScopeDepth().isValid());
502 assert(innermostScope.encloses(dest.getScopeDepth()));
503 dest.setScopeDepth(innermostScope);
508 ParentScope->Labels.append(Labels.begin(), Labels.end());
520 switch (SubStmt->getStmtClass()) {
521 case Stmt::DoStmtClass:
524 case Stmt::ForStmtClass:
527 case Stmt::WhileStmtClass:
530 case Stmt::CXXForRangeStmtClass:
558 llvm::BasicBlock *CurBB =
Builder.GetInsertBlock();
565 cast<llvm::PHINode>(IndGotoBB->begin())->addIncoming(V, CurBB);
590 std::swap(Executed, Skipped);
609 llvm::BasicBlock *ElseBlock = ContBlock;
655 Builder.getCurrentDebugLocation());
662 BreakContinueStack.push_back(BreakContinue(LoopExit, LoopHeader));
683 bool EmitBoolCondBranch =
true;
684 if (llvm::ConstantInt *C = dyn_cast<llvm::ConstantInt>(BoolCondVal))
686 EmitBoolCondBranch =
false;
690 if (EmitBoolCondBranch) {
691 llvm::BasicBlock *ExitBlock = LoopExit.
getBlock();
695 BoolCondVal, LoopBody, ExitBlock,
698 if (ExitBlock != LoopExit.
getBlock()) {
713 BreakContinueStack.pop_back();
729 if (!EmitBoolCondBranch)
741 BreakContinueStack.push_back(BreakContinue(LoopExit, LoopCond));
747 Builder.getCurrentDebugLocation());
765 BreakContinueStack.pop_back();
769 bool EmitBoolCondBranch =
true;
770 if (llvm::ConstantInt *C = dyn_cast<llvm::ConstantInt>(BoolCondVal))
772 EmitBoolCondBranch =
false;
775 if (EmitBoolCondBranch) {
778 BoolCondVal, LoopBody, LoopExit.
getBlock(),
779 createProfileWeightsForLoop(S.
getCond(), BackedgeCount));
789 if (!EmitBoolCondBranch)
799 llvm::DebugLoc DL =
Builder.getCurrentDebugLocation();
809 llvm::BasicBlock *CondBlock = Continue.
getBlock();
822 BreakContinueStack.push_back(BreakContinue(LoopExit, Continue));
834 llvm::BasicBlock *ExitBlock = LoopExit.
getBlock();
837 if (ForScope.requiresCleanups())
847 BoolCondVal, ForBody, ExitBlock,
850 if (ExitBlock != LoopExit.
getBlock()) {
875 BreakContinueStack.pop_back();
877 ConditionScope.ForceCleanup();
882 ForScope.ForceCleanup();
897 llvm::DebugLoc DL =
Builder.getCurrentDebugLocation();
914 llvm::BasicBlock *ExitBlock = LoopExit.
getBlock();
915 if (ForScope.requiresCleanups())
925 BoolCondVal, ForBody, ExitBlock,
928 if (ExitBlock != LoopExit.
getBlock()) {
940 BreakContinueStack.push_back(BreakContinue(LoopExit, Continue));
954 BreakContinueStack.pop_back();
958 ForScope.ForceCleanup();
966 void CodeGenFunction::EmitReturnOfRValue(
RValue RV,
QualType Ty) {
997 dyn_cast_or_null<ExprWithCleanups>(RV)) {
999 RV = cleanups->getSubExpr();
1047 ++NumSimpleReturnExprs;
1059 for (
const auto *
I : S.
decls())
1064 assert(!BreakContinueStack.empty() &&
"break stmt not in a loop or switch!");
1076 assert(!BreakContinueStack.empty() &&
"continue stmt not in a loop!");
1091 assert(S.
getRHS() &&
"Expected RHS value in CaseStmt");
1104 if (LHS.isSigned() ? RHS.slt(LHS) : RHS.ult(LHS))
1107 llvm::APInt Range = RHS - LHS;
1109 if (Range.ult(llvm::APInt(Range.getBitWidth(), 64))) {
1112 unsigned NCases = Range.getZExtValue() + 1;
1117 uint64_t Weight = Total / NCases, Rem = Total % NCases;
1118 for (
unsigned I = 0;
I != NCases; ++
I) {
1120 SwitchWeights->push_back(Weight + (Rem ? 1 : 0));
1123 SwitchInsn->addCase(
Builder.getInt(LHS), CaseDest);
1131 llvm::BasicBlock *RestoreBB =
Builder.GetInsertBlock();
1136 llvm::BasicBlock *FalseDest = CaseRangeBlock;
1139 CurFn->getBasicBlockList().push_back(CaseRangeBlock);
1140 Builder.SetInsertPoint(CaseRangeBlock);
1144 Builder.CreateSub(SwitchInsn->getCondition(),
Builder.getInt(LHS));
1148 llvm::MDNode *Weights =
nullptr;
1149 if (SwitchWeights) {
1151 uint64_t DefaultCount = (*SwitchWeights)[0];
1152 Weights = createProfileWeights(ThisCount, DefaultCount);
1157 (*SwitchWeights)[0] += ThisCount;
1159 Builder.CreateCondBr(Cond, CaseDest, FalseDest, Weights);
1163 Builder.SetInsertPoint(RestoreBB);
1165 Builder.ClearInsertionPoint();
1185 llvm::ConstantInt *CaseVal =
1194 JumpDest Block = BreakContinueStack.back().BreakBlock;
1200 SwitchInsn->addCase(CaseVal, Block.
getBlock());
1204 if (
Builder.GetInsertBlock()) {
1206 Builder.ClearInsertionPoint();
1216 SwitchInsn->addCase(CaseVal, CaseDest);
1231 while (NextCase && NextCase->
getRHS() ==
nullptr) {
1233 llvm::ConstantInt *CaseVal =
1243 SwitchInsn->addCase(CaseVal, CaseDest);
1260 llvm::BasicBlock *DefaultBlock = SwitchInsn->getDefaultDest();
1261 assert(DefaultBlock->empty() &&
1262 "EmitDefaultStmt: Default block already defined?");
1303 if (
const SwitchCase *SC = dyn_cast<SwitchCase>(S)) {
1317 if (!Case && isa<BreakStmt>(S))
1322 if (
const CompoundStmt *CS = dyn_cast<CompoundStmt>(S)) {
1330 bool HadSkippedDecl =
false;
1334 for (; Case && I !=
E; ++
I) {
1335 HadSkippedDecl |= isa<DeclStmt>(*I);
1350 for (++I; I !=
E; ++
I)
1360 assert(FoundCase &&
"Didn't find case but returned fallthrough?");
1375 for (; I !=
E; ++
I) {
1386 for (++I; I !=
E; ++
I)
1411 ResultStmts.push_back(S);
1420 const llvm::APSInt &ConstantCondValue,
1432 if (
const DefaultStmt *DS = dyn_cast<DefaultStmt>(Case)) {
1438 const CaseStmt *CS = cast<CaseStmt>(Case);
1440 if (CS->
getRHS())
return false;
1465 bool FoundCase =
false;
1474 llvm::SwitchInst *SavedSwitchInsn = SwitchInsn;
1476 llvm::BasicBlock *SavedCRBlock = CaseRangeBlock;
1480 llvm::APSInt ConstantCondValue;
1501 SwitchInsn =
nullptr;
1505 for (
unsigned i = 0, e = CaseStmts.size(); i != e; ++i)
1511 SwitchInsn = SavedSwitchInsn;
1533 SwitchInsn =
Builder.CreateSwitch(CondV, DefaultBlock);
1536 uint64_t DefaultCount = 0;
1537 unsigned NumCases = 0;
1541 if (isa<DefaultStmt>(Case))
1546 SwitchWeights->reserve(NumCases);
1549 SwitchWeights->push_back(DefaultCount);
1551 CaseRangeBlock = DefaultBlock;
1554 Builder.ClearInsertionPoint();
1559 if (!BreakContinueStack.empty())
1560 OuterContinue = BreakContinueStack.back().ContinueBlock;
1562 BreakContinueStack.push_back(BreakContinue(SwitchExit, OuterContinue));
1567 BreakContinueStack.pop_back();
1571 SwitchInsn->setDefaultDest(CaseRangeBlock);
1574 if (!DefaultBlock->getParent()) {
1582 DefaultBlock->replaceAllUsesWith(SwitchExit.
getBlock());
1583 delete DefaultBlock;
1598 auto *FD = dyn_cast_or_null<FunctionDecl>(Call->getCalleeDecl());
1599 if (FD && FD->getBuiltinID() == Builtin::BI__builtin_unpredictable) {
1601 SwitchInsn->setMetadata(llvm::LLVMContext::MD_unpredictable,
1602 MDHelper.createUnpredictable());
1606 if (SwitchWeights) {
1607 assert(SwitchWeights->size() == 1 + SwitchInsn->getNumCases() &&
1608 "switch weights do not match switch cases");
1610 if (SwitchWeights->size() > 1)
1611 SwitchInsn->setMetadata(llvm::LLVMContext::MD_prof,
1612 createProfileWeights(*SwitchWeights));
1613 delete SwitchWeights;
1615 SwitchInsn = SavedSwitchInsn;
1616 SwitchWeights = SavedSwitchWeights;
1617 CaseRangeBlock = SavedCRBlock;
1625 while (*Constraint) {
1626 switch (*Constraint) {
1638 while (Constraint[1] && Constraint[1] !=
',')
1643 Result += *Constraint;
1644 while (Constraint[1] && Constraint[1] == *Constraint)
1655 "Must pass output names to constraints with a symbolic name");
1658 assert(result &&
"Could not resolve symbolic name"); (void)result;
1659 Result += llvm::utostr(Index);
1686 AsmLabelAttr *
Attr = Variable->getAttr<AsmLabelAttr>();
1689 StringRef Register = Attr->getLabel();
1695 !Info.allowsRegister()) {
1701 return (EarlyClobber ?
"&{" :
"{") + Register.str() +
"}";
1707 std::string &ConstraintStr,
1716 if (Size <= 64 && llvm::isPowerOf2_64(Size)) {
1718 Ty = llvm::PointerType::getUnqual(Ty);
1724 ConstraintStr +=
'*';
1729 ConstraintStr +=
'*';
1737 const Expr *InputExpr,
1738 std::string &ConstraintStr) {
1746 "Required-immediate inlineasm arg isn't constant?");
1752 if (InputExpr->getStmtClass() == Expr::CXXThisExprClass)
1756 return EmitAsmInputLValue(Info, Dest, InputExpr->
getType(), ConstraintStr,
1768 Locs.push_back(llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
1771 if (!StrVal.empty()) {
1774 unsigned StartToken = 0;
1775 unsigned ByteOffset = 0;
1779 for (
unsigned i = 0, e = StrVal.size() - 1; i != e; ++i) {
1780 if (StrVal[i] !=
'\n')
continue;
1782 i + 1, SM, LangOpts, CGF.
getTarget(), &StartToken, &ByteOffset);
1783 Locs.push_back(llvm::ConstantAsMetadata::get(
1801 if (
const GCCAsmStmt *GAS = dyn_cast<GCCAsmStmt>(&S))
1802 Name = GAS->getOutputName(i);
1805 assert(IsValid &&
"Failed to parse output constraint");
1806 OutputConstraintInfos.push_back(Info);
1809 for (
unsigned i = 0, e = S.
getNumInputs(); i != e; i++) {
1811 if (
const GCCAsmStmt *GAS = dyn_cast<GCCAsmStmt>(&S))
1812 Name = GAS->getInputName(i);
1816 assert(IsValid &&
"Failed to parse input constraint"); (void)IsValid;
1817 InputConstraintInfos.push_back(Info);
1820 std::string Constraints;
1822 std::vector<LValue> ResultRegDests;
1823 std::vector<QualType> ResultRegQualTys;
1824 std::vector<llvm::Type *> ResultRegTypes;
1825 std::vector<llvm::Type *> ResultTruncRegTypes;
1826 std::vector<llvm::Type *> ArgTypes;
1827 std::vector<llvm::Value*> Args;
1830 std::string InOutConstraints;
1831 std::vector<llvm::Value*> InOutArgs;
1832 std::vector<llvm::Type*> InOutArgTypes;
1840 bool ReadOnly =
true, ReadNone =
true;
1858 if (!Constraints.empty())
1864 Constraints +=
"=" + OutputConstraint;
1865 ResultRegQualTys.push_back(OutExpr->getType());
1866 ResultRegDests.push_back(Dest);
1868 ResultTruncRegTypes.push_back(ResultRegTypes.back());
1875 for (InputNo = 0; InputNo != S.
getNumInputs(); ++InputNo) {
1880 assert(InputNo != S.
getNumInputs() &&
"Didn't find matching input!");
1883 QualType OutputType = OutExpr->getType();
1892 getTargetHooks().adjustInlineAsmType(*
this, OutputConstraint,
1893 ResultRegTypes.back()))
1894 ResultRegTypes.back() = AdjTy;
1897 diag::err_asm_invalid_type_in_input)
1898 << OutExpr->getType() << OutputConstraint;
1901 ArgTypes.push_back(Dest.getAddress().getType());
1902 Args.push_back(Dest.getPointer());
1903 Constraints +=
"=*";
1904 Constraints += OutputConstraint;
1905 ReadOnly = ReadNone =
false;
1909 InOutConstraints +=
',';
1922 InOutConstraints += llvm::utostr(i);
1924 InOutConstraints += OutputConstraint;
1926 InOutArgTypes.push_back(Arg->getType());
1927 InOutArgs.push_back(Arg);
1933 if (isa<MSAsmStmt>(&S)) {
1939 *
this, ReturnSlot, Constraints, ResultRegTypes, ResultTruncRegTypes,
1945 for (
unsigned i = 0, e = S.
getNumInputs(); i != e; i++) {
1953 if (!Constraints.empty())
1959 &OutputConstraintInfos);
1965 llvm::Value *Arg = EmitAsmInput(Info, InputExpr, Constraints);
1974 QualType OutputType = S.getOutputExpr(Output)->getType();
1980 if (isa<llvm::PointerType>(Arg->getType()))
1983 if (isa<llvm::IntegerType>(OutputTy))
1984 Arg =
Builder.CreateZExt(Arg, OutputTy);
1985 else if (isa<llvm::PointerType>(OutputTy))
1988 assert(OutputTy->isFloatingPointTy() &&
"Unexpected output type");
1989 Arg =
Builder.CreateFPExt(Arg, OutputTy);
1994 getTargetHooks().adjustInlineAsmType(*
this, InputConstraint,
1999 << InputExpr->
getType() << InputConstraint;
2001 ArgTypes.push_back(Arg->getType());
2002 Args.push_back(Arg);
2003 Constraints += InputConstraint;
2007 for (
unsigned i = 0, e = InOutArgs.size(); i != e; i++) {
2008 ArgTypes.push_back(InOutArgTypes[i]);
2009 Args.push_back(InOutArgs[i]);
2011 Constraints += InOutConstraints;
2017 if (Clobber ==
"memory")
2018 ReadOnly = ReadNone =
false;
2019 else if (Clobber !=
"cc")
2022 if (!Constraints.empty())
2025 Constraints +=
"~{";
2026 Constraints += Clobber;
2032 if (!MachineClobbers.empty()) {
2033 if (!Constraints.empty())
2035 Constraints += MachineClobbers;
2039 if (ResultRegTypes.empty())
2041 else if (ResultRegTypes.size() == 1)
2042 ResultType = ResultRegTypes[0];
2044 ResultType = llvm::StructType::get(
getLLVMContext(), ResultRegTypes);
2046 llvm::FunctionType *FTy =
2047 llvm::FunctionType::get(ResultType, ArgTypes,
false);
2050 llvm::InlineAsm::AsmDialect AsmDialect = isa<MSAsmStmt>(&
S) ?
2051 llvm::InlineAsm::AD_Intel : llvm::InlineAsm::AD_ATT;
2052 llvm::InlineAsm *IA =
2053 llvm::InlineAsm::get(FTy, AsmString, Constraints, HasSideEffect,
2055 llvm::CallInst *Result =
Builder.CreateCall(IA, Args);
2056 Result->addAttribute(llvm::AttributeSet::FunctionIndex,
2057 llvm::Attribute::NoUnwind);
2059 if (isa<MSAsmStmt>(&S)) {
2063 if (AsmString.find(
"__MSASMLABEL_") != std::string::npos)
2064 Result->addAttribute(llvm::AttributeSet::FunctionIndex,
2065 llvm::Attribute::NoDuplicate);
2069 if (!HasSideEffect) {
2071 Result->addAttribute(llvm::AttributeSet::FunctionIndex,
2072 llvm::Attribute::ReadNone);
2074 Result->addAttribute(llvm::AttributeSet::FunctionIndex,
2075 llvm::Attribute::ReadOnly);
2080 if (
const GCCAsmStmt *gccAsmStmt = dyn_cast<GCCAsmStmt>(&S)) {
2086 Result->setMetadata(
"srcloc",
2088 llvm::ConstantAsMetadata::get(Loc)));
2095 Result->addAttribute(llvm::AttributeSet::FunctionIndex,
2096 llvm::Attribute::Convergent);
2100 std::vector<llvm::Value*> RegResults;
2101 if (ResultRegTypes.size() == 1) {
2102 RegResults.push_back(Result);
2104 for (
unsigned i = 0, e = ResultRegTypes.size(); i != e; ++i) {
2106 RegResults.push_back(Tmp);
2110 assert(RegResults.size() == ResultRegTypes.size());
2111 assert(RegResults.size() == ResultTruncRegTypes.size());
2112 assert(RegResults.size() == ResultRegDests.size());
2113 for (
unsigned i = 0, e = RegResults.size(); i != e; ++i) {
2118 if (ResultRegTypes[i] != ResultTruncRegTypes[i]) {
2119 llvm::Type *TruncTy = ResultTruncRegTypes[i];
2123 if (TruncTy->isFloatingPointTy())
2124 Tmp =
Builder.CreateFPTrunc(Tmp, TruncTy);
2125 else if (TruncTy->isPointerTy() && Tmp->getType()->isIntegerTy()) {
2127 Tmp =
Builder.CreateTrunc(Tmp,
2129 Tmp =
Builder.CreateIntToPtr(Tmp, TruncTy);
2130 }
else if (Tmp->getType()->isPointerTy() && TruncTy->isIntegerTy()) {
2132 Tmp =
Builder.CreatePtrToInt(Tmp,
2134 Tmp =
Builder.CreateTrunc(Tmp, TruncTy);
2135 }
else if (TruncTy->isIntegerTy()) {
2136 Tmp =
Builder.CreateTrunc(Tmp, TruncTy);
2137 }
else if (TruncTy->isVectorTy()) {
2157 I !=
E; ++
I, ++CurField) {
2159 if (CurField->hasCapturedVLAType()) {
2160 auto VAT = CurField->getCapturedVLAType();
2197 "CapturedStmtInfo should be set when generating the captured function");
2201 assert(CD->hasBody() &&
"missing CapturedDecl body");
2219 F->addFnAttr(llvm::Attribute::NoUnwind);
2224 CD->
getBody()->getLocStart());
2231 Ctx.getTagDeclType(RD));
2232 for (
auto *FD : RD->
fields()) {
2233 if (FD->hasCapturedVLAType()) {
2236 auto VAT = FD->getCapturedVLAType();
2237 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 EmitInitializerForField(FieldDecl *Field, LValue LHS, Expr *Init, ArrayRef< VarDecl * > ArrayIndexes)
void EmitIndirectGotoStmt(const IndirectGotoStmt &S)
const SwitchCase * getNextSwitchCase() const
virtual void EmitBody(CodeGenFunction &CGF, const Stmt *S)
Emit the captured statement body.
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()
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 push(llvm::BasicBlock *Header, llvm::DebugLoc Location=llvm::DebugLoc())
Begin a new structured loop.
void EmitOMPDistributeDirective(const OMPDistributeDirective &S)
void EmitCXXTryStmt(const CXXTryStmt &S)
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.
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
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...
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...
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 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...
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
class LLVM_ALIGNAS(8) DependentTemplateSpecializationType const IdentifierInfo * Name
Represents a template specialization type whose template cannot be resolved, e.g. ...
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)
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
static bool hasScalarEvaluationKind(QualType T)
bool resolveSymbolicName(const char *&Name, ArrayRef< ConstraintInfo > OutputConstraints, unsigned &Index) const
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 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 incrementProfileCounter(const Stmt *S)
Increment the profiler's counter for the given statement.
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...
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)
LValue MakeAddrLValue(Address Addr, QualType T, AlignmentSource AlignSource=AlignmentSource::Type)
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
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.
The result type of a method or function.
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)
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.
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 EmitOMPTaskyieldDirective(const OMPTaskyieldDirective &S)
LValue InitCapturedStruct(const CapturedStmt &S)
void EmitOMPTargetParallelDirective(const OMPTargetParallelDirective &S)
Address CreateMemTemp(QualType T, const Twine &Name="tmp")
CreateMemTemp - Create a temporary memory object of the given type, with appropriate alignment...
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 ...
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
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. ...
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...
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
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 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)
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.
StringRef getNormalizedGCCRegisterName(StringRef Name) const
Returns the "normalized" GCC register name.
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.
void ForceCleanup()
Force the emission of cleanups now, instead of waiting until this object is destroyed.
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.
Address EmitCompoundStmtWithoutScope(const CompoundStmt &S, bool GetLast=false, AggValueSlot AVS=AggValueSlot::ignored())
void EmitOMPDistributeParallelForDirective(const OMPDistributeParallelForDirective &S)
DeclStmt * getLoopVarStmt()
unsigned getNumClobbers() 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...
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.
capture_init_iterator capture_init_end()
Retrieve the iterator pointing one past the last initialization argument.
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.
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.