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!");
80 if (
const auto *D = dyn_cast<OMPExecutableDirective>(S)) {
88 case Stmt::CXXCatchStmtClass:
89 case Stmt::SEHExceptStmtClass:
90 case Stmt::SEHFinallyStmtClass:
91 case Stmt::MSDependentExistsStmtClass:
92 llvm_unreachable(
"invalid statement class to emit generically");
93 case Stmt::NullStmtClass:
94 case Stmt::CompoundStmtClass:
95 case Stmt::DeclStmtClass:
96 case Stmt::LabelStmtClass:
97 case Stmt::AttributedStmtClass:
98 case Stmt::GotoStmtClass:
99 case Stmt::BreakStmtClass:
100 case Stmt::ContinueStmtClass:
101 case Stmt::DefaultStmtClass:
102 case Stmt::CaseStmtClass:
103 case Stmt::SEHLeaveStmtClass:
104 llvm_unreachable(
"should have emitted these statements as simple");
106 #define STMT(Type, Base) 107 #define ABSTRACT_STMT(Op) 108 #define EXPR(Type, Base) \ 109 case Stmt::Type##Class: 110 #include "clang/AST/StmtNodes.inc" 113 llvm::BasicBlock *incoming =
Builder.GetInsertBlock();
114 assert(incoming &&
"expression emission must have an insertion point");
118 llvm::BasicBlock *outgoing =
Builder.GetInsertBlock();
119 assert(outgoing &&
"expression emission cleared block!");
133 if (incoming != outgoing && outgoing->use_empty()) {
134 outgoing->eraseFromParent();
140 case Stmt::IndirectGotoStmtClass:
143 case Stmt::IfStmtClass:
EmitIfStmt(cast<IfStmt>(*S));
break;
144 case Stmt::WhileStmtClass:
EmitWhileStmt(cast<WhileStmt>(*S), Attrs);
break;
145 case Stmt::DoStmtClass:
EmitDoStmt(cast<DoStmt>(*S), Attrs);
break;
146 case Stmt::ForStmtClass:
EmitForStmt(cast<ForStmt>(*S), Attrs);
break;
148 case Stmt::ReturnStmtClass:
EmitReturnStmt(cast<ReturnStmt>(*S));
break;
150 case Stmt::SwitchStmtClass:
EmitSwitchStmt(cast<SwitchStmt>(*S));
break;
151 case Stmt::GCCAsmStmtClass:
152 case Stmt::MSAsmStmtClass:
EmitAsmStmt(cast<AsmStmt>(*S));
break;
153 case Stmt::CoroutineBodyStmtClass:
156 case Stmt::CoreturnStmtClass:
159 case Stmt::CapturedStmtClass: {
164 case Stmt::ObjCAtTryStmtClass:
167 case Stmt::ObjCAtCatchStmtClass:
169 "@catch statements should be handled by EmitObjCAtTryStmt");
170 case Stmt::ObjCAtFinallyStmtClass:
172 "@finally statements should be handled by EmitObjCAtTryStmt");
173 case Stmt::ObjCAtThrowStmtClass:
176 case Stmt::ObjCAtSynchronizedStmtClass:
179 case Stmt::ObjCForCollectionStmtClass:
182 case Stmt::ObjCAutoreleasePoolStmtClass:
186 case Stmt::CXXTryStmtClass:
189 case Stmt::CXXForRangeStmtClass:
192 case Stmt::SEHTryStmtClass:
195 case Stmt::OMPParallelDirectiveClass:
198 case Stmt::OMPSimdDirectiveClass:
201 case Stmt::OMPForDirectiveClass:
204 case Stmt::OMPForSimdDirectiveClass:
207 case Stmt::OMPSectionsDirectiveClass:
210 case Stmt::OMPSectionDirectiveClass:
213 case Stmt::OMPSingleDirectiveClass:
216 case Stmt::OMPMasterDirectiveClass:
219 case Stmt::OMPCriticalDirectiveClass:
222 case Stmt::OMPParallelForDirectiveClass:
225 case Stmt::OMPParallelForSimdDirectiveClass:
228 case Stmt::OMPParallelSectionsDirectiveClass:
231 case Stmt::OMPTaskDirectiveClass:
234 case Stmt::OMPTaskyieldDirectiveClass:
237 case Stmt::OMPBarrierDirectiveClass:
240 case Stmt::OMPTaskwaitDirectiveClass:
243 case Stmt::OMPTaskgroupDirectiveClass:
246 case Stmt::OMPFlushDirectiveClass:
249 case Stmt::OMPOrderedDirectiveClass:
252 case Stmt::OMPAtomicDirectiveClass:
255 case Stmt::OMPTargetDirectiveClass:
258 case Stmt::OMPTeamsDirectiveClass:
261 case Stmt::OMPCancellationPointDirectiveClass:
264 case Stmt::OMPCancelDirectiveClass:
267 case Stmt::OMPTargetDataDirectiveClass:
270 case Stmt::OMPTargetEnterDataDirectiveClass:
273 case Stmt::OMPTargetExitDataDirectiveClass:
276 case Stmt::OMPTargetParallelDirectiveClass:
279 case Stmt::OMPTargetParallelForDirectiveClass:
282 case Stmt::OMPTaskLoopDirectiveClass:
285 case Stmt::OMPTaskLoopSimdDirectiveClass:
288 case Stmt::OMPDistributeDirectiveClass:
291 case Stmt::OMPTargetUpdateDirectiveClass:
294 case Stmt::OMPDistributeParallelForDirectiveClass:
296 cast<OMPDistributeParallelForDirective>(*S));
298 case Stmt::OMPDistributeParallelForSimdDirectiveClass:
300 cast<OMPDistributeParallelForSimdDirective>(*S));
302 case Stmt::OMPDistributeSimdDirectiveClass:
305 case Stmt::OMPTargetParallelForSimdDirectiveClass:
307 cast<OMPTargetParallelForSimdDirective>(*S));
309 case Stmt::OMPTargetSimdDirectiveClass:
312 case Stmt::OMPTeamsDistributeDirectiveClass:
315 case Stmt::OMPTeamsDistributeSimdDirectiveClass:
317 cast<OMPTeamsDistributeSimdDirective>(*S));
319 case Stmt::OMPTeamsDistributeParallelForSimdDirectiveClass:
321 cast<OMPTeamsDistributeParallelForSimdDirective>(*S));
323 case Stmt::OMPTeamsDistributeParallelForDirectiveClass:
325 cast<OMPTeamsDistributeParallelForDirective>(*S));
327 case Stmt::OMPTargetTeamsDirectiveClass:
330 case Stmt::OMPTargetTeamsDistributeDirectiveClass:
332 cast<OMPTargetTeamsDistributeDirective>(*S));
334 case Stmt::OMPTargetTeamsDistributeParallelForDirectiveClass:
336 cast<OMPTargetTeamsDistributeParallelForDirective>(*S));
338 case Stmt::OMPTargetTeamsDistributeParallelForSimdDirectiveClass:
340 cast<OMPTargetTeamsDistributeParallelForSimdDirective>(*S));
342 case Stmt::OMPTargetTeamsDistributeSimdDirectiveClass:
344 cast<OMPTargetTeamsDistributeSimdDirective>(*S));
351 default:
return false;
352 case Stmt::NullStmtClass:
break;
353 case Stmt::CompoundStmtClass:
EmitCompoundStmt(cast<CompoundStmt>(*S));
break;
354 case Stmt::DeclStmtClass:
EmitDeclStmt(cast<DeclStmt>(*S));
break;
355 case Stmt::LabelStmtClass:
EmitLabelStmt(cast<LabelStmt>(*S));
break;
356 case Stmt::AttributedStmtClass:
358 case Stmt::GotoStmtClass:
EmitGotoStmt(cast<GotoStmt>(*S));
break;
359 case Stmt::BreakStmtClass:
EmitBreakStmt(cast<BreakStmt>(*S));
break;
360 case Stmt::ContinueStmtClass:
EmitContinueStmt(cast<ContinueStmt>(*S));
break;
361 case Stmt::DefaultStmtClass:
EmitDefaultStmt(cast<DefaultStmt>(*S));
break;
362 case Stmt::CaseStmtClass:
EmitCaseStmt(cast<CaseStmt>(*S));
break;
363 case Stmt::SEHLeaveStmtClass:
EmitSEHLeaveStmt(cast<SEHLeaveStmt>(*S));
break;
375 "LLVM IR generation of compound statement ('{}')");
389 E = S.
body_end()-GetLast; I != E; ++I)
399 while (
const LabelStmt *LS = dyn_cast<LabelStmt>(LastStmt)) {
401 LastStmt = LS->getSubStmt();
406 QualType ExprTy = cast<Expr>(LastStmt)->getType();
424 llvm::BranchInst *BI = dyn_cast<llvm::BranchInst>(BB->getTerminator());
433 if (!BI || !BI->isUnconditional())
437 if (BI->getIterator() != BB->begin())
440 BB->replaceAllUsesWith(BI->getSuccessor(0));
441 BI->eraseFromParent();
442 BB->eraseFromParent();
446 llvm::BasicBlock *CurBB =
Builder.GetInsertBlock();
451 if (IsFinished && BB->use_empty()) {
458 if (CurBB && CurBB->getParent())
459 CurFn->getBasicBlockList().insertAfter(CurBB->getIterator(), BB);
461 CurFn->getBasicBlockList().push_back(BB);
469 llvm::BasicBlock *CurBB =
Builder.GetInsertBlock();
471 if (!CurBB || CurBB->getTerminator()) {
483 bool inserted =
false;
484 for (llvm::User *u : block->users()) {
485 if (llvm::Instruction *insn = dyn_cast<llvm::Instruction>(u)) {
486 CurFn->getBasicBlockList().insertAfter(insn->getParent()->getIterator(),
494 CurFn->getBasicBlockList().push_back(block);
502 if (Dest.
isValid())
return Dest;
540 assert(!Labels.empty());
542 = CGF.EHStack.getInnermostNormalCleanup();
546 i = Labels.begin(), e = Labels.end(); i != e; ++i) {
547 assert(CGF.LabelMap.count(*i));
548 JumpDest &dest = CGF.LabelMap.find(*i)->second;
549 assert(dest.getScopeDepth().isValid());
550 assert(innermostScope.encloses(dest.getScopeDepth()));
551 dest.setScopeDepth(innermostScope);
556 ParentScope->Labels.append(Labels.begin(), Labels.end());
590 llvm::BasicBlock *CurBB =
Builder.GetInsertBlock();
597 cast<llvm::PHINode>(IndGotoBB->begin())->addIncoming(V, CurBB);
622 std::swap(Executed, Skipped);
641 llvm::BasicBlock *ElseBlock = ContBlock;
696 BreakContinueStack.push_back(BreakContinue(LoopExit, LoopHeader));
717 bool EmitBoolCondBranch =
true;
718 if (llvm::ConstantInt *C = dyn_cast<llvm::ConstantInt>(BoolCondVal))
720 EmitBoolCondBranch =
false;
724 if (EmitBoolCondBranch) {
725 llvm::BasicBlock *ExitBlock = LoopExit.
getBlock();
729 BoolCondVal, LoopBody, ExitBlock,
732 if (ExitBlock != LoopExit.
getBlock()) {
747 BreakContinueStack.pop_back();
763 if (!EmitBoolCondBranch)
775 BreakContinueStack.push_back(BreakContinue(LoopExit, LoopCond));
801 BreakContinueStack.pop_back();
805 bool EmitBoolCondBranch =
true;
806 if (llvm::ConstantInt *C = dyn_cast<llvm::ConstantInt>(BoolCondVal))
808 EmitBoolCondBranch =
false;
811 if (EmitBoolCondBranch) {
814 BoolCondVal, LoopBody, LoopExit.
getBlock(),
815 createProfileWeightsForLoop(S.
getCond(), BackedgeCount));
825 if (!EmitBoolCondBranch)
843 llvm::BasicBlock *CondBlock = Continue.
getBlock();
859 BreakContinueStack.push_back(BreakContinue(LoopExit, Continue));
871 llvm::BasicBlock *ExitBlock = LoopExit.
getBlock();
874 if (ForScope.requiresCleanups())
884 BoolCondVal, ForBody, ExitBlock,
887 if (ExitBlock != LoopExit.
getBlock()) {
912 BreakContinueStack.pop_back();
914 ConditionScope.ForceCleanup();
919 ForScope.ForceCleanup();
952 llvm::BasicBlock *ExitBlock = LoopExit.
getBlock();
953 if (ForScope.requiresCleanups())
963 BoolCondVal, ForBody, ExitBlock,
966 if (ExitBlock != LoopExit.
getBlock()) {
978 BreakContinueStack.push_back(BreakContinue(LoopExit, Continue));
992 BreakContinueStack.pop_back();
996 ForScope.ForceCleanup();
1004 void CodeGenFunction::EmitReturnOfRValue(
RValue RV,
QualType Ty) {
1020 if (requiresReturnValueCheck()) {
1023 new llvm::GlobalVariable(
CGM.
getModule(), SLoc->getType(),
false,
1024 llvm::GlobalVariable::PrivateLinkage, SLoc);
1025 SLocPtr->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
1027 assert(ReturnLocation.
isValid() &&
"No valid return location");
1035 Builder.ClearInsertionPoint();
1047 dyn_cast_or_null<ExprWithCleanups>(RV)) {
1049 RV = cleanups->getSubExpr();
1097 ++NumSimpleReturnExprs;
1109 for (
const auto *I : S.
decls())
1114 assert(!BreakContinueStack.empty() &&
"break stmt not in a loop or switch!");
1126 assert(!BreakContinueStack.empty() &&
"continue stmt not in a loop!");
1141 assert(S.
getRHS() &&
"Expected RHS value in CaseStmt");
1154 if (LHS.isSigned() ? RHS.slt(LHS) : RHS.ult(LHS))
1157 llvm::APInt Range = RHS - LHS;
1159 if (Range.ult(llvm::APInt(Range.getBitWidth(), 64))) {
1162 unsigned NCases = Range.getZExtValue() + 1;
1167 uint64_t Weight = Total / NCases, Rem = Total % NCases;
1168 for (
unsigned I = 0; I != NCases; ++I) {
1170 SwitchWeights->push_back(Weight + (Rem ? 1 : 0));
1173 SwitchInsn->addCase(
Builder.getInt(LHS), CaseDest);
1181 llvm::BasicBlock *RestoreBB =
Builder.GetInsertBlock();
1186 llvm::BasicBlock *FalseDest = CaseRangeBlock;
1189 CurFn->getBasicBlockList().push_back(CaseRangeBlock);
1190 Builder.SetInsertPoint(CaseRangeBlock);
1194 Builder.CreateSub(SwitchInsn->getCondition(),
Builder.getInt(LHS));
1198 llvm::MDNode *Weights =
nullptr;
1199 if (SwitchWeights) {
1201 uint64_t DefaultCount = (*SwitchWeights)[0];
1202 Weights = createProfileWeights(ThisCount, DefaultCount);
1207 (*SwitchWeights)[0] += ThisCount;
1209 Builder.CreateCondBr(Cond, CaseDest, FalseDest, Weights);
1213 Builder.SetInsertPoint(RestoreBB);
1215 Builder.ClearInsertionPoint();
1235 llvm::ConstantInt *CaseVal =
1244 JumpDest Block = BreakContinueStack.back().BreakBlock;
1250 SwitchInsn->addCase(CaseVal, Block.
getBlock());
1254 if (
Builder.GetInsertBlock()) {
1256 Builder.ClearInsertionPoint();
1266 SwitchInsn->addCase(CaseVal, CaseDest);
1281 while (NextCase && NextCase->
getRHS() ==
nullptr) {
1283 llvm::ConstantInt *CaseVal =
1293 SwitchInsn->addCase(CaseVal, CaseDest);
1310 llvm::BasicBlock *DefaultBlock = SwitchInsn->getDefaultDest();
1311 assert(DefaultBlock->empty() &&
1312 "EmitDefaultStmt: Default block already defined?");
1353 if (
const SwitchCase *SC = dyn_cast<SwitchCase>(S)) {
1367 if (!Case && isa<BreakStmt>(S))
1372 if (
const CompoundStmt *CS = dyn_cast<CompoundStmt>(S)) {
1376 bool StartedInLiveCode = FoundCase;
1377 unsigned StartSize = ResultStmts.size();
1384 bool HadSkippedDecl =
false;
1388 for (; Case && I != E; ++I) {
1404 for (++I; I != E; ++I)
1414 assert(FoundCase &&
"Didn't find case but returned fallthrough?");
1429 assert(!HadSkippedDecl &&
"fallthrough after skipping decl");
1434 bool AnyDecls =
false;
1435 for (; I != E; ++I) {
1448 for (++I; I != E; ++I)
1465 ResultStmts.resize(StartSize);
1466 ResultStmts.push_back(S);
1490 ResultStmts.push_back(S);
1499 const llvm::APSInt &ConstantCondValue,
1511 if (
const DefaultStmt *DS = dyn_cast<DefaultStmt>(Case)) {
1517 const CaseStmt *CS = cast<CaseStmt>(Case);
1519 if (CS->
getRHS())
return false;
1544 bool FoundCase =
false;
1553 llvm::SwitchInst *SavedSwitchInsn = SwitchInsn;
1555 llvm::BasicBlock *SavedCRBlock = CaseRangeBlock;
1559 llvm::APSInt ConstantCondValue;
1580 SwitchInsn =
nullptr;
1584 for (
unsigned i = 0, e = CaseStmts.size(); i != e; ++i)
1590 SwitchInsn = SavedSwitchInsn;
1612 SwitchInsn =
Builder.CreateSwitch(CondV, DefaultBlock);
1615 uint64_t DefaultCount = 0;
1616 unsigned NumCases = 0;
1620 if (isa<DefaultStmt>(Case))
1625 SwitchWeights->reserve(NumCases);
1628 SwitchWeights->push_back(DefaultCount);
1630 CaseRangeBlock = DefaultBlock;
1633 Builder.ClearInsertionPoint();
1638 if (!BreakContinueStack.empty())
1639 OuterContinue = BreakContinueStack.back().ContinueBlock;
1641 BreakContinueStack.push_back(BreakContinue(SwitchExit, OuterContinue));
1646 BreakContinueStack.pop_back();
1650 SwitchInsn->setDefaultDest(CaseRangeBlock);
1653 if (!DefaultBlock->getParent()) {
1661 DefaultBlock->replaceAllUsesWith(SwitchExit.
getBlock());
1662 delete DefaultBlock;
1677 auto *FD = dyn_cast_or_null<FunctionDecl>(Call->getCalleeDecl());
1678 if (FD && FD->getBuiltinID() == Builtin::BI__builtin_unpredictable) {
1680 SwitchInsn->setMetadata(llvm::LLVMContext::MD_unpredictable,
1681 MDHelper.createUnpredictable());
1685 if (SwitchWeights) {
1686 assert(SwitchWeights->size() == 1 + SwitchInsn->getNumCases() &&
1687 "switch weights do not match switch cases");
1689 if (SwitchWeights->size() > 1)
1690 SwitchInsn->setMetadata(llvm::LLVMContext::MD_prof,
1691 createProfileWeights(*SwitchWeights));
1692 delete SwitchWeights;
1694 SwitchInsn = SavedSwitchInsn;
1695 SwitchWeights = SavedSwitchWeights;
1696 CaseRangeBlock = SavedCRBlock;
1704 while (*Constraint) {
1705 switch (*Constraint) {
1717 while (Constraint[1] && Constraint[1] !=
',')
1722 Result += *Constraint;
1723 while (Constraint[1] && Constraint[1] == *Constraint)
1734 "Must pass output names to constraints with a symbolic name");
1737 assert(result &&
"Could not resolve symbolic name"); (void)result;
1738 Result += llvm::utostr(Index);
1765 AsmLabelAttr *
Attr = Variable->
getAttr<AsmLabelAttr>();
1768 StringRef Register = Attr->getLabel();
1774 !Info.allowsRegister()) {
1780 return (EarlyClobber ?
"&{" :
"{") + Register.str() +
"}";
1786 std::string &ConstraintStr,
1795 if (Size <= 64 && llvm::isPowerOf2_64(Size)) {
1797 Ty = llvm::PointerType::getUnqual(Ty);
1803 ConstraintStr +=
'*';
1808 ConstraintStr +=
'*';
1816 const Expr *InputExpr,
1817 std::string &ConstraintStr) {
1821 llvm::APSInt Result;
1825 "Required-immediate inlineasm arg isn't constant?");
1831 if (InputExpr->
getStmtClass() == Expr::CXXThisExprClass)
1835 return EmitAsmInputLValue(Info, Dest, InputExpr->
getType(), ConstraintStr,
1847 Locs.push_back(llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
1850 if (!StrVal.empty()) {
1853 unsigned StartToken = 0;
1854 unsigned ByteOffset = 0;
1858 for (
unsigned i = 0, e = StrVal.size() - 1; i != e; ++i) {
1859 if (StrVal[i] !=
'\n')
continue;
1861 i + 1, SM, LangOpts, CGF.
getTarget(), &StartToken, &ByteOffset);
1862 Locs.push_back(llvm::ConstantAsMetadata::get(
1880 if (
const GCCAsmStmt *GAS = dyn_cast<GCCAsmStmt>(&S))
1881 Name = GAS->getOutputName(i);
1884 assert(IsValid &&
"Failed to parse output constraint");
1885 OutputConstraintInfos.push_back(Info);
1888 for (
unsigned i = 0, e = S.
getNumInputs(); i != e; i++) {
1890 if (
const GCCAsmStmt *GAS = dyn_cast<GCCAsmStmt>(&S))
1891 Name = GAS->getInputName(i);
1895 assert(IsValid &&
"Failed to parse input constraint"); (void)IsValid;
1896 InputConstraintInfos.push_back(Info);
1899 std::string Constraints;
1901 std::vector<LValue> ResultRegDests;
1902 std::vector<QualType> ResultRegQualTys;
1903 std::vector<llvm::Type *> ResultRegTypes;
1904 std::vector<llvm::Type *> ResultTruncRegTypes;
1905 std::vector<llvm::Type *> ArgTypes;
1906 std::vector<llvm::Value*> Args;
1909 std::string InOutConstraints;
1910 std::vector<llvm::Value*> InOutArgs;
1911 std::vector<llvm::Type*> InOutArgTypes;
1919 bool ReadOnly =
true, ReadNone =
true;
1937 if (!Constraints.empty())
1943 Constraints +=
"=" + OutputConstraint;
1944 ResultRegQualTys.push_back(OutExpr->getType());
1945 ResultRegDests.push_back(Dest);
1947 ResultTruncRegTypes.push_back(ResultRegTypes.back());
1954 for (InputNo = 0; InputNo != S.
getNumInputs(); ++InputNo) {
1959 assert(InputNo != S.
getNumInputs() &&
"Didn't find matching input!");
1962 QualType OutputType = OutExpr->getType();
1972 ResultRegTypes.back()))
1973 ResultRegTypes.back() = AdjTy;
1976 diag::err_asm_invalid_type_in_input)
1977 << OutExpr->getType() << OutputConstraint;
1980 ArgTypes.push_back(Dest.getAddress().getType());
1981 Args.push_back(Dest.getPointer());
1982 Constraints +=
"=*";
1983 Constraints += OutputConstraint;
1984 ReadOnly = ReadNone =
false;
1988 InOutConstraints +=
',';
2001 InOutConstraints += llvm::utostr(i);
2003 InOutConstraints += OutputConstraint;
2005 InOutArgTypes.push_back(Arg->getType());
2006 InOutArgs.push_back(Arg);
2012 if (isa<MSAsmStmt>(&S)) {
2018 *
this, ReturnSlot, Constraints, ResultRegTypes, ResultTruncRegTypes,
2024 for (
unsigned i = 0, e = S.
getNumInputs(); i != e; i++) {
2032 if (!Constraints.empty())
2038 &OutputConstraintInfos);
2044 llvm::Value *Arg = EmitAsmInput(Info, InputExpr, Constraints);
2053 QualType OutputType = S.getOutputExpr(Output)->getType();
2059 if (isa<llvm::PointerType>(Arg->getType()))
2062 if (isa<llvm::IntegerType>(OutputTy))
2063 Arg =
Builder.CreateZExt(Arg, OutputTy);
2064 else if (isa<llvm::PointerType>(OutputTy))
2067 assert(OutputTy->isFloatingPointTy() &&
"Unexpected output type");
2068 Arg =
Builder.CreateFPExt(Arg, OutputTy);
2078 << InputExpr->
getType() << InputConstraint;
2080 ArgTypes.push_back(Arg->getType());
2081 Args.push_back(Arg);
2082 Constraints += InputConstraint;
2086 for (
unsigned i = 0, e = InOutArgs.size(); i != e; i++) {
2087 ArgTypes.push_back(InOutArgTypes[i]);
2088 Args.push_back(InOutArgs[i]);
2090 Constraints += InOutConstraints;
2096 if (Clobber ==
"memory")
2097 ReadOnly = ReadNone =
false;
2098 else if (Clobber !=
"cc")
2101 if (!Constraints.empty())
2104 Constraints +=
"~{";
2105 Constraints += Clobber;
2111 if (!MachineClobbers.empty()) {
2112 if (!Constraints.empty())
2114 Constraints += MachineClobbers;
2118 if (ResultRegTypes.empty())
2120 else if (ResultRegTypes.size() == 1)
2121 ResultType = ResultRegTypes[0];
2123 ResultType = llvm::StructType::get(
getLLVMContext(), ResultRegTypes);
2125 llvm::FunctionType *FTy =
2126 llvm::FunctionType::get(ResultType, ArgTypes,
false);
2129 llvm::InlineAsm::AsmDialect AsmDialect = isa<MSAsmStmt>(&S) ?
2130 llvm::InlineAsm::AD_Intel : llvm::InlineAsm::AD_ATT;
2131 llvm::InlineAsm *IA =
2132 llvm::InlineAsm::get(FTy, AsmString, Constraints, HasSideEffect,
2134 llvm::CallInst *Result =
Builder.CreateCall(IA, Args);
2135 Result->addAttribute(llvm::AttributeList::FunctionIndex,
2136 llvm::Attribute::NoUnwind);
2139 if (!HasSideEffect) {
2141 Result->addAttribute(llvm::AttributeList::FunctionIndex,
2142 llvm::Attribute::ReadNone);
2144 Result->addAttribute(llvm::AttributeList::FunctionIndex,
2145 llvm::Attribute::ReadOnly);
2150 if (
const GCCAsmStmt *gccAsmStmt = dyn_cast<GCCAsmStmt>(&S)) {
2156 Result->setMetadata(
"srcloc",
2158 llvm::ConstantAsMetadata::get(Loc)));
2161 if (
getLangOpts().assumeFunctionsAreConvergent()) {
2166 Result->addAttribute(llvm::AttributeList::FunctionIndex,
2167 llvm::Attribute::Convergent);
2171 std::vector<llvm::Value*> RegResults;
2172 if (ResultRegTypes.size() == 1) {
2173 RegResults.push_back(Result);
2175 for (
unsigned i = 0, e = ResultRegTypes.size(); i != e; ++i) {
2177 RegResults.push_back(Tmp);
2181 assert(RegResults.size() == ResultRegTypes.size());
2182 assert(RegResults.size() == ResultTruncRegTypes.size());
2183 assert(RegResults.size() == ResultRegDests.size());
2184 for (
unsigned i = 0, e = RegResults.size(); i != e; ++i) {
2189 if (ResultRegTypes[i] != ResultTruncRegTypes[i]) {
2190 llvm::Type *TruncTy = ResultTruncRegTypes[i];
2194 if (TruncTy->isFloatingPointTy())
2195 Tmp =
Builder.CreateFPTrunc(Tmp, TruncTy);
2196 else if (TruncTy->isPointerTy() && Tmp->getType()->isIntegerTy()) {
2198 Tmp =
Builder.CreateTrunc(Tmp,
2200 Tmp =
Builder.CreateIntToPtr(Tmp, TruncTy);
2201 }
else if (Tmp->getType()->isPointerTy() && TruncTy->isIntegerTy()) {
2203 Tmp =
Builder.CreatePtrToInt(Tmp,
2205 Tmp =
Builder.CreateTrunc(Tmp, TruncTy);
2206 }
else if (TruncTy->isIntegerTy()) {
2207 Tmp =
Builder.CreateZExtOrTrunc(Tmp, TruncTy);
2208 }
else if (TruncTy->isVectorTy()) {
2228 I != E; ++I, ++CurField) {
2230 if (CurField->hasCapturedVLAType()) {
2231 auto VAT = CurField->getCapturedVLAType();
2268 "CapturedStmtInfo should be set when generating the captured function");
2272 assert(CD->
hasBody() &&
"missing CapturedDecl body");
2289 F->addFnAttr(llvm::Attribute::NoUnwind);
2301 Ctx.getTagDeclType(RD));
2302 for (
auto *FD : RD->
fields()) {
2303 if (FD->hasCapturedVLAType()) {
2306 auto VAT = FD->getCapturedVLAType();
2307 VLASizeMap[VAT->getSizeExpr()] = ExprArg;
const CGFunctionInfo & arrangeBuiltinFunctionDeclaration(QualType resultType, const FunctionArgList &args)
A builtin function is a freestanding function using the default C conventions.
const llvm::DataLayout & getDataLayout() const
void EmitIndirectGotoStmt(const IndirectGotoStmt &S)
void EmitCoroutineBody(const CoroutineBodyStmt &S)
virtual void EmitBody(CodeGenFunction &CGF, const Stmt *S)
Emit the captured statement body.
This represents a GCC inline-assembly statement extension.
const Stmt * getElse() const
void EmitOMPTaskwaitDirective(const OMPTaskwaitDirective &S)
unsigned getNumInputs() const
unsigned getRawEncoding() const
When a SourceLocation itself cannot be used, this returns an (opaque) 32-bit integer encoding for it...
A (possibly-)qualified type.
capture_init_iterator capture_init_begin()
Retrieve the first initialization argument.
void EmitSEHLeaveStmt(const SEHLeaveStmt &S)
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.
const CodeGenOptions & getCodeGenOpts() const
static CSFC_Result CollectStatementsForCase(const Stmt *S, const SwitchCase *Case, bool &FoundCase, SmallVectorImpl< const Stmt *> &ResultStmts)
void EmitGotoStmt(const GotoStmt &S)
void EmitAttributedStmt(const AttributedStmt &S)
param_iterator param_begin() const
Retrieve an iterator pointing to the first parameter decl.
bool HaveInsertPoint() const
HaveInsertPoint - True if an insertion point is defined.
void EmitOMPDistributeDirective(const OMPDistributeDirective &S)
void EmitCXXTryStmt(const CXXTryStmt &S)
Stmt - This represents one statement.
IfStmt - This represents an if/then/else.
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...
static stable_iterator stable_end()
Create a stable reference to the bottom of the EH stack.
bool requiresCleanups() const
Determine whether this scope requires any cleanups.
StorageClass getStorageClass() const
Returns the storage class as written in the source.
void EmitOMPTargetSimdDirective(const OMPTargetSimdDirective &S)
unsigned getNumOutputs() 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.
void EmitOMPOrderedDirective(const OMPOrderedDirective &S)
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)
bool validateInputConstraint(MutableArrayRef< ConstraintInfo > OutputConstraints, ConstraintInfo &info) const
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
const RecordDecl * getCapturedRecordDecl() const
Retrieve the record declaration for captured variables.
stable_iterator stable_begin() const
Create a stable reference to the top of the EH stack.
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 getLocStart() const LLVM_READONLY
LValue EmitLValueForFieldInitialization(LValue Base, const FieldDecl *Field)
EmitLValueForFieldInitialization - Like EmitLValueForField, except that if the Field is a reference...
SourceLocation getLocStart() const LLVM_READONLY
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.
Represents a point when we exit a loop.
VarDecl * getConditionVariable() const
Retrieve the variable declared in this "while" statement, if any.
bool empty() const
Determines whether the exception-scopes stack is empty.
void EmitOMPParallelForSimdDirective(const OMPParallelForSimdDirective &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...
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)
const VarDecl * getNRVOCandidate() const
Retrieve the variable that might be used for the named return value optimization. ...
uint64_t getProfileCount(const Stmt *S)
Get the profiler's count for the given statement.
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.
DiagnosticsEngine & getDiags() const
void EmitLabel(const LabelDecl *D)
EmitLabel - Emit the block for the given label.
Represents an expression – generally a full-expression – that introduces cleanups to be run at the ...
void EmitOMPTeamsDistributeDirective(const OMPTeamsDistributeDirective &S)
VarDecl * getConditionVariable() const
Retrieve the variable declared in this "switch" statement, if any.
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)
bool isObviouslyBranchWithoutCleanups(JumpDest Dest) const
isObviouslyBranchWithoutCleanups - Return true if a branch to the specified destination obviously has...
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.
const TargetInfo & getTarget() const
void EmitOMPSimdDirective(const OMPSimdDirective &S)
void setScopeDepth(EHScopeStack::stable_iterator depth)
Address getAddress() 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 ...
StringRef getNormalizedGCCRegisterName(StringRef Name, bool ReturnCanonical=false) const
Returns the "normalized" GCC register name.
void addLabel(const LabelDecl *label)
RValue EmitReferenceBindingToExpr(const Expr *E)
Emits a reference binding to the passed in expression.
field_range fields() const
FieldDecl - An instance of this class is created by Sema::ActOnField to represent a member of a struc...
ImplicitParamDecl * getContextParam() const
Retrieve the parameter containing captured variables.
void rescopeLabels()
Change the cleanup scope of the labels in this lexical scope to match the scope of the enclosing cont...
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...
const Expr * getRetValue() const
bool isReferenceType() const
virtual void setContextValue(llvm::Value *V)
void EmitForStmt(const ForStmt &S, ArrayRef< const Attr *> Attrs=None)
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
void EmitOMPDistributeParallelForSimdDirective(const OMPDistributeParallelForSimdDirective &S)
void EmitInitializerForField(FieldDecl *Field, LValue LHS, Expr *Init)
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 hasMatchingInput() const
Return true if this output operand has a matching (tied) input operand.
Expr *const * const_capture_init_iterator
Const iterator that walks over the capture initialization arguments.
void EmitOMPTargetTeamsDistributeSimdDirective(const OMPTargetTeamsDistributeSimdDirective &S)
ForStmt - This represents a 'for (init;cond;inc)' stmt.
void pop()
End the current loop.
LabelDecl * getDecl() const
SourceLocation getLBracLoc() const
void EmitOMPCancellationPointDirective(const OMPCancellationPointDirective &S)
RAII for correct setting/restoring of CapturedStmtInfo.
const Expr * getOutputExpr(unsigned i) const
param_iterator param_end() const
Retrieve an iterator one past the last parameter decl.
void EmitOMPTeamsDistributeParallelForSimdDirective(const OMPTeamsDistributeParallelForSimdDirective &S)
void EmitContinueStmt(const ContinueStmt &S)
void EmitOMPTargetDirective(const OMPTargetDirective &S)
bool hasNormalCleanups() const
Determines whether there are any normal cleanups on the stack.
CXXForRangeStmt - This represents C++0x [stmt.ranged]'s ranged for statement, represented as 'for (ra...
bool isCXXThisExprCaptured() const
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...
Scope - A scope is a transient data structure that is used while parsing the program.
field_iterator field_begin() const
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...
void ForceCleanup(std::initializer_list< llvm::Value **> ValuesToReload={})
Force the emission of cleanups now, instead of waiting until this object is destroyed.
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.
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.
VarDecl * getConditionVariable() const
Retrieve the variable declared in this "for" statement, if any.
Address getAggregateAddress() const
getAggregateAddr() - Return the Value* of the address of the aggregate.
bool isValidGCCRegisterName(StringRef Name) const
Returns whether the passed in string is a valid register name according to GCC.
LValue EmitLValueForField(LValue Base, const FieldDecl *Field)
StringRef getString() const
CompoundStmt - This represents a group of statements like { stmt stmt }.
ASTContext & getContext() 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...
llvm::APSInt EvaluateKnownConstInt(const ASTContext &Ctx, SmallVectorImpl< PartialDiagnosticAt > *Diag=nullptr) const
EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded integer.
std::string generateAsmString(const ASTContext &C) const
Assemble final IR asm string.
Exposes information about the current target.
static TypeEvaluationKind getEvaluationKind(QualType T)
getEvaluationKind - Return the TypeEvaluationKind of QualType T.
EHScopeStack::stable_iterator getScopeDepth() const
ValueDecl - Represent the declaration of a variable (in which case it is an lvalue) a function (in wh...
Expr - This represents one expression.
Enters a new scope for capturing cleanups, all of which will be executed once the scope is exited...
void EmitCaseStmt(const CaseStmt &S)
std::pair< llvm::Value *, llvm::Value * > getComplexVal() const
getComplexVal - Return the real/imag components of this complex value.
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.
llvm::BasicBlock * getBlock() const
const Stmt * getThen() const
Address EmitCompoundStmt(const CompoundStmt &S, bool GetLast=false, AggValueSlot AVS=AggValueSlot::ignored())
EmitCompoundStmt - Emit a compound statement {..} node.
bool requiresImmediateConstant() const
LabelDecl * getConstantTarget()
getConstantTarget - Returns the fixed target of this indirect goto, if one exists.
void EmitSEHTryStmt(const SEHTryStmt &S)
static llvm::MDNode * getAsmSrcLocInfo(const StringLiteral *Str, CodeGenFunction &CGF)
getAsmSrcLocInfo - Return the !srcloc metadata node to attach to an inline asm call instruction...
llvm::LLVMContext & getLLVMContext()
llvm::BasicBlock * GetIndirectGotoBlock()
llvm::IntegerType * Int32Ty
void EmitOMPMasterDirective(const OMPMasterDirective &S)
LabelDecl * getLabel() const
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)
QualType getRecordType(const RecordDecl *Decl) const
void ResolveBranchFixups(llvm::BasicBlock *Target)
SourceLocation getEnd() const
void EmitOMPBarrierDirective(const OMPBarrierDirective &S)
StringRef getClobber(unsigned i) const
const LangOptions & getLangOpts() const
ASTContext & getContext() const
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.
Stmt *const * const_body_iterator
llvm::StoreInst * CreateFlagStore(bool Value, llvm::Value *Addr)
Emit a store to an i1 flag variable.
GlobalDecl - represents a global declaration.
void EmitSimpleOMPExecutableDirective(const OMPExecutableDirective &D)
Emit simple code for OpenMP directives in Simd-only mode.
DoStmt - This represents a 'do/while' stmt.
AsmStmt is the base class for GCCAsmStmt and MSAsmStmt.
void EmitDeclStmt(const DeclStmt &S)
virtual bool hasBody() const
Returns true if this Decl represents a declaration for a body of code, such as a function or method d...
The l-value was considered opaque, so the alignment was determined from a type.
void EmitOMPFlushDirective(const OMPFlushDirective &S)
virtual llvm::Value * getContextValue() const
bool SawAsmBlock
Whether we processed a Microsoft-style asm block during CodeGen.
Address CreateBitCast(Address Addr, llvm::Type *Ty, const llvm::Twine &Name="")
StringRef getInputConstraint(unsigned i) const
getInputConstraint - Return the specified input constraint.
This captures a statement into a function.
StringRef getOutputConstraint(unsigned i) const
getOutputConstraint - Return the constraint string for the specified output operand.
Encodes a location in the source.
void EmitDoStmt(const DoStmt &S, ArrayRef< const Attr *> Attrs=None)
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 ...
const SwitchCase * getSwitchCaseList() const
void EmitObjCForCollectionStmt(const ObjCForCollectionStmt &S)
ArrayRef< const Attr * > getAttrs() const
DeclStmt - Adaptor class for mixing declarations with statements and expressions. ...
LabelDecl - Represents the declaration of a label.
void EmitStmt(const Stmt *S, ArrayRef< const Attr *> Attrs=None)
EmitStmt - Emit the code for the statement.
void EmitOMPTaskgroupDirective(const OMPTaskgroupDirective &S)
void EmitOMPTargetParallelForSimdDirective(const OMPTargetParallelForSimdDirective &S)
bool validateOutputConstraint(ConstraintInfo &Info) const
void EmitOMPTeamsDistributeSimdDirective(const OMPTeamsDistributeSimdDirective &S)
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.
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 EmitOMPTaskLoopDirective(const OMPTaskLoopDirective &S)
virtual FieldDecl * getThisFieldDecl() const
const CGFunctionInfo * CurFnInfo
void enterFullExpression(const ExprWithCleanups *E)
void EmitDecl(const Decl &D)
EmitDecl - Emit a declaration.
const TargetCodeGenInfo & getTargetHooks() const
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.
void EmitWhileStmt(const WhileStmt &S, ArrayRef< const Attr *> Attrs=None)
FunctionArgList - Type for representing both the decl and type of parameters to a function...
llvm::Value * getScalarVal() const
getScalarVal() - Return the Value* of this scalar value.
LabelStmt * getStmt() const
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.
VarDecl * getConditionVariable() const
Retrieve the variable declared in this "if" statement, if any.
CGFunctionInfo - Class to encapsulate the information about a function definition.
This class organizes the cross-function state that is used while generating LLVM code.
void EmitOMPTargetTeamsDirective(const OMPTargetTeamsDirective &S)
Dataflow Directional Tag Classes.
void EmitOMPTaskyieldDirective(const OMPTaskyieldDirective &S)
LValue InitCapturedStruct(const CapturedStmt &S)
void EmitOMPTargetParallelDirective(const OMPTargetParallelDirective &S)
bool allowsMemory() const
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.
void EmitOMPTargetParallelForDirective(const OMPTargetParallelForDirective &S)
llvm::LoadInst * CreateLoad(Address Addr, const llvm::Twine &Name="")
llvm::IntegerType * IntPtrTy
StmtClass getStmtClass() const
void EmitOMPTeamsDistributeParallelForDirective(const OMPTeamsDistributeParallelForDirective &S)
void EmitAggregateCopy(Address DestPtr, Address SrcPtr, QualType EltTy, bool isVolatile=false, bool isAssignment=false)
EmitAggregateCopy - Emit an aggregate copy.
void EmitOMPCancelDirective(const OMPCancelDirective &S)
bool hasTiedOperand() const
Return true if this input operand is a matching constraint that ties it to an output operand...
llvm::StoreInst * CreateStore(llvm::Value *Val, Address Addr, bool IsVolatile=false)
llvm::Module & getModule() const
void EmitObjCAtThrowStmt(const ObjCAtThrowStmt &S)
body_iterator body_begin()
LValue MakeAddrLValue(Address Addr, QualType T, AlignmentSource Source=AlignmentSource::Type)
bool hasProfileClangInstr() const
Check if Clang profile instrumenation is on.
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).
bool allowsRegister() const
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 * getBody() const
JumpDest ReturnBlock
ReturnBlock - Unified return block.
virtual StringRef getHelperName() const
Get the name of the capture helper.
static bool hasAggregateEvaluationKind(QualType T)
SwitchStmt - This represents a 'switch' stmt.
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...
bool resolveSymbolicName(const char *&Name, ArrayRef< ConstraintInfo > OutputConstraints, unsigned &Index) const
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
unsigned getTiedOperand() const
const Expr * getInputExpr(unsigned i) const
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
SourceLocation getLocStart() const LLVM_READONLY
void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false)
EmitBlock - Emit the given block.
void EmitOMPTargetEnterDataDirective(const OMPTargetEnterDataDirective &S)
ABIArgInfo & getReturnInfo()
unsigned getNumClobbers() const
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
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.
SourceLocation getAsmLoc() const
GotoStmt - This represents a direct goto.
unsigned NextCleanupDestIndex
const SwitchCase * getNextSwitchCase() const
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...
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.
bool isNRVOVariable() const
Determine whether this local variable can be used with the named return value optimization (NRVO)...
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)
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.
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...
Address ReturnValue
ReturnValue - The temporary alloca to hold the return value.
void EmitLabelStmt(const LabelStmt &S)
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 ...
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]).
StringRef getName() const
getName - Get the name of identifier for this declaration as a StringRef.
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.
CGCapturedStmtInfo * CapturedStmtInfo
void EmitOMPTargetExitDataDirective(const OMPTargetExitDataDirective &S)
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...
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...
void EmitCXXForRangeStmt(const CXXForRangeStmt &S, ArrayRef< const Attr *> Attrs=None)
Address EmitCompoundStmtWithoutScope(const CompoundStmt &S, bool GetLast=false, AggValueSlot AVS=AggValueSlot::ignored())
void EmitOMPDistributeParallelForDirective(const OMPDistributeParallelForDirective &S)
DeclStmt * getLoopVarStmt()
const Expr * getCond() const
A trivial tuple used to represent a source range.
void EmitObjCAtTryStmt(const ObjCAtTryStmt &S)
LValue - This represents an lvalue references.
SanitizerMetadata * getSanitizerMetadata()
void EmitBlockAfterUses(llvm::BasicBlock *BB)
EmitBlockAfterUses - Emit the given block somewhere hopefully near its uses, and leave the insertion ...
const LangOptions & getLangOpts() const
DeclStmt * getBeginStmt()
void EmitBreakStmt(const BreakStmt &S)
const Expr * getCond() const
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
SourceLocation getBegin() const
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...
llvm::Value * getPointer() const
This class handles loading and caching of source files into memory.
bool haveRegionCounts() const
Whether or not we have PGO region data for the current function.
Defines enum values for all the target-independent builtin functions.
void EmitOMPTaskDirective(const OMPTaskDirective &S)
SourceLocation getBodyRBrace() const
getBodyRBrace - Gets the right brace of the body, if a body exists.
CapturedRegionKind getCapturedRegionKind() const
Retrieve the captured region kind.
Attr - This represents one attribute.
SourceLocation getLocation() const
virtual std::string convertConstraint(const char *&Constraint) const
void EmitOMPTargetTeamsDistributeParallelForDirective(const OMPTargetTeamsDistributeParallelForDirective &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.
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.