21 #include "llvm/ADT/StringExtras.h" 22 #include "llvm/IR/DataLayout.h" 23 #include "llvm/IR/InlineAsm.h" 24 #include "llvm/IR/Intrinsics.h" 25 #include "llvm/IR/MDBuilder.h" 27 using namespace clang;
28 using namespace CodeGen;
45 assert(S &&
"Null statement?");
62 assert(!isa<DeclStmt>(*S) &&
"Unexpected DeclStmt!");
76 if (
const auto *D = dyn_cast<OMPExecutableDirective>(S)) {
84 case Stmt::CXXCatchStmtClass:
85 case Stmt::SEHExceptStmtClass:
86 case Stmt::SEHFinallyStmtClass:
87 case Stmt::MSDependentExistsStmtClass:
88 llvm_unreachable(
"invalid statement class to emit generically");
89 case Stmt::NullStmtClass:
90 case Stmt::CompoundStmtClass:
91 case Stmt::DeclStmtClass:
92 case Stmt::LabelStmtClass:
93 case Stmt::AttributedStmtClass:
94 case Stmt::GotoStmtClass:
95 case Stmt::BreakStmtClass:
96 case Stmt::ContinueStmtClass:
97 case Stmt::DefaultStmtClass:
98 case Stmt::CaseStmtClass:
99 case Stmt::SEHLeaveStmtClass:
100 llvm_unreachable(
"should have emitted these statements as simple");
102 #define STMT(Type, Base) 103 #define ABSTRACT_STMT(Op) 104 #define EXPR(Type, Base) \ 105 case Stmt::Type##Class: 106 #include "clang/AST/StmtNodes.inc" 109 llvm::BasicBlock *incoming =
Builder.GetInsertBlock();
110 assert(incoming &&
"expression emission must have an insertion point");
114 llvm::BasicBlock *outgoing =
Builder.GetInsertBlock();
115 assert(outgoing &&
"expression emission cleared block!");
129 if (incoming != outgoing && outgoing->use_empty()) {
130 outgoing->eraseFromParent();
136 case Stmt::IndirectGotoStmtClass:
139 case Stmt::IfStmtClass:
EmitIfStmt(cast<IfStmt>(*S));
break;
140 case Stmt::WhileStmtClass:
EmitWhileStmt(cast<WhileStmt>(*S), Attrs);
break;
141 case Stmt::DoStmtClass:
EmitDoStmt(cast<DoStmt>(*S), Attrs);
break;
142 case Stmt::ForStmtClass:
EmitForStmt(cast<ForStmt>(*S), Attrs);
break;
144 case Stmt::ReturnStmtClass:
EmitReturnStmt(cast<ReturnStmt>(*S));
break;
146 case Stmt::SwitchStmtClass:
EmitSwitchStmt(cast<SwitchStmt>(*S));
break;
147 case Stmt::GCCAsmStmtClass:
148 case Stmt::MSAsmStmtClass:
EmitAsmStmt(cast<AsmStmt>(*S));
break;
149 case Stmt::CoroutineBodyStmtClass:
152 case Stmt::CoreturnStmtClass:
155 case Stmt::CapturedStmtClass: {
160 case Stmt::ObjCAtTryStmtClass:
163 case Stmt::ObjCAtCatchStmtClass:
165 "@catch statements should be handled by EmitObjCAtTryStmt");
166 case Stmt::ObjCAtFinallyStmtClass:
168 "@finally statements should be handled by EmitObjCAtTryStmt");
169 case Stmt::ObjCAtThrowStmtClass:
172 case Stmt::ObjCAtSynchronizedStmtClass:
175 case Stmt::ObjCForCollectionStmtClass:
178 case Stmt::ObjCAutoreleasePoolStmtClass:
182 case Stmt::CXXTryStmtClass:
185 case Stmt::CXXForRangeStmtClass:
188 case Stmt::SEHTryStmtClass:
191 case Stmt::OMPParallelDirectiveClass:
194 case Stmt::OMPSimdDirectiveClass:
197 case Stmt::OMPForDirectiveClass:
200 case Stmt::OMPForSimdDirectiveClass:
203 case Stmt::OMPSectionsDirectiveClass:
206 case Stmt::OMPSectionDirectiveClass:
209 case Stmt::OMPSingleDirectiveClass:
212 case Stmt::OMPMasterDirectiveClass:
215 case Stmt::OMPCriticalDirectiveClass:
218 case Stmt::OMPParallelForDirectiveClass:
221 case Stmt::OMPParallelForSimdDirectiveClass:
224 case Stmt::OMPParallelSectionsDirectiveClass:
227 case Stmt::OMPTaskDirectiveClass:
230 case Stmt::OMPTaskyieldDirectiveClass:
233 case Stmt::OMPBarrierDirectiveClass:
236 case Stmt::OMPTaskwaitDirectiveClass:
239 case Stmt::OMPTaskgroupDirectiveClass:
242 case Stmt::OMPFlushDirectiveClass:
245 case Stmt::OMPOrderedDirectiveClass:
248 case Stmt::OMPAtomicDirectiveClass:
251 case Stmt::OMPTargetDirectiveClass:
254 case Stmt::OMPTeamsDirectiveClass:
257 case Stmt::OMPCancellationPointDirectiveClass:
260 case Stmt::OMPCancelDirectiveClass:
263 case Stmt::OMPTargetDataDirectiveClass:
266 case Stmt::OMPTargetEnterDataDirectiveClass:
269 case Stmt::OMPTargetExitDataDirectiveClass:
272 case Stmt::OMPTargetParallelDirectiveClass:
275 case Stmt::OMPTargetParallelForDirectiveClass:
278 case Stmt::OMPTaskLoopDirectiveClass:
281 case Stmt::OMPTaskLoopSimdDirectiveClass:
284 case Stmt::OMPDistributeDirectiveClass:
287 case Stmt::OMPTargetUpdateDirectiveClass:
290 case Stmt::OMPDistributeParallelForDirectiveClass:
292 cast<OMPDistributeParallelForDirective>(*S));
294 case Stmt::OMPDistributeParallelForSimdDirectiveClass:
296 cast<OMPDistributeParallelForSimdDirective>(*S));
298 case Stmt::OMPDistributeSimdDirectiveClass:
301 case Stmt::OMPTargetParallelForSimdDirectiveClass:
303 cast<OMPTargetParallelForSimdDirective>(*S));
305 case Stmt::OMPTargetSimdDirectiveClass:
308 case Stmt::OMPTeamsDistributeDirectiveClass:
311 case Stmt::OMPTeamsDistributeSimdDirectiveClass:
313 cast<OMPTeamsDistributeSimdDirective>(*S));
315 case Stmt::OMPTeamsDistributeParallelForSimdDirectiveClass:
317 cast<OMPTeamsDistributeParallelForSimdDirective>(*S));
319 case Stmt::OMPTeamsDistributeParallelForDirectiveClass:
321 cast<OMPTeamsDistributeParallelForDirective>(*S));
323 case Stmt::OMPTargetTeamsDirectiveClass:
326 case Stmt::OMPTargetTeamsDistributeDirectiveClass:
328 cast<OMPTargetTeamsDistributeDirective>(*S));
330 case Stmt::OMPTargetTeamsDistributeParallelForDirectiveClass:
332 cast<OMPTargetTeamsDistributeParallelForDirective>(*S));
334 case Stmt::OMPTargetTeamsDistributeParallelForSimdDirectiveClass:
336 cast<OMPTargetTeamsDistributeParallelForSimdDirective>(*S));
338 case Stmt::OMPTargetTeamsDistributeSimdDirectiveClass:
340 cast<OMPTargetTeamsDistributeSimdDirective>(*S));
347 default:
return false;
348 case Stmt::NullStmtClass:
break;
349 case Stmt::CompoundStmtClass:
EmitCompoundStmt(cast<CompoundStmt>(*S));
break;
350 case Stmt::DeclStmtClass:
EmitDeclStmt(cast<DeclStmt>(*S));
break;
351 case Stmt::LabelStmtClass:
EmitLabelStmt(cast<LabelStmt>(*S));
break;
352 case Stmt::AttributedStmtClass:
354 case Stmt::GotoStmtClass:
EmitGotoStmt(cast<GotoStmt>(*S));
break;
355 case Stmt::BreakStmtClass:
EmitBreakStmt(cast<BreakStmt>(*S));
break;
356 case Stmt::ContinueStmtClass:
EmitContinueStmt(cast<ContinueStmt>(*S));
break;
357 case Stmt::DefaultStmtClass:
EmitDefaultStmt(cast<DefaultStmt>(*S));
break;
358 case Stmt::CaseStmtClass:
EmitCaseStmt(cast<CaseStmt>(*S));
break;
359 case Stmt::SEHLeaveStmtClass:
EmitSEHLeaveStmt(cast<SEHLeaveStmt>(*S));
break;
371 "LLVM IR generation of compound statement ('{}')");
385 assert((!GetLast || (GetLast && ExprResult)) &&
386 "If GetLast is true then the CompoundStmt must have a StmtExprResult");
390 for (
auto *CurStmt : S.
body()) {
391 if (GetLast && ExprResult == CurStmt) {
397 while (!isa<Expr>(ExprResult)) {
398 if (
const auto *LS = dyn_cast<LabelStmt>(ExprResult)) {
400 ExprResult = LS->getSubStmt();
401 }
else if (
const auto *AS = dyn_cast<AttributedStmt>(ExprResult)) {
404 ExprResult = AS->getSubStmt();
406 llvm_unreachable(
"unknown value statement");
433 llvm::BranchInst *BI = dyn_cast<llvm::BranchInst>(BB->getTerminator());
442 if (!BI || !BI->isUnconditional())
446 if (BI->getIterator() != BB->begin())
449 BB->replaceAllUsesWith(BI->getSuccessor(0));
450 BI->eraseFromParent();
451 BB->eraseFromParent();
455 llvm::BasicBlock *CurBB =
Builder.GetInsertBlock();
460 if (IsFinished && BB->use_empty()) {
467 if (CurBB && CurBB->getParent())
468 CurFn->getBasicBlockList().insertAfter(CurBB->getIterator(), BB);
470 CurFn->getBasicBlockList().push_back(BB);
478 llvm::BasicBlock *CurBB =
Builder.GetInsertBlock();
480 if (!CurBB || CurBB->getTerminator()) {
492 bool inserted =
false;
493 for (llvm::User *u : block->users()) {
494 if (llvm::Instruction *insn = dyn_cast<llvm::Instruction>(u)) {
495 CurFn->getBasicBlockList().insertAfter(insn->getParent()->getIterator(),
503 CurFn->getBasicBlockList().push_back(block);
511 if (Dest.
isValid())
return Dest;
559 assert(!Labels.empty());
561 = CGF.EHStack.getInnermostNormalCleanup();
565 i = Labels.begin(), e = Labels.end();
i != e; ++
i) {
566 assert(CGF.LabelMap.count(*
i));
567 JumpDest &dest = CGF.LabelMap.find(*i)->second;
568 assert(dest.getScopeDepth().isValid());
569 assert(innermostScope.encloses(dest.getScopeDepth()));
570 dest.setScopeDepth(innermostScope);
575 ParentScope->Labels.append(Labels.begin(), Labels.end());
609 llvm::BasicBlock *CurBB =
Builder.GetInsertBlock();
616 cast<llvm::PHINode>(IndGotoBB->begin())->addIncoming(V, CurBB);
641 std::swap(Executed, Skipped);
660 llvm::BasicBlock *ElseBlock = ContBlock;
715 BreakContinueStack.push_back(BreakContinue(LoopExit, LoopHeader));
736 bool EmitBoolCondBranch =
true;
737 if (llvm::ConstantInt *C = dyn_cast<llvm::ConstantInt>(BoolCondVal))
739 EmitBoolCondBranch =
false;
743 if (EmitBoolCondBranch) {
744 llvm::BasicBlock *ExitBlock = LoopExit.
getBlock();
748 BoolCondVal, LoopBody, ExitBlock,
751 if (ExitBlock != LoopExit.
getBlock()) {
766 BreakContinueStack.pop_back();
782 if (!EmitBoolCondBranch)
794 BreakContinueStack.push_back(BreakContinue(LoopExit, LoopCond));
820 BreakContinueStack.pop_back();
824 bool EmitBoolCondBranch =
true;
825 if (llvm::ConstantInt *C = dyn_cast<llvm::ConstantInt>(BoolCondVal))
827 EmitBoolCondBranch =
false;
830 if (EmitBoolCondBranch) {
833 BoolCondVal, LoopBody, LoopExit.
getBlock(),
834 createProfileWeightsForLoop(S.
getCond(), BackedgeCount));
844 if (!EmitBoolCondBranch)
862 llvm::BasicBlock *CondBlock = Continue.
getBlock();
878 BreakContinueStack.push_back(BreakContinue(LoopExit, Continue));
890 llvm::BasicBlock *ExitBlock = LoopExit.
getBlock();
893 if (ForScope.requiresCleanups())
903 BoolCondVal, ForBody, ExitBlock,
906 if (ExitBlock != LoopExit.
getBlock()) {
931 BreakContinueStack.pop_back();
933 ConditionScope.ForceCleanup();
938 ForScope.ForceCleanup();
973 llvm::BasicBlock *ExitBlock = LoopExit.
getBlock();
974 if (ForScope.requiresCleanups())
984 BoolCondVal, ForBody, ExitBlock,
987 if (ExitBlock != LoopExit.
getBlock()) {
999 BreakContinueStack.push_back(BreakContinue(LoopExit, Continue));
1013 BreakContinueStack.pop_back();
1017 ForScope.ForceCleanup();
1025 void CodeGenFunction::EmitReturnOfRValue(
RValue RV,
QualType Ty) {
1043 if (requiresReturnValueCheck()) {
1046 new llvm::GlobalVariable(
CGM.
getModule(), SLoc->getType(),
false,
1047 llvm::GlobalVariable::PrivateLinkage, SLoc);
1048 SLocPtr->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
1050 assert(ReturnLocation.
isValid() &&
"No valid return location");
1058 Builder.ClearInsertionPoint();
1069 if (
const FullExpr *fe = dyn_cast_or_null<FullExpr>(RV)) {
1071 RV = fe->getSubExpr();
1120 ++NumSimpleReturnExprs;
1132 for (
const auto *I : S.
decls())
1137 assert(!BreakContinueStack.empty() &&
"break stmt not in a loop or switch!");
1149 assert(!BreakContinueStack.empty() &&
"continue stmt not in a loop!");
1164 assert(S.
getRHS() &&
"Expected RHS value in CaseStmt");
1177 if (LHS.isSigned() ? RHS.slt(LHS) : RHS.ult(LHS))
1180 llvm::APInt Range = RHS - LHS;
1182 if (Range.ult(llvm::APInt(Range.getBitWidth(), 64))) {
1185 unsigned NCases = Range.getZExtValue() + 1;
1190 uint64_t Weight = Total / NCases, Rem = Total % NCases;
1191 for (
unsigned I = 0; I != NCases; ++I) {
1193 SwitchWeights->push_back(Weight + (Rem ? 1 : 0));
1196 SwitchInsn->addCase(
Builder.getInt(LHS), CaseDest);
1204 llvm::BasicBlock *RestoreBB =
Builder.GetInsertBlock();
1209 llvm::BasicBlock *FalseDest = CaseRangeBlock;
1212 CurFn->getBasicBlockList().push_back(CaseRangeBlock);
1213 Builder.SetInsertPoint(CaseRangeBlock);
1217 Builder.CreateSub(SwitchInsn->getCondition(),
Builder.getInt(LHS));
1221 llvm::MDNode *Weights =
nullptr;
1222 if (SwitchWeights) {
1224 uint64_t DefaultCount = (*SwitchWeights)[0];
1225 Weights = createProfileWeights(ThisCount, DefaultCount);
1230 (*SwitchWeights)[0] += ThisCount;
1232 Builder.CreateCondBr(Cond, CaseDest, FalseDest, Weights);
1236 Builder.SetInsertPoint(RestoreBB);
1238 Builder.ClearInsertionPoint();
1258 llvm::ConstantInt *CaseVal =
1267 JumpDest Block = BreakContinueStack.back().BreakBlock;
1273 SwitchInsn->addCase(CaseVal, Block.
getBlock());
1277 if (
Builder.GetInsertBlock()) {
1279 Builder.ClearInsertionPoint();
1289 SwitchInsn->addCase(CaseVal, CaseDest);
1304 while (NextCase && NextCase->
getRHS() ==
nullptr) {
1306 llvm::ConstantInt *CaseVal =
1316 SwitchInsn->addCase(CaseVal, CaseDest);
1333 llvm::BasicBlock *DefaultBlock = SwitchInsn->getDefaultDest();
1334 assert(DefaultBlock->empty() &&
1335 "EmitDefaultStmt: Default block already defined?");
1376 if (
const SwitchCase *SC = dyn_cast<SwitchCase>(S)) {
1390 if (!Case && isa<BreakStmt>(S))
1395 if (
const CompoundStmt *CS = dyn_cast<CompoundStmt>(S)) {
1399 bool StartedInLiveCode = FoundCase;
1400 unsigned StartSize = ResultStmts.size();
1407 bool HadSkippedDecl =
false;
1411 for (; Case && I != E; ++I) {
1427 for (++I; I != E; ++I)
1437 assert(FoundCase &&
"Didn't find case but returned fallthrough?");
1452 assert(!HadSkippedDecl &&
"fallthrough after skipping decl");
1457 bool AnyDecls =
false;
1458 for (; I != E; ++I) {
1471 for (++I; I != E; ++I)
1488 ResultStmts.resize(StartSize);
1489 ResultStmts.push_back(S);
1513 ResultStmts.push_back(S);
1522 const llvm::APSInt &ConstantCondValue,
1534 if (
const DefaultStmt *DS = dyn_cast<DefaultStmt>(Case)) {
1540 const CaseStmt *CS = cast<CaseStmt>(Case);
1542 if (CS->
getRHS())
return false;
1567 bool FoundCase =
false;
1576 llvm::SwitchInst *SavedSwitchInsn = SwitchInsn;
1578 llvm::BasicBlock *SavedCRBlock = CaseRangeBlock;
1582 llvm::APSInt ConstantCondValue;
1603 SwitchInsn =
nullptr;
1607 for (
unsigned i = 0, e = CaseStmts.size();
i != e; ++
i)
1613 SwitchInsn = SavedSwitchInsn;
1635 SwitchInsn =
Builder.CreateSwitch(CondV, DefaultBlock);
1638 uint64_t DefaultCount = 0;
1639 unsigned NumCases = 0;
1643 if (isa<DefaultStmt>(Case))
1648 SwitchWeights->reserve(NumCases);
1651 SwitchWeights->push_back(DefaultCount);
1653 CaseRangeBlock = DefaultBlock;
1656 Builder.ClearInsertionPoint();
1661 if (!BreakContinueStack.empty())
1662 OuterContinue = BreakContinueStack.back().ContinueBlock;
1664 BreakContinueStack.push_back(BreakContinue(SwitchExit, OuterContinue));
1669 BreakContinueStack.pop_back();
1673 SwitchInsn->setDefaultDest(CaseRangeBlock);
1676 if (!DefaultBlock->getParent()) {
1684 DefaultBlock->replaceAllUsesWith(SwitchExit.
getBlock());
1685 delete DefaultBlock;
1700 auto *FD = dyn_cast_or_null<FunctionDecl>(Call->getCalleeDecl());
1701 if (FD && FD->getBuiltinID() == Builtin::BI__builtin_unpredictable) {
1703 SwitchInsn->setMetadata(llvm::LLVMContext::MD_unpredictable,
1704 MDHelper.createUnpredictable());
1708 if (SwitchWeights) {
1709 assert(SwitchWeights->size() == 1 + SwitchInsn->getNumCases() &&
1710 "switch weights do not match switch cases");
1712 if (SwitchWeights->size() > 1)
1713 SwitchInsn->setMetadata(llvm::LLVMContext::MD_prof,
1714 createProfileWeights(*SwitchWeights));
1715 delete SwitchWeights;
1717 SwitchInsn = SavedSwitchInsn;
1718 SwitchWeights = SavedSwitchWeights;
1719 CaseRangeBlock = SavedCRBlock;
1727 while (*Constraint) {
1728 switch (*Constraint) {
1740 while (Constraint[1] && Constraint[1] !=
',')
1745 Result += *Constraint;
1746 while (Constraint[1] && Constraint[1] == *Constraint)
1757 "Must pass output names to constraints with a symbolic name");
1760 assert(result &&
"Could not resolve symbolic name"); (void)result;
1761 Result += llvm::utostr(Index);
1788 AsmLabelAttr *
Attr = Variable->
getAttr<AsmLabelAttr>();
1791 StringRef Register = Attr->getLabel();
1797 !Info.allowsRegister()) {
1803 return (EarlyClobber ?
"&{" :
"{") + Register.str() +
"}";
1809 std::string &ConstraintStr,
1818 if (Size <= 64 && llvm::isPowerOf2_64(Size)) {
1820 Ty = llvm::PointerType::getUnqual(Ty);
1826 ConstraintStr +=
'*';
1831 ConstraintStr +=
'*';
1839 const Expr *InputExpr,
1840 std::string &ConstraintStr) {
1848 llvm::APSInt IntResult;
1862 if (InputExpr->
getStmtClass() == Expr::CXXThisExprClass)
1866 return EmitAsmInputLValue(Info, Dest, InputExpr->
getType(), ConstraintStr,
1878 Locs.push_back(llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
1881 if (!StrVal.empty()) {
1884 unsigned StartToken = 0;
1885 unsigned ByteOffset = 0;
1889 for (
unsigned i = 0, e = StrVal.size() - 1;
i != e; ++
i) {
1890 if (StrVal[
i] !=
'\n')
continue;
1892 i + 1, SM, LangOpts, CGF.
getTarget(), &StartToken, &ByteOffset);
1893 Locs.push_back(llvm::ConstantAsMetadata::get(
1902 bool ReadOnly,
bool ReadNone,
const AsmStmt &S,
1903 const std::vector<llvm::Type *> &ResultRegTypes,
1905 std::vector<llvm::Value *> &RegResults) {
1906 Result.addAttribute(llvm::AttributeList::FunctionIndex,
1907 llvm::Attribute::NoUnwind);
1909 if (!HasSideEffect) {
1911 Result.addAttribute(llvm::AttributeList::FunctionIndex,
1912 llvm::Attribute::ReadNone);
1914 Result.addAttribute(llvm::AttributeList::FunctionIndex,
1915 llvm::Attribute::ReadOnly);
1920 if (
const auto *gccAsmStmt = dyn_cast<GCCAsmStmt>(&S))
1921 Result.setMetadata(
"srcloc",
1925 llvm::Constant *Loc = llvm::ConstantInt::get(CGF.
Int32Ty,
1927 Result.setMetadata(
"srcloc",
1929 llvm::ConstantAsMetadata::get(Loc)));
1937 Result.addAttribute(llvm::AttributeList::FunctionIndex,
1938 llvm::Attribute::Convergent);
1940 if (ResultRegTypes.size() == 1) {
1941 RegResults.push_back(&Result);
1943 for (
unsigned i = 0, e = ResultRegTypes.size();
i != e; ++
i) {
1945 RegResults.push_back(Tmp);
1960 if (
const GCCAsmStmt *GAS = dyn_cast<GCCAsmStmt>(&S))
1961 Name = GAS->getOutputName(
i);
1964 assert(IsValid &&
"Failed to parse output constraint");
1965 OutputConstraintInfos.push_back(Info);
1970 if (
const GCCAsmStmt *GAS = dyn_cast<GCCAsmStmt>(&S))
1971 Name = GAS->getInputName(
i);
1975 assert(IsValid &&
"Failed to parse input constraint"); (void)IsValid;
1976 InputConstraintInfos.push_back(Info);
1979 std::string Constraints;
1981 std::vector<LValue> ResultRegDests;
1982 std::vector<QualType> ResultRegQualTys;
1983 std::vector<llvm::Type *> ResultRegTypes;
1984 std::vector<llvm::Type *> ResultTruncRegTypes;
1985 std::vector<llvm::Type *> ArgTypes;
1986 std::vector<llvm::Value*> Args;
1989 std::string InOutConstraints;
1990 std::vector<llvm::Value*> InOutArgs;
1991 std::vector<llvm::Type*> InOutArgTypes;
1994 std::vector<std::string> OutputConstraints;
2002 bool ReadOnly =
true, ReadNone =
true;
2018 OutputConstraints.push_back(OutputConstraint);
2020 if (!Constraints.empty())
2026 Constraints +=
"=" + OutputConstraint;
2027 ResultRegQualTys.push_back(OutExpr->getType());
2028 ResultRegDests.push_back(Dest);
2030 ResultTruncRegTypes.push_back(ResultRegTypes.back());
2037 for (InputNo = 0; InputNo != S.
getNumInputs(); ++InputNo) {
2042 assert(InputNo != S.
getNumInputs() &&
"Didn't find matching input!");
2045 QualType OutputType = OutExpr->getType();
2055 ResultRegTypes.back()))
2056 ResultRegTypes.back() = AdjTy;
2059 diag::err_asm_invalid_type_in_input)
2060 << OutExpr->getType() << OutputConstraint;
2064 if (
auto *VT = dyn_cast<llvm::VectorType>(ResultRegTypes.back()))
2065 LargestVectorWidth =
std::max(LargestVectorWidth,
2066 VT->getPrimitiveSizeInBits());
2070 Constraints +=
"=*";
2071 Constraints += OutputConstraint;
2072 ReadOnly = ReadNone =
false;
2076 InOutConstraints +=
',';
2089 if (
auto *VT = dyn_cast<llvm::VectorType>(Arg->getType()))
2090 LargestVectorWidth =
std::max(LargestVectorWidth,
2091 VT->getPrimitiveSizeInBits());
2093 InOutConstraints += llvm::utostr(
i);
2095 InOutConstraints += OutputConstraint;
2097 InOutArgTypes.push_back(Arg->getType());
2098 InOutArgs.push_back(Arg);
2104 if (isa<MSAsmStmt>(&S)) {
2110 *
this, ReturnSlot, Constraints, ResultRegTypes, ResultTruncRegTypes,
2124 if (!Constraints.empty())
2130 &OutputConstraintInfos);
2136 std::string ReplaceConstraint (InputConstraint);
2137 llvm::Value *Arg = EmitAsmInput(Info, InputExpr, Constraints);
2146 QualType OutputType = S.getOutputExpr(Output)->getType();
2152 if (isa<llvm::PointerType>(Arg->getType()))
2155 if (isa<llvm::IntegerType>(OutputTy))
2156 Arg =
Builder.CreateZExt(Arg, OutputTy);
2157 else if (isa<llvm::PointerType>(OutputTy))
2160 assert(OutputTy->isFloatingPointTy() &&
"Unexpected output type");
2161 Arg =
Builder.CreateFPExt(Arg, OutputTy);
2165 ReplaceConstraint = OutputConstraints[Output];
2173 << InputExpr->
getType() << InputConstraint;
2176 if (
auto *VT = dyn_cast<llvm::VectorType>(Arg->getType()))
2177 LargestVectorWidth =
std::max(LargestVectorWidth,
2178 VT->getPrimitiveSizeInBits());
2180 ArgTypes.push_back(Arg->getType());
2181 Args.push_back(Arg);
2182 Constraints += InputConstraint;
2186 for (
unsigned i = 0, e = InOutArgs.size();
i != e;
i++) {
2187 ArgTypes.push_back(InOutArgTypes[
i]);
2188 Args.push_back(InOutArgs[i]);
2190 Constraints += InOutConstraints;
2194 llvm::BasicBlock *Fallthrough =
nullptr;
2195 bool IsGCCAsmGoto =
false;
2196 if (
const auto *GS = dyn_cast<GCCAsmStmt>(&S)) {
2197 IsGCCAsmGoto = GS->isAsmGoto();
2199 for (
auto *E : GS->labels()) {
2201 Transfer.push_back(Dest.
getBlock());
2202 llvm::BlockAddress *BA =
2205 ArgTypes.push_back(BA->getType());
2206 if (!Constraints.empty())
2210 StringRef Name =
"asm.fallthrough";
2219 if (Clobber ==
"memory")
2220 ReadOnly = ReadNone =
false;
2221 else if (Clobber !=
"cc")
2224 if (!Constraints.empty())
2227 Constraints +=
"~{";
2228 Constraints += Clobber;
2234 if (!MachineClobbers.empty()) {
2235 if (!Constraints.empty())
2237 Constraints += MachineClobbers;
2241 if (ResultRegTypes.empty())
2243 else if (ResultRegTypes.size() == 1)
2244 ResultType = ResultRegTypes[0];
2246 ResultType = llvm::StructType::get(
getLLVMContext(), ResultRegTypes);
2248 llvm::FunctionType *FTy =
2249 llvm::FunctionType::get(ResultType, ArgTypes,
false);
2252 llvm::InlineAsm::AsmDialect AsmDialect = isa<MSAsmStmt>(&S) ?
2253 llvm::InlineAsm::AD_Intel : llvm::InlineAsm::AD_ATT;
2254 llvm::InlineAsm *IA =
2255 llvm::InlineAsm::get(FTy, AsmString, Constraints, HasSideEffect,
2257 std::vector<llvm::Value*> RegResults;
2259 llvm::CallBrInst *Result =
2260 Builder.CreateCallBr(IA, Fallthrough, Transfer, Args);
2262 ReadNone, S, ResultRegTypes, *
this, RegResults);
2265 llvm::CallInst *Result =
2268 ReadNone, S, ResultRegTypes, *
this, RegResults);
2271 assert(RegResults.size() == ResultRegTypes.size());
2272 assert(RegResults.size() == ResultTruncRegTypes.size());
2273 assert(RegResults.size() == ResultRegDests.size());
2274 for (
unsigned i = 0, e = RegResults.size();
i != e; ++
i) {
2279 if (ResultRegTypes[
i] != ResultTruncRegTypes[
i]) {
2284 if (TruncTy->isFloatingPointTy())
2285 Tmp =
Builder.CreateFPTrunc(Tmp, TruncTy);
2286 else if (TruncTy->isPointerTy() && Tmp->getType()->isIntegerTy()) {
2288 Tmp =
Builder.CreateTrunc(Tmp,
2290 Tmp =
Builder.CreateIntToPtr(Tmp, TruncTy);
2291 }
else if (Tmp->getType()->isPointerTy() && TruncTy->isIntegerTy()) {
2293 Tmp =
Builder.CreatePtrToInt(Tmp,
2295 Tmp =
Builder.CreateTrunc(Tmp, TruncTy);
2296 }
else if (TruncTy->isIntegerTy()) {
2297 Tmp =
Builder.CreateZExtOrTrunc(Tmp, TruncTy);
2298 }
else if (TruncTy->isVectorTy()) {
2318 I != E; ++I, ++CurField) {
2320 if (CurField->hasCapturedVLAType()) {
2321 auto VAT = CurField->getCapturedVLAType();
2358 "CapturedStmtInfo should be set when generating the captured function");
2362 assert(CD->
hasBody() &&
"missing CapturedDecl body");
2379 F->addFnAttr(llvm::Attribute::NoUnwind);
2390 Ctx.getTagDeclType(RD));
2391 for (
auto *FD : RD->
fields()) {
2392 if (FD->hasCapturedVLAType()) {
2396 auto VAT = FD->getCapturedVLAType();
2397 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.
void EmitOMPTaskwaitDirective(const OMPTaskwaitDirective &S)
unsigned getNumInputs() const
SourceLocation getBeginLoc() 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.
Address CreateMemTemp(QualType T, const Twine &Name="tmp", Address *Alloca=nullptr)
CreateMemTemp - Create a temporary memory object of the given type, with appropriate alignmen and cas...
void enterFullExpression(const FullExpr *E)
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 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.
LValue EmitLValueForFieldInitialization(LValue Base, const FieldDecl *Field)
EmitLValueForFieldInitialization - Like EmitLValueForField, except that if the Field is a reference...
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.
bool empty() const
Determines whether the exception-scopes stack is empty.
void EmitOMPParallelForSimdDirective(const OMPParallelForSimdDirective &S)
Address GetAddrOfLocalVar(const VarDecl *VD)
GetAddrOfLocalVar - Return the address of a local variable.
Represents 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.
void EmitOMPTeamsDistributeDirective(const OMPTeamsDistributeDirective &S)
void SimplifyForwardingBlocks(llvm::BasicBlock *BB)
SimplifyForwardingBlocks - If the given basic block is only a branch to another basic block...
The collection of all-type qualifiers we support.
A jump destination is an abstract label, branching to which may require a jump out through normal cle...
void EmitOMPTargetTeamsDistributeParallelForSimdDirective(const OMPTargetTeamsDistributeParallelForSimdDirective &S)
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.
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.
FullExpr - Represents a "full-expression" node.
field_range fields() const
SourceLocation getBeginLoc() const LLVM_READONLY
Represents a member of a struct/union/class.
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...
Stmt * getStmtExprResult()
bool isReferenceType() const
Stmt *const * const_body_iterator
virtual void setContextValue(llvm::Value *V)
static AggValueSlot forAddr(Address addr, Qualifiers quals, IsDestructed_t isDestructed, NeedsGCBarriers_t needsGC, IsAliased_t isAliased, Overlap_t mayOverlap, IsZeroed_t isZeroed=IsNotZeroed, IsSanitizerChecked_t isChecked=IsNotSanitizerChecked)
forAddr - Make a slot for an aggregate value.
void EmitForStmt(const ForStmt &S, ArrayRef< const Attr *> Attrs=None)
__DEVICE__ int max(int __a, int __b)
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.
bool assumeFunctionsAreConvergent() const
APValue Val
Val - This is the value the expression can be folded to.
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...
static void UpdateAsmCallInst(llvm::CallBase &Result, bool HasSideEffect, bool ReadOnly, bool ReadNone, const AsmStmt &S, const std::vector< llvm::Type *> &ResultRegTypes, CodeGenFunction &CGF, std::vector< llvm::Value *> &RegResults)
Scope - A scope is a transient data structure that is used while parsing the program.
field_iterator field_begin() const
CaseStmt - Represent a case 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...
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.
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.
virtual 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()
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...
AggValueSlot::Overlap_t getOverlapForReturnValue()
Determine whether a return value slot may overlap some other object.
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
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
This represents one expression.
Emit only debug info necessary for generating line number tables (-gline-tables-only).
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)
llvm::BasicBlock * getBlock() 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.
llvm::PointerType * getType() const
Return the type of the pointer value.
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()
SmallVector< llvm::OperandBundleDef, 1 > getBundlesForFunclet(llvm::Value *Callee)
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
SwitchCase * getSwitchCaseList()
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
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)
bool EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx, bool InConstantContext=false) const
EvaluateAsRValue - Return true if this is a constant which we can fold to an rvalue using any crazy t...
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.
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
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 ...
void EmitObjCForCollectionStmt(const ObjCForCollectionStmt &S)
DeclStmt - Adaptor class for mixing declarations with statements and expressions. ...
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)
SourceLocation getBeginLoc() const LLVM_READONLY
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)
VarDecl * getConditionVariable()
Retrieve the variable declared in this "switch" statement, if any.
void EmitOMPTaskLoopDirective(const OMPTaskLoopDirective &S)
virtual FieldDecl * getThisFieldDecl() const
const CGFunctionInfo * CurFnInfo
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
llvm::CallBase * EmitCallOrInvoke(llvm::FunctionCallee 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...
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.
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)
VarDecl * getConditionVariable()
Retrieve the variable declared in this "while" statement, if any.
EvalResult is a struct with detailed info about an evaluated expression.
void EmitOMPTargetParallelDirective(const OMPTargetParallelDirective &S)
bool allowsMemory() const
void EmitOMPParallelForDirective(const OMPParallelForDirective &S)
ArrayRef< const Attr * > getAttrs() const
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 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)
SourceLocation getBeginLoc() const LLVM_READONLY
llvm::Module & getModule() const
bool toIntegralConstant(APSInt &Result, QualType SrcTy, const ASTContext &Ctx) const
Try to convert this value to an integral constant.
void EmitObjCAtThrowStmt(const ObjCAtThrowStmt &S)
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)
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
void SetInternalFunctionAttributes(GlobalDecl GD, llvm::Function *F, const CGFunctionInfo &FI)
Set the attributes on the LLVM function for the given decl and function info.
const Expr * getInputExpr(unsigned i) const
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
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...
bool EvaluateAsInt(EvalResult &Result, const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects, bool InConstantContext=false) const
EvaluateAsInt - Return true if this is a constant which we can fold and convert to an integer...
VarDecl * getConditionVariable()
Retrieve the variable declared in this "if" statement, if any.
ActionResult< Expr * > ExprResult
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
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...
void EmitAggregateCopy(LValue Dest, LValue Src, QualType EltTy, AggValueSlot::Overlap_t MayOverlap, bool isVolatile=false)
EmitAggregateCopy - Emit an aggregate copy.
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()
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
Expr * IgnoreParenNoopCasts(const ASTContext &Ctx) LLVM_READONLY
Skip past any parenthese and casts which do not change the value (including ptr->int casts of the sam...
DeclStmt * getBeginStmt()
void EmitBreakStmt(const BreakStmt &S)
void EmitObjCAutoreleasePoolStmt(const ObjCAutoreleasePoolStmt &S)
static bool containsBreak(const Stmt *S)
containsBreak - Return true if the statement contains a break out of it.
SourceLocation getBegin() const
capture_init_iterator capture_init_end()
Retrieve the iterator pointing one past the last initialization argument.
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.