head 1.1; branch 1.1.1; access; symbols netbsd-11-0-RC4:1.1.1.14 netbsd-11-0-RC3:1.1.1.14 netbsd-11-0-RC2:1.1.1.14 netbsd-11-0-RC1:1.1.1.14 perseant-exfatfs-base-20250801:1.1.1.14 netbsd-11:1.1.1.14.0.10 netbsd-11-base:1.1.1.14 netbsd-10-1-RELEASE:1.1.1.14 perseant-exfatfs-base-20240630:1.1.1.14 perseant-exfatfs:1.1.1.14.0.8 perseant-exfatfs-base:1.1.1.14 netbsd-8-3-RELEASE:1.1.1.11 netbsd-9-4-RELEASE:1.1.1.13 netbsd-10-0-RELEASE:1.1.1.14 netbsd-10-0-RC6:1.1.1.14 netbsd-10-0-RC5:1.1.1.14 netbsd-10-0-RC4:1.1.1.14 netbsd-10-0-RC3:1.1.1.14 netbsd-10-0-RC2:1.1.1.14 netbsd-10-0-RC1:1.1.1.14 netbsd-10:1.1.1.14.0.6 netbsd-10-base:1.1.1.14 netbsd-9-3-RELEASE:1.1.1.13 cjep_sun2x:1.1.1.14.0.4 cjep_sun2x-base:1.1.1.14 cjep_staticlib_x-base1:1.1.1.14 netbsd-9-2-RELEASE:1.1.1.13 cjep_staticlib_x:1.1.1.14.0.2 cjep_staticlib_x-base:1.1.1.14 netbsd-9-1-RELEASE:1.1.1.13 phil-wifi-20200421:1.1.1.14 phil-wifi-20200411:1.1.1.14 phil-wifi-20200406:1.1.1.14 netbsd-8-2-RELEASE:1.1.1.11 netbsd-9-0-RELEASE:1.1.1.13 netbsd-9-0-RC2:1.1.1.13 netbsd-9-0-RC1:1.1.1.13 netbsd-9:1.1.1.13.0.2 netbsd-9-base:1.1.1.13 phil-wifi-20190609:1.1.1.13 netbsd-8-1-RELEASE:1.1.1.11 netbsd-8-1-RC1:1.1.1.11 pgoyette-compat-merge-20190127:1.1.1.12.2.1 pgoyette-compat-20190127:1.1.1.13 pgoyette-compat-20190118:1.1.1.13 pgoyette-compat-1226:1.1.1.13 pgoyette-compat-1126:1.1.1.13 pgoyette-compat-1020:1.1.1.13 pgoyette-compat-0930:1.1.1.13 pgoyette-compat-0906:1.1.1.13 netbsd-7-2-RELEASE:1.1.1.7.2.1 pgoyette-compat-0728:1.1.1.13 clang-337282:1.1.1.13 netbsd-8-0-RELEASE:1.1.1.11 phil-wifi:1.1.1.12.0.4 phil-wifi-base:1.1.1.12 pgoyette-compat-0625:1.1.1.12 netbsd-8-0-RC2:1.1.1.11 pgoyette-compat-0521:1.1.1.12 pgoyette-compat-0502:1.1.1.12 pgoyette-compat-0422:1.1.1.12 netbsd-8-0-RC1:1.1.1.11 pgoyette-compat-0415:1.1.1.12 pgoyette-compat-0407:1.1.1.12 pgoyette-compat-0330:1.1.1.12 pgoyette-compat-0322:1.1.1.12 pgoyette-compat-0315:1.1.1.12 netbsd-7-1-2-RELEASE:1.1.1.7.2.1 pgoyette-compat:1.1.1.12.0.2 pgoyette-compat-base:1.1.1.12 netbsd-7-1-1-RELEASE:1.1.1.7.2.1 clang-319952:1.1.1.12 matt-nb8-mediatek:1.1.1.11.0.8 matt-nb8-mediatek-base:1.1.1.11 clang-309604:1.1.1.12 perseant-stdc-iso10646:1.1.1.11.0.6 perseant-stdc-iso10646-base:1.1.1.11 netbsd-8:1.1.1.11.0.4 netbsd-8-base:1.1.1.11 prg-localcount2-base3:1.1.1.11 prg-localcount2-base2:1.1.1.11 prg-localcount2-base1:1.1.1.11 prg-localcount2:1.1.1.11.0.2 prg-localcount2-base:1.1.1.11 pgoyette-localcount-20170426:1.1.1.11 bouyer-socketcan-base1:1.1.1.11 pgoyette-localcount-20170320:1.1.1.11 netbsd-7-1:1.1.1.7.2.1.0.6 netbsd-7-1-RELEASE:1.1.1.7.2.1 netbsd-7-1-RC2:1.1.1.7.2.1 clang-294123:1.1.1.11 netbsd-7-nhusb-base-20170116:1.1.1.7.2.1 bouyer-socketcan:1.1.1.10.0.2 bouyer-socketcan-base:1.1.1.10 clang-291444:1.1.1.10 pgoyette-localcount-20170107:1.1.1.9 netbsd-7-1-RC1:1.1.1.7.2.1 pgoyette-localcount-20161104:1.1.1.9 netbsd-7-0-2-RELEASE:1.1.1.7.2.1 localcount-20160914:1.1.1.9 netbsd-7-nhusb:1.1.1.7.2.1.0.4 netbsd-7-nhusb-base:1.1.1.7.2.1 clang-280599:1.1.1.9 pgoyette-localcount-20160806:1.1.1.9 pgoyette-localcount-20160726:1.1.1.9 pgoyette-localcount:1.1.1.9.0.2 pgoyette-localcount-base:1.1.1.9 netbsd-7-0-1-RELEASE:1.1.1.7.2.1 clang-261930:1.1.1.9 netbsd-7-0:1.1.1.7.2.1.0.2 netbsd-7-0-RELEASE:1.1.1.7.2.1 netbsd-7-0-RC3:1.1.1.7.2.1 netbsd-7-0-RC2:1.1.1.7.2.1 netbsd-7-0-RC1:1.1.1.7.2.1 clang-237755:1.1.1.8 clang-232565:1.1.1.8 clang-227398:1.1.1.8 tls-maxphys-base:1.1.1.7 tls-maxphys:1.1.1.7.0.4 netbsd-7:1.1.1.7.0.2 netbsd-7-base:1.1.1.7 clang-215315:1.1.1.7 clang-209886:1.1.1.6 yamt-pagecache:1.1.1.5.0.4 yamt-pagecache-base9:1.1.1.5 tls-earlyentropy:1.1.1.5.0.2 tls-earlyentropy-base:1.1.1.6 riastradh-xf86-video-intel-2-7-1-pre-2-21-15:1.1.1.5 riastradh-drm2-base3:1.1.1.5 clang-202566:1.1.1.5 clang-201163:1.1.1.4 clang-199312:1.1.1.3 clang-198450:1.1.1.2 clang-196603:1.1.1.1 clang-195771:1.1.1.1 LLVM:1.1.1; locks; strict; comment @// @; 1.1 date 2013.11.28.14.14.53; author joerg; state Exp; branches 1.1.1.1; next ; commitid ow8OybrawrB1f3fx; 1.1.1.1 date 2013.11.28.14.14.53; author joerg; state Exp; branches; next 1.1.1.2; commitid ow8OybrawrB1f3fx; 1.1.1.2 date 2014.01.05.15.38.00; author joerg; state Exp; branches; next 1.1.1.3; commitid wh3aCSIWykURqWjx; 1.1.1.3 date 2014.01.15.21.26.26; author joerg; state Exp; branches; next 1.1.1.4; commitid NQXlzzA0SPkc5glx; 1.1.1.4 date 2014.02.14.20.07.08; author joerg; state Exp; branches; next 1.1.1.5; commitid annVkZ1sc17rF6px; 1.1.1.5 date 2014.03.04.19.53.57; author joerg; state Exp; branches 1.1.1.5.2.1 1.1.1.5.4.1; next 1.1.1.6; commitid 29z1hJonZISIXprx; 1.1.1.6 date 2014.05.30.18.14.41; author joerg; state Exp; branches; next 1.1.1.7; commitid 8q0kdlBlCn09GACx; 1.1.1.7 date 2014.08.10.17.08.36; author joerg; state Exp; branches 1.1.1.7.2.1 1.1.1.7.4.1; next 1.1.1.8; commitid N85tXAN6Ex9VZPLx; 1.1.1.8 date 2015.01.29.19.57.31; author joerg; state Exp; branches; next 1.1.1.9; commitid mlISSizlPKvepX7y; 1.1.1.9 date 2016.02.27.22.12.08; author joerg; state Exp; branches 1.1.1.9.2.1; next 1.1.1.10; commitid tIimz3oDlh1NpBWy; 1.1.1.10 date 2017.01.11.10.33.37; author joerg; state Exp; branches 1.1.1.10.2.1; next 1.1.1.11; commitid CNnUNfII1jgNmxBz; 1.1.1.11 date 2017.02.09.17.38.04; author joerg; state Exp; branches; next 1.1.1.12; commitid UxB8JMFWM7xyMiFz; 1.1.1.12 date 2017.08.01.19.35.32; author joerg; state Exp; branches 1.1.1.12.2.1 1.1.1.12.4.1; next 1.1.1.13; commitid pMuDy65V0VicSx1A; 1.1.1.13 date 2018.07.17.18.31.02; author joerg; state Exp; branches; next 1.1.1.14; commitid wDzL46ALjrCZgwKA; 1.1.1.14 date 2019.11.13.22.19.21; author joerg; state dead; branches; next ; commitid QD8YATxuNG34YJKB; 1.1.1.5.2.1 date 2014.08.10.07.08.07; author tls; state Exp; branches; next ; commitid t01A1TLTYxkpGMLx; 1.1.1.5.4.1 date 2014.03.04.19.53.57; author yamt; state dead; branches; next 1.1.1.5.4.2; commitid WSrDtL5nYAUyiyBx; 1.1.1.5.4.2 date 2014.05.22.16.18.27; author yamt; state Exp; branches; next ; commitid WSrDtL5nYAUyiyBx; 1.1.1.7.2.1 date 2015.06.04.20.04.28; author snj; state Exp; branches; next ; commitid yRnjq9fueSo6n9oy; 1.1.1.7.4.1 date 2014.08.10.17.08.36; author tls; state dead; branches; next 1.1.1.7.4.2; commitid jTnpym9Qu0o4R1Nx; 1.1.1.7.4.2 date 2014.08.19.23.47.27; author tls; state Exp; branches; next ; commitid jTnpym9Qu0o4R1Nx; 1.1.1.9.2.1 date 2017.03.20.06.52.37; author pgoyette; state Exp; branches; next ; commitid jjw7cAwgyKq7RfKz; 1.1.1.10.2.1 date 2017.04.21.16.51.38; author bouyer; state Exp; branches; next ; commitid dUG7nkTKALCadqOz; 1.1.1.12.2.1 date 2018.07.28.04.33.18; author pgoyette; state Exp; branches; next ; commitid 1UP1xAIUxv1ZgRLA; 1.1.1.12.4.1 date 2019.06.10.21.45.21; author christos; state Exp; branches; next 1.1.1.12.4.2; commitid jtc8rnCzWiEEHGqB; 1.1.1.12.4.2 date 2020.04.13.07.46.32; author martin; state dead; branches; next ; commitid X01YhRUPVUDaec4C; desc @@ 1.1 log @Initial revision @ text @//===--- CGStmt.cpp - Emit LLVM Code from Statements ----------------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This contains code to emit Stmt nodes as LLVM code. // //===----------------------------------------------------------------------===// #include "CodeGenFunction.h" #include "CGDebugInfo.h" #include "CodeGenModule.h" #include "TargetInfo.h" #include "clang/AST/StmtVisitor.h" #include "clang/Sema/SemaDiagnostic.h" #include "clang/Basic/PrettyStackTrace.h" #include "clang/Basic/TargetInfo.h" #include "llvm/ADT/StringExtras.h" #include "llvm/IR/DataLayout.h" #include "llvm/IR/InlineAsm.h" #include "llvm/IR/Intrinsics.h" #include "llvm/Support/CallSite.h" using namespace clang; using namespace CodeGen; //===----------------------------------------------------------------------===// // Statement Emission //===----------------------------------------------------------------------===// void CodeGenFunction::EmitStopPoint(const Stmt *S) { if (CGDebugInfo *DI = getDebugInfo()) { SourceLocation Loc; Loc = S->getLocStart(); DI->EmitLocation(Builder, Loc); LastStopPoint = Loc; } } void CodeGenFunction::EmitStmt(const Stmt *S) { assert(S && "Null statement?"); // These statements have their own debug info handling. if (EmitSimpleStmt(S)) return; // Check if we are generating unreachable code. if (!HaveInsertPoint()) { // If so, and the statement doesn't contain a label, then we do not need to // generate actual code. This is safe because (1) the current point is // unreachable, so we don't need to execute the code, and (2) we've already // handled the statements which update internal data structures (like the // local variable map) which could be used by subsequent statements. if (!ContainsLabel(S)) { // Verify that any decl statements were handled as simple, they may be in // scope of subsequent reachable statements. assert(!isa(*S) && "Unexpected DeclStmt!"); return; } // Otherwise, make a new block to hold the code. EnsureInsertPoint(); } // Generate a stoppoint if we are emitting debug info. EmitStopPoint(S); switch (S->getStmtClass()) { case Stmt::NoStmtClass: case Stmt::CXXCatchStmtClass: case Stmt::SEHExceptStmtClass: case Stmt::SEHFinallyStmtClass: case Stmt::MSDependentExistsStmtClass: case Stmt::OMPParallelDirectiveClass: llvm_unreachable("invalid statement class to emit generically"); case Stmt::NullStmtClass: case Stmt::CompoundStmtClass: case Stmt::DeclStmtClass: case Stmt::LabelStmtClass: case Stmt::AttributedStmtClass: case Stmt::GotoStmtClass: case Stmt::BreakStmtClass: case Stmt::ContinueStmtClass: case Stmt::DefaultStmtClass: case Stmt::CaseStmtClass: llvm_unreachable("should have emitted these statements as simple"); #define STMT(Type, Base) #define ABSTRACT_STMT(Op) #define EXPR(Type, Base) \ case Stmt::Type##Class: #include "clang/AST/StmtNodes.inc" { // Remember the block we came in on. llvm::BasicBlock *incoming = Builder.GetInsertBlock(); assert(incoming && "expression emission must have an insertion point"); EmitIgnoredExpr(cast(S)); llvm::BasicBlock *outgoing = Builder.GetInsertBlock(); assert(outgoing && "expression emission cleared block!"); // The expression emitters assume (reasonably!) that the insertion // point is always set. To maintain that, the call-emission code // for noreturn functions has to enter a new block with no // predecessors. We want to kill that block and mark the current // insertion point unreachable in the common case of a call like // "exit();". Since expression emission doesn't otherwise create // blocks with no predecessors, we can just test for that. // However, we must be careful not to do this to our incoming // block, because *statement* emission does sometimes create // reachable blocks which will have no predecessors until later in // the function. This occurs with, e.g., labels that are not // reachable by fallthrough. if (incoming != outgoing && outgoing->use_empty()) { outgoing->eraseFromParent(); Builder.ClearInsertionPoint(); } break; } case Stmt::IndirectGotoStmtClass: EmitIndirectGotoStmt(cast(*S)); break; case Stmt::IfStmtClass: EmitIfStmt(cast(*S)); break; case Stmt::WhileStmtClass: EmitWhileStmt(cast(*S)); break; case Stmt::DoStmtClass: EmitDoStmt(cast(*S)); break; case Stmt::ForStmtClass: EmitForStmt(cast(*S)); break; case Stmt::ReturnStmtClass: EmitReturnStmt(cast(*S)); break; case Stmt::SwitchStmtClass: EmitSwitchStmt(cast(*S)); break; case Stmt::GCCAsmStmtClass: // Intentional fall-through. case Stmt::MSAsmStmtClass: EmitAsmStmt(cast(*S)); break; case Stmt::CapturedStmtClass: { const CapturedStmt *CS = cast(S); EmitCapturedStmt(*CS, CS->getCapturedRegionKind()); } break; case Stmt::ObjCAtTryStmtClass: EmitObjCAtTryStmt(cast(*S)); break; case Stmt::ObjCAtCatchStmtClass: llvm_unreachable( "@@catch statements should be handled by EmitObjCAtTryStmt"); case Stmt::ObjCAtFinallyStmtClass: llvm_unreachable( "@@finally statements should be handled by EmitObjCAtTryStmt"); case Stmt::ObjCAtThrowStmtClass: EmitObjCAtThrowStmt(cast(*S)); break; case Stmt::ObjCAtSynchronizedStmtClass: EmitObjCAtSynchronizedStmt(cast(*S)); break; case Stmt::ObjCForCollectionStmtClass: EmitObjCForCollectionStmt(cast(*S)); break; case Stmt::ObjCAutoreleasePoolStmtClass: EmitObjCAutoreleasePoolStmt(cast(*S)); break; case Stmt::CXXTryStmtClass: EmitCXXTryStmt(cast(*S)); break; case Stmt::CXXForRangeStmtClass: EmitCXXForRangeStmt(cast(*S)); break; case Stmt::SEHTryStmtClass: EmitSEHTryStmt(cast(*S)); break; } } bool CodeGenFunction::EmitSimpleStmt(const Stmt *S) { switch (S->getStmtClass()) { default: return false; case Stmt::NullStmtClass: break; case Stmt::CompoundStmtClass: EmitCompoundStmt(cast(*S)); break; case Stmt::DeclStmtClass: EmitDeclStmt(cast(*S)); break; case Stmt::LabelStmtClass: EmitLabelStmt(cast(*S)); break; case Stmt::AttributedStmtClass: EmitAttributedStmt(cast(*S)); break; case Stmt::GotoStmtClass: EmitGotoStmt(cast(*S)); break; case Stmt::BreakStmtClass: EmitBreakStmt(cast(*S)); break; case Stmt::ContinueStmtClass: EmitContinueStmt(cast(*S)); break; case Stmt::DefaultStmtClass: EmitDefaultStmt(cast(*S)); break; case Stmt::CaseStmtClass: EmitCaseStmt(cast(*S)); break; } return true; } /// EmitCompoundStmt - Emit a compound statement {..} node. If GetLast is true, /// this captures the expression result of the last sub-statement and returns it /// (for use by the statement expression extension). llvm::Value* CodeGenFunction::EmitCompoundStmt(const CompoundStmt &S, bool GetLast, AggValueSlot AggSlot) { PrettyStackTraceLoc CrashInfo(getContext().getSourceManager(),S.getLBracLoc(), "LLVM IR generation of compound statement ('{}')"); // Keep track of the current cleanup stack depth, including debug scopes. LexicalScope Scope(*this, S.getSourceRange()); return EmitCompoundStmtWithoutScope(S, GetLast, AggSlot); } llvm::Value* CodeGenFunction::EmitCompoundStmtWithoutScope(const CompoundStmt &S, bool GetLast, AggValueSlot AggSlot) { for (CompoundStmt::const_body_iterator I = S.body_begin(), E = S.body_end()-GetLast; I != E; ++I) EmitStmt(*I); llvm::Value *RetAlloca = 0; if (GetLast) { // We have to special case labels here. They are statements, but when put // at the end of a statement expression, they yield the value of their // subexpression. Handle this by walking through all labels we encounter, // emitting them before we evaluate the subexpr. const Stmt *LastStmt = S.body_back(); while (const LabelStmt *LS = dyn_cast(LastStmt)) { EmitLabel(LS->getDecl()); LastStmt = LS->getSubStmt(); } EnsureInsertPoint(); QualType ExprTy = cast(LastStmt)->getType(); if (hasAggregateEvaluationKind(ExprTy)) { EmitAggExpr(cast(LastStmt), AggSlot); } else { // We can't return an RValue here because there might be cleanups at // the end of the StmtExpr. Because of that, we have to emit the result // here into a temporary alloca. RetAlloca = CreateMemTemp(ExprTy); EmitAnyExprToMem(cast(LastStmt), RetAlloca, Qualifiers(), /*IsInit*/false); } } return RetAlloca; } void CodeGenFunction::SimplifyForwardingBlocks(llvm::BasicBlock *BB) { llvm::BranchInst *BI = dyn_cast(BB->getTerminator()); // If there is a cleanup stack, then we it isn't worth trying to // simplify this block (we would need to remove it from the scope map // and cleanup entry). if (!EHStack.empty()) return; // Can only simplify direct branches. if (!BI || !BI->isUnconditional()) return; // Can only simplify empty blocks. if (BI != BB->begin()) return; BB->replaceAllUsesWith(BI->getSuccessor(0)); BI->eraseFromParent(); BB->eraseFromParent(); } void CodeGenFunction::EmitBlock(llvm::BasicBlock *BB, bool IsFinished) { llvm::BasicBlock *CurBB = Builder.GetInsertBlock(); // Fall out of the current block (if necessary). EmitBranch(BB); if (IsFinished && BB->use_empty()) { delete BB; return; } // Place the block after the current block, if possible, or else at // the end of the function. if (CurBB && CurBB->getParent()) CurFn->getBasicBlockList().insertAfter(CurBB, BB); else CurFn->getBasicBlockList().push_back(BB); Builder.SetInsertPoint(BB); } void CodeGenFunction::EmitBranch(llvm::BasicBlock *Target) { // Emit a branch from the current block to the target one if this // was a real block. If this was just a fall-through block after a // terminator, don't emit it. llvm::BasicBlock *CurBB = Builder.GetInsertBlock(); if (!CurBB || CurBB->getTerminator()) { // If there is no insert point or the previous block is already // terminated, don't touch it. } else { // Otherwise, create a fall-through branch. Builder.CreateBr(Target); } Builder.ClearInsertionPoint(); } void CodeGenFunction::EmitBlockAfterUses(llvm::BasicBlock *block) { bool inserted = false; for (llvm::BasicBlock::use_iterator i = block->use_begin(), e = block->use_end(); i != e; ++i) { if (llvm::Instruction *insn = dyn_cast(*i)) { CurFn->getBasicBlockList().insertAfter(insn->getParent(), block); inserted = true; break; } } if (!inserted) CurFn->getBasicBlockList().push_back(block); Builder.SetInsertPoint(block); } CodeGenFunction::JumpDest CodeGenFunction::getJumpDestForLabel(const LabelDecl *D) { JumpDest &Dest = LabelMap[D]; if (Dest.isValid()) return Dest; // Create, but don't insert, the new block. Dest = JumpDest(createBasicBlock(D->getName()), EHScopeStack::stable_iterator::invalid(), NextCleanupDestIndex++); return Dest; } void CodeGenFunction::EmitLabel(const LabelDecl *D) { // Add this label to the current lexical scope if we're within any // normal cleanups. Jumps "in" to this label --- when permitted by // the language --- may need to be routed around such cleanups. if (EHStack.hasNormalCleanups() && CurLexicalScope) CurLexicalScope->addLabel(D); JumpDest &Dest = LabelMap[D]; // If we didn't need a forward reference to this label, just go // ahead and create a destination at the current scope. if (!Dest.isValid()) { Dest = getJumpDestInCurrentScope(D->getName()); // Otherwise, we need to give this label a target depth and remove // it from the branch-fixups list. } else { assert(!Dest.getScopeDepth().isValid() && "already emitted label!"); Dest.setScopeDepth(EHStack.stable_begin()); ResolveBranchFixups(Dest.getBlock()); } EmitBlock(Dest.getBlock()); } /// Change the cleanup scope of the labels in this lexical scope to /// match the scope of the enclosing context. void CodeGenFunction::LexicalScope::rescopeLabels() { assert(!Labels.empty()); EHScopeStack::stable_iterator innermostScope = CGF.EHStack.getInnermostNormalCleanup(); // Change the scope depth of all the labels. for (SmallVectorImpl::const_iterator i = Labels.begin(), e = Labels.end(); i != e; ++i) { assert(CGF.LabelMap.count(*i)); JumpDest &dest = CGF.LabelMap.find(*i)->second; assert(dest.getScopeDepth().isValid()); assert(innermostScope.encloses(dest.getScopeDepth())); dest.setScopeDepth(innermostScope); } // Reparent the labels if the new scope also has cleanups. if (innermostScope != EHScopeStack::stable_end() && ParentScope) { ParentScope->Labels.append(Labels.begin(), Labels.end()); } } void CodeGenFunction::EmitLabelStmt(const LabelStmt &S) { EmitLabel(S.getDecl()); EmitStmt(S.getSubStmt()); } void CodeGenFunction::EmitAttributedStmt(const AttributedStmt &S) { EmitStmt(S.getSubStmt()); } void CodeGenFunction::EmitGotoStmt(const GotoStmt &S) { // If this code is reachable then emit a stop point (if generating // debug info). We have to do this ourselves because we are on the // "simple" statement path. if (HaveInsertPoint()) EmitStopPoint(&S); EmitBranchThroughCleanup(getJumpDestForLabel(S.getLabel())); } void CodeGenFunction::EmitIndirectGotoStmt(const IndirectGotoStmt &S) { if (const LabelDecl *Target = S.getConstantTarget()) { EmitBranchThroughCleanup(getJumpDestForLabel(Target)); return; } // Ensure that we have an i8* for our PHI node. llvm::Value *V = Builder.CreateBitCast(EmitScalarExpr(S.getTarget()), Int8PtrTy, "addr"); llvm::BasicBlock *CurBB = Builder.GetInsertBlock(); // Get the basic block for the indirect goto. llvm::BasicBlock *IndGotoBB = GetIndirectGotoBlock(); // The first instruction in the block has to be the PHI for the switch dest, // add an entry for this branch. cast(IndGotoBB->begin())->addIncoming(V, CurBB); EmitBranch(IndGotoBB); } void CodeGenFunction::EmitIfStmt(const IfStmt &S) { // C99 6.8.4.1: The first substatement is executed if the expression compares // unequal to 0. The condition must be a scalar type. LexicalScope ConditionScope(*this, S.getSourceRange()); if (S.getConditionVariable()) EmitAutoVarDecl(*S.getConditionVariable()); // If the condition constant folds and can be elided, try to avoid emitting // the condition and the dead arm of the if/else. bool CondConstant; if (ConstantFoldsToSimpleInteger(S.getCond(), CondConstant)) { // Figure out which block (then or else) is executed. const Stmt *Executed = S.getThen(); const Stmt *Skipped = S.getElse(); if (!CondConstant) // Condition false? std::swap(Executed, Skipped); // If the skipped block has no labels in it, just emit the executed block. // This avoids emitting dead code and simplifies the CFG substantially. if (!ContainsLabel(Skipped)) { if (Executed) { RunCleanupsScope ExecutedScope(*this); EmitStmt(Executed); } return; } } // Otherwise, the condition did not fold, or we couldn't elide it. Just emit // the conditional branch. llvm::BasicBlock *ThenBlock = createBasicBlock("if.then"); llvm::BasicBlock *ContBlock = createBasicBlock("if.end"); llvm::BasicBlock *ElseBlock = ContBlock; if (S.getElse()) ElseBlock = createBasicBlock("if.else"); EmitBranchOnBoolExpr(S.getCond(), ThenBlock, ElseBlock); // Emit the 'then' code. EmitBlock(ThenBlock); { RunCleanupsScope ThenScope(*this); EmitStmt(S.getThen()); } EmitBranch(ContBlock); // Emit the 'else' code if present. if (const Stmt *Else = S.getElse()) { // There is no need to emit line number for unconditional branch. if (getDebugInfo()) Builder.SetCurrentDebugLocation(llvm::DebugLoc()); EmitBlock(ElseBlock); { RunCleanupsScope ElseScope(*this); EmitStmt(Else); } // There is no need to emit line number for unconditional branch. if (getDebugInfo()) Builder.SetCurrentDebugLocation(llvm::DebugLoc()); EmitBranch(ContBlock); } // Emit the continuation block for code after the if. EmitBlock(ContBlock, true); } void CodeGenFunction::EmitWhileStmt(const WhileStmt &S) { // Emit the header for the loop, which will also become // the continue target. JumpDest LoopHeader = getJumpDestInCurrentScope("while.cond"); EmitBlock(LoopHeader.getBlock()); // Create an exit block for when the condition fails, which will // also become the break target. JumpDest LoopExit = getJumpDestInCurrentScope("while.end"); // Store the blocks to use for break and continue. BreakContinueStack.push_back(BreakContinue(LoopExit, LoopHeader)); // C++ [stmt.while]p2: // When the condition of a while statement is a declaration, the // scope of the variable that is declared extends from its point // of declaration (3.3.2) to the end of the while statement. // [...] // The object created in a condition is destroyed and created // with each iteration of the loop. RunCleanupsScope ConditionScope(*this); if (S.getConditionVariable()) EmitAutoVarDecl(*S.getConditionVariable()); // Evaluate the conditional in the while header. C99 6.8.5.1: The // evaluation of the controlling expression takes place before each // execution of the loop body. llvm::Value *BoolCondVal = EvaluateExprAsBool(S.getCond()); // while(1) is common, avoid extra exit blocks. Be sure // to correctly handle break/continue though. bool EmitBoolCondBranch = true; if (llvm::ConstantInt *C = dyn_cast(BoolCondVal)) if (C->isOne()) EmitBoolCondBranch = false; // As long as the condition is true, go to the loop body. llvm::BasicBlock *LoopBody = createBasicBlock("while.body"); if (EmitBoolCondBranch) { llvm::BasicBlock *ExitBlock = LoopExit.getBlock(); if (ConditionScope.requiresCleanups()) ExitBlock = createBasicBlock("while.exit"); Builder.CreateCondBr(BoolCondVal, LoopBody, ExitBlock); if (ExitBlock != LoopExit.getBlock()) { EmitBlock(ExitBlock); EmitBranchThroughCleanup(LoopExit); } } // Emit the loop body. We have to emit this in a cleanup scope // because it might be a singleton DeclStmt. { RunCleanupsScope BodyScope(*this); EmitBlock(LoopBody); EmitStmt(S.getBody()); } BreakContinueStack.pop_back(); // Immediately force cleanup. ConditionScope.ForceCleanup(); // Branch to the loop header again. EmitBranch(LoopHeader.getBlock()); // Emit the exit block. EmitBlock(LoopExit.getBlock(), true); // The LoopHeader typically is just a branch if we skipped emitting // a branch, try to erase it. if (!EmitBoolCondBranch) SimplifyForwardingBlocks(LoopHeader.getBlock()); } void CodeGenFunction::EmitDoStmt(const DoStmt &S) { JumpDest LoopExit = getJumpDestInCurrentScope("do.end"); JumpDest LoopCond = getJumpDestInCurrentScope("do.cond"); // Store the blocks to use for break and continue. BreakContinueStack.push_back(BreakContinue(LoopExit, LoopCond)); // Emit the body of the loop. llvm::BasicBlock *LoopBody = createBasicBlock("do.body"); EmitBlock(LoopBody); { RunCleanupsScope BodyScope(*this); EmitStmt(S.getBody()); } BreakContinueStack.pop_back(); EmitBlock(LoopCond.getBlock()); // C99 6.8.5.2: "The evaluation of the controlling expression takes place // after each execution of the loop body." // Evaluate the conditional in the while header. // C99 6.8.5p2/p4: The first substatement is executed if the expression // compares unequal to 0. The condition must be a scalar type. llvm::Value *BoolCondVal = EvaluateExprAsBool(S.getCond()); // "do {} while (0)" is common in macros, avoid extra blocks. Be sure // to correctly handle break/continue though. bool EmitBoolCondBranch = true; if (llvm::ConstantInt *C = dyn_cast(BoolCondVal)) if (C->isZero()) EmitBoolCondBranch = false; // As long as the condition is true, iterate the loop. if (EmitBoolCondBranch) Builder.CreateCondBr(BoolCondVal, LoopBody, LoopExit.getBlock()); // Emit the exit block. EmitBlock(LoopExit.getBlock()); // The DoCond block typically is just a branch if we skipped // emitting a branch, try to erase it. if (!EmitBoolCondBranch) SimplifyForwardingBlocks(LoopCond.getBlock()); } void CodeGenFunction::EmitForStmt(const ForStmt &S) { JumpDest LoopExit = getJumpDestInCurrentScope("for.end"); RunCleanupsScope ForScope(*this); CGDebugInfo *DI = getDebugInfo(); if (DI) DI->EmitLexicalBlockStart(Builder, S.getSourceRange().getBegin()); // Evaluate the first part before the loop. if (S.getInit()) EmitStmt(S.getInit()); // Start the loop with a block that tests the condition. // If there's an increment, the continue scope will be overwritten // later. JumpDest Continue = getJumpDestInCurrentScope("for.cond"); llvm::BasicBlock *CondBlock = Continue.getBlock(); EmitBlock(CondBlock); // Create a cleanup scope for the condition variable cleanups. RunCleanupsScope ConditionScope(*this); if (S.getCond()) { // If the for statement has a condition scope, emit the local variable // declaration. if (S.getConditionVariable()) { EmitAutoVarDecl(*S.getConditionVariable()); } llvm::BasicBlock *ExitBlock = LoopExit.getBlock(); // If there are any cleanups between here and the loop-exit scope, // create a block to stage a loop exit along. if (ForScope.requiresCleanups()) ExitBlock = createBasicBlock("for.cond.cleanup"); // As long as the condition is true, iterate the loop. llvm::BasicBlock *ForBody = createBasicBlock("for.body"); // C99 6.8.5p2/p4: The first substatement is executed if the expression // compares unequal to 0. The condition must be a scalar type. EmitBranchOnBoolExpr(S.getCond(), ForBody, ExitBlock); if (ExitBlock != LoopExit.getBlock()) { EmitBlock(ExitBlock); EmitBranchThroughCleanup(LoopExit); } EmitBlock(ForBody); } else { // Treat it as a non-zero constant. Don't even create a new block for the // body, just fall into it. } // If the for loop doesn't have an increment we can just use the // condition as the continue block. Otherwise we'll need to create // a block for it (in the current scope, i.e. in the scope of the // condition), and that we will become our continue block. if (S.getInc()) Continue = getJumpDestInCurrentScope("for.inc"); // Store the blocks to use for break and continue. BreakContinueStack.push_back(BreakContinue(LoopExit, Continue)); { // Create a separate cleanup scope for the body, in case it is not // a compound statement. RunCleanupsScope BodyScope(*this); EmitStmt(S.getBody()); } // If there is an increment, emit it next. if (S.getInc()) { EmitBlock(Continue.getBlock()); EmitStmt(S.getInc()); } BreakContinueStack.pop_back(); ConditionScope.ForceCleanup(); EmitBranch(CondBlock); ForScope.ForceCleanup(); if (DI) DI->EmitLexicalBlockEnd(Builder, S.getSourceRange().getEnd()); // Emit the fall-through block. EmitBlock(LoopExit.getBlock(), true); } void CodeGenFunction::EmitCXXForRangeStmt(const CXXForRangeStmt &S) { JumpDest LoopExit = getJumpDestInCurrentScope("for.end"); RunCleanupsScope ForScope(*this); CGDebugInfo *DI = getDebugInfo(); if (DI) DI->EmitLexicalBlockStart(Builder, S.getSourceRange().getBegin()); // Evaluate the first pieces before the loop. EmitStmt(S.getRangeStmt()); EmitStmt(S.getBeginEndStmt()); // Start the loop with a block that tests the condition. // If there's an increment, the continue scope will be overwritten // later. llvm::BasicBlock *CondBlock = createBasicBlock("for.cond"); EmitBlock(CondBlock); // If there are any cleanups between here and the loop-exit scope, // create a block to stage a loop exit along. llvm::BasicBlock *ExitBlock = LoopExit.getBlock(); if (ForScope.requiresCleanups()) ExitBlock = createBasicBlock("for.cond.cleanup"); // The loop body, consisting of the specified body and the loop variable. llvm::BasicBlock *ForBody = createBasicBlock("for.body"); // The body is executed if the expression, contextually converted // to bool, is true. EmitBranchOnBoolExpr(S.getCond(), ForBody, ExitBlock); if (ExitBlock != LoopExit.getBlock()) { EmitBlock(ExitBlock); EmitBranchThroughCleanup(LoopExit); } EmitBlock(ForBody); // Create a block for the increment. In case of a 'continue', we jump there. JumpDest Continue = getJumpDestInCurrentScope("for.inc"); // Store the blocks to use for break and continue. BreakContinueStack.push_back(BreakContinue(LoopExit, Continue)); { // Create a separate cleanup scope for the loop variable and body. RunCleanupsScope BodyScope(*this); EmitStmt(S.getLoopVarStmt()); EmitStmt(S.getBody()); } // If there is an increment, emit it next. EmitBlock(Continue.getBlock()); EmitStmt(S.getInc()); BreakContinueStack.pop_back(); EmitBranch(CondBlock); ForScope.ForceCleanup(); if (DI) DI->EmitLexicalBlockEnd(Builder, S.getSourceRange().getEnd()); // Emit the fall-through block. EmitBlock(LoopExit.getBlock(), true); } void CodeGenFunction::EmitReturnOfRValue(RValue RV, QualType Ty) { if (RV.isScalar()) { Builder.CreateStore(RV.getScalarVal(), ReturnValue); } else if (RV.isAggregate()) { EmitAggregateCopy(ReturnValue, RV.getAggregateAddr(), Ty); } else { EmitStoreOfComplex(RV.getComplexVal(), MakeNaturalAlignAddrLValue(ReturnValue, Ty), /*init*/ true); } EmitBranchThroughCleanup(ReturnBlock); } /// EmitReturnStmt - Note that due to GCC extensions, this can have an operand /// if the function returns void, or may be missing one if the function returns /// non-void. Fun stuff :). void CodeGenFunction::EmitReturnStmt(const ReturnStmt &S) { // Emit the result value, even if unused, to evalute the side effects. const Expr *RV = S.getRetValue(); // Treat block literals in a return expression as if they appeared // in their own scope. This permits a small, easily-implemented // exception to our over-conservative rules about not jumping to // statements following block literals with non-trivial cleanups. RunCleanupsScope cleanupScope(*this); if (const ExprWithCleanups *cleanups = dyn_cast_or_null(RV)) { enterFullExpression(cleanups); RV = cleanups->getSubExpr(); } // FIXME: Clean this up by using an LValue for ReturnTemp, // EmitStoreThroughLValue, and EmitAnyExpr. if (S.getNRVOCandidate() && S.getNRVOCandidate()->isNRVOVariable()) { // Apply the named return value optimization for this return statement, // which means doing nothing: the appropriate result has already been // constructed into the NRVO variable. // If there is an NRVO flag for this variable, set it to 1 into indicate // that the cleanup code should not destroy the variable. if (llvm::Value *NRVOFlag = NRVOFlags[S.getNRVOCandidate()]) Builder.CreateStore(Builder.getTrue(), NRVOFlag); } else if (!ReturnValue) { // Make sure not to return anything, but evaluate the expression // for side effects. if (RV) EmitAnyExpr(RV); } else if (RV == 0) { // Do nothing (return value is left uninitialized) } else if (FnRetTy->isReferenceType()) { // If this function returns a reference, take the address of the expression // rather than the value. RValue Result = EmitReferenceBindingToExpr(RV); Builder.CreateStore(Result.getScalarVal(), ReturnValue); } else { switch (getEvaluationKind(RV->getType())) { case TEK_Scalar: Builder.CreateStore(EmitScalarExpr(RV), ReturnValue); break; case TEK_Complex: EmitComplexExprIntoLValue(RV, MakeNaturalAlignAddrLValue(ReturnValue, RV->getType()), /*isInit*/ true); break; case TEK_Aggregate: { CharUnits Alignment = getContext().getTypeAlignInChars(RV->getType()); EmitAggExpr(RV, AggValueSlot::forAddr(ReturnValue, Alignment, Qualifiers(), AggValueSlot::IsDestructed, AggValueSlot::DoesNotNeedGCBarriers, AggValueSlot::IsNotAliased)); break; } } } ++NumReturnExprs; if (RV == 0 || RV->isEvaluatable(getContext())) ++NumSimpleReturnExprs; cleanupScope.ForceCleanup(); EmitBranchThroughCleanup(ReturnBlock); } void CodeGenFunction::EmitDeclStmt(const DeclStmt &S) { // As long as debug info is modeled with instructions, we have to ensure we // have a place to insert here and write the stop point here. if (HaveInsertPoint()) EmitStopPoint(&S); for (DeclStmt::const_decl_iterator I = S.decl_begin(), E = S.decl_end(); I != E; ++I) EmitDecl(**I); } void CodeGenFunction::EmitBreakStmt(const BreakStmt &S) { assert(!BreakContinueStack.empty() && "break stmt not in a loop or switch!"); // If this code is reachable then emit a stop point (if generating // debug info). We have to do this ourselves because we are on the // "simple" statement path. if (HaveInsertPoint()) EmitStopPoint(&S); JumpDest Block = BreakContinueStack.back().BreakBlock; EmitBranchThroughCleanup(Block); } void CodeGenFunction::EmitContinueStmt(const ContinueStmt &S) { assert(!BreakContinueStack.empty() && "continue stmt not in a loop!"); // If this code is reachable then emit a stop point (if generating // debug info). We have to do this ourselves because we are on the // "simple" statement path. if (HaveInsertPoint()) EmitStopPoint(&S); JumpDest Block = BreakContinueStack.back().ContinueBlock; EmitBranchThroughCleanup(Block); } /// EmitCaseStmtRange - If case statement range is not too big then /// add multiple cases to switch instruction, one for each value within /// the range. If range is too big then emit "if" condition check. void CodeGenFunction::EmitCaseStmtRange(const CaseStmt &S) { assert(S.getRHS() && "Expected RHS value in CaseStmt"); llvm::APSInt LHS = S.getLHS()->EvaluateKnownConstInt(getContext()); llvm::APSInt RHS = S.getRHS()->EvaluateKnownConstInt(getContext()); // Emit the code for this case. We do this first to make sure it is // properly chained from our predecessor before generating the // switch machinery to enter this block. EmitBlock(createBasicBlock("sw.bb")); llvm::BasicBlock *CaseDest = Builder.GetInsertBlock(); EmitStmt(S.getSubStmt()); // If range is empty, do nothing. if (LHS.isSigned() ? RHS.slt(LHS) : RHS.ult(LHS)) return; llvm::APInt Range = RHS - LHS; // FIXME: parameters such as this should not be hardcoded. if (Range.ult(llvm::APInt(Range.getBitWidth(), 64))) { // Range is small enough to add multiple switch instruction cases. for (unsigned i = 0, e = Range.getZExtValue() + 1; i != e; ++i) { SwitchInsn->addCase(Builder.getInt(LHS), CaseDest); LHS++; } return; } // The range is too big. Emit "if" condition into a new block, // making sure to save and restore the current insertion point. llvm::BasicBlock *RestoreBB = Builder.GetInsertBlock(); // Push this test onto the chain of range checks (which terminates // in the default basic block). The switch's default will be changed // to the top of this chain after switch emission is complete. llvm::BasicBlock *FalseDest = CaseRangeBlock; CaseRangeBlock = createBasicBlock("sw.caserange"); CurFn->getBasicBlockList().push_back(CaseRangeBlock); Builder.SetInsertPoint(CaseRangeBlock); // Emit range check. llvm::Value *Diff = Builder.CreateSub(SwitchInsn->getCondition(), Builder.getInt(LHS)); llvm::Value *Cond = Builder.CreateICmpULE(Diff, Builder.getInt(Range), "inbounds"); Builder.CreateCondBr(Cond, CaseDest, FalseDest); // Restore the appropriate insertion point. if (RestoreBB) Builder.SetInsertPoint(RestoreBB); else Builder.ClearInsertionPoint(); } void CodeGenFunction::EmitCaseStmt(const CaseStmt &S) { // If there is no enclosing switch instance that we're aware of, then this // case statement and its block can be elided. This situation only happens // when we've constant-folded the switch, are emitting the constant case, // and part of the constant case includes another case statement. For // instance: switch (4) { case 4: do { case 5: } while (1); } if (!SwitchInsn) { EmitStmt(S.getSubStmt()); return; } // Handle case ranges. if (S.getRHS()) { EmitCaseStmtRange(S); return; } llvm::ConstantInt *CaseVal = Builder.getInt(S.getLHS()->EvaluateKnownConstInt(getContext())); // If the body of the case is just a 'break', and if there was no fallthrough, // try to not emit an empty block. if ((CGM.getCodeGenOpts().OptimizationLevel > 0) && isa(S.getSubStmt())) { JumpDest Block = BreakContinueStack.back().BreakBlock; // Only do this optimization if there are no cleanups that need emitting. if (isObviouslyBranchWithoutCleanups(Block)) { SwitchInsn->addCase(CaseVal, Block.getBlock()); // If there was a fallthrough into this case, make sure to redirect it to // the end of the switch as well. if (Builder.GetInsertBlock()) { Builder.CreateBr(Block.getBlock()); Builder.ClearInsertionPoint(); } return; } } EmitBlock(createBasicBlock("sw.bb")); llvm::BasicBlock *CaseDest = Builder.GetInsertBlock(); SwitchInsn->addCase(CaseVal, CaseDest); // Recursively emitting the statement is acceptable, but is not wonderful for // code where we have many case statements nested together, i.e.: // case 1: // case 2: // case 3: etc. // Handling this recursively will create a new block for each case statement // that falls through to the next case which is IR intensive. It also causes // deep recursion which can run into stack depth limitations. Handle // sequential non-range case statements specially. const CaseStmt *CurCase = &S; const CaseStmt *NextCase = dyn_cast(S.getSubStmt()); // Otherwise, iteratively add consecutive cases to this switch stmt. while (NextCase && NextCase->getRHS() == 0) { CurCase = NextCase; llvm::ConstantInt *CaseVal = Builder.getInt(CurCase->getLHS()->EvaluateKnownConstInt(getContext())); SwitchInsn->addCase(CaseVal, CaseDest); NextCase = dyn_cast(CurCase->getSubStmt()); } // Normal default recursion for non-cases. EmitStmt(CurCase->getSubStmt()); } void CodeGenFunction::EmitDefaultStmt(const DefaultStmt &S) { llvm::BasicBlock *DefaultBlock = SwitchInsn->getDefaultDest(); assert(DefaultBlock->empty() && "EmitDefaultStmt: Default block already defined?"); EmitBlock(DefaultBlock); EmitStmt(S.getSubStmt()); } /// CollectStatementsForCase - Given the body of a 'switch' statement and a /// constant value that is being switched on, see if we can dead code eliminate /// the body of the switch to a simple series of statements to emit. Basically, /// on a switch (5) we want to find these statements: /// case 5: /// printf(...); <-- /// ++i; <-- /// break; /// /// and add them to the ResultStmts vector. If it is unsafe to do this /// transformation (for example, one of the elided statements contains a label /// that might be jumped to), return CSFC_Failure. If we handled it and 'S' /// should include statements after it (e.g. the printf() line is a substmt of /// the case) then return CSFC_FallThrough. If we handled it and found a break /// statement, then return CSFC_Success. /// /// If Case is non-null, then we are looking for the specified case, checking /// that nothing we jump over contains labels. If Case is null, then we found /// the case and are looking for the break. /// /// If the recursive walk actually finds our Case, then we set FoundCase to /// true. /// enum CSFC_Result { CSFC_Failure, CSFC_FallThrough, CSFC_Success }; static CSFC_Result CollectStatementsForCase(const Stmt *S, const SwitchCase *Case, bool &FoundCase, SmallVectorImpl &ResultStmts) { // If this is a null statement, just succeed. if (S == 0) return Case ? CSFC_Success : CSFC_FallThrough; // If this is the switchcase (case 4: or default) that we're looking for, then // we're in business. Just add the substatement. if (const SwitchCase *SC = dyn_cast(S)) { if (S == Case) { FoundCase = true; return CollectStatementsForCase(SC->getSubStmt(), 0, FoundCase, ResultStmts); } // Otherwise, this is some other case or default statement, just ignore it. return CollectStatementsForCase(SC->getSubStmt(), Case, FoundCase, ResultStmts); } // If we are in the live part of the code and we found our break statement, // return a success! if (Case == 0 && isa(S)) return CSFC_Success; // If this is a switch statement, then it might contain the SwitchCase, the // break, or neither. if (const CompoundStmt *CS = dyn_cast(S)) { // Handle this as two cases: we might be looking for the SwitchCase (if so // the skipped statements must be skippable) or we might already have it. CompoundStmt::const_body_iterator I = CS->body_begin(), E = CS->body_end(); if (Case) { // Keep track of whether we see a skipped declaration. The code could be // using the declaration even if it is skipped, so we can't optimize out // the decl if the kept statements might refer to it. bool HadSkippedDecl = false; // If we're looking for the case, just see if we can skip each of the // substatements. for (; Case && I != E; ++I) { HadSkippedDecl |= isa(*I); switch (CollectStatementsForCase(*I, Case, FoundCase, ResultStmts)) { case CSFC_Failure: return CSFC_Failure; case CSFC_Success: // A successful result means that either 1) that the statement doesn't // have the case and is skippable, or 2) does contain the case value // and also contains the break to exit the switch. In the later case, // we just verify the rest of the statements are elidable. if (FoundCase) { // If we found the case and skipped declarations, we can't do the // optimization. if (HadSkippedDecl) return CSFC_Failure; for (++I; I != E; ++I) if (CodeGenFunction::ContainsLabel(*I, true)) return CSFC_Failure; return CSFC_Success; } break; case CSFC_FallThrough: // If we have a fallthrough condition, then we must have found the // case started to include statements. Consider the rest of the // statements in the compound statement as candidates for inclusion. assert(FoundCase && "Didn't find case but returned fallthrough?"); // We recursively found Case, so we're not looking for it anymore. Case = 0; // If we found the case and skipped declarations, we can't do the // optimization. if (HadSkippedDecl) return CSFC_Failure; break; } } } // If we have statements in our range, then we know that the statements are // live and need to be added to the set of statements we're tracking. for (; I != E; ++I) { switch (CollectStatementsForCase(*I, 0, FoundCase, ResultStmts)) { case CSFC_Failure: return CSFC_Failure; case CSFC_FallThrough: // A fallthrough result means that the statement was simple and just // included in ResultStmt, keep adding them afterwards. break; case CSFC_Success: // A successful result means that we found the break statement and // stopped statement inclusion. We just ensure that any leftover stmts // are skippable and return success ourselves. for (++I; I != E; ++I) if (CodeGenFunction::ContainsLabel(*I, true)) return CSFC_Failure; return CSFC_Success; } } return Case ? CSFC_Success : CSFC_FallThrough; } // Okay, this is some other statement that we don't handle explicitly, like a // for statement or increment etc. If we are skipping over this statement, // just verify it doesn't have labels, which would make it invalid to elide. if (Case) { if (CodeGenFunction::ContainsLabel(S, true)) return CSFC_Failure; return CSFC_Success; } // Otherwise, we want to include this statement. Everything is cool with that // so long as it doesn't contain a break out of the switch we're in. if (CodeGenFunction::containsBreak(S)) return CSFC_Failure; // Otherwise, everything is great. Include the statement and tell the caller // that we fall through and include the next statement as well. ResultStmts.push_back(S); return CSFC_FallThrough; } /// FindCaseStatementsForValue - Find the case statement being jumped to and /// then invoke CollectStatementsForCase to find the list of statements to emit /// for a switch on constant. See the comment above CollectStatementsForCase /// for more details. static bool FindCaseStatementsForValue(const SwitchStmt &S, const llvm::APSInt &ConstantCondValue, SmallVectorImpl &ResultStmts, ASTContext &C) { // First step, find the switch case that is being branched to. We can do this // efficiently by scanning the SwitchCase list. const SwitchCase *Case = S.getSwitchCaseList(); const DefaultStmt *DefaultCase = 0; for (; Case; Case = Case->getNextSwitchCase()) { // It's either a default or case. Just remember the default statement in // case we're not jumping to any numbered cases. if (const DefaultStmt *DS = dyn_cast(Case)) { DefaultCase = DS; continue; } // Check to see if this case is the one we're looking for. const CaseStmt *CS = cast(Case); // Don't handle case ranges yet. if (CS->getRHS()) return false; // If we found our case, remember it as 'case'. if (CS->getLHS()->EvaluateKnownConstInt(C) == ConstantCondValue) break; } // If we didn't find a matching case, we use a default if it exists, or we // elide the whole switch body! if (Case == 0) { // It is safe to elide the body of the switch if it doesn't contain labels // etc. If it is safe, return successfully with an empty ResultStmts list. if (DefaultCase == 0) return !CodeGenFunction::ContainsLabel(&S); Case = DefaultCase; } // Ok, we know which case is being jumped to, try to collect all the // statements that follow it. This can fail for a variety of reasons. Also, // check to see that the recursive walk actually found our case statement. // Insane cases like this can fail to find it in the recursive walk since we // don't handle every stmt kind: // switch (4) { // while (1) { // case 4: ... bool FoundCase = false; return CollectStatementsForCase(S.getBody(), Case, FoundCase, ResultStmts) != CSFC_Failure && FoundCase; } void CodeGenFunction::EmitSwitchStmt(const SwitchStmt &S) { JumpDest SwitchExit = getJumpDestInCurrentScope("sw.epilog"); RunCleanupsScope ConditionScope(*this); if (S.getConditionVariable()) EmitAutoVarDecl(*S.getConditionVariable()); // Handle nested switch statements. llvm::SwitchInst *SavedSwitchInsn = SwitchInsn; llvm::BasicBlock *SavedCRBlock = CaseRangeBlock; // See if we can constant fold the condition of the switch and therefore only // emit the live case statement (if any) of the switch. llvm::APSInt ConstantCondValue; if (ConstantFoldsToSimpleInteger(S.getCond(), ConstantCondValue)) { SmallVector CaseStmts; if (FindCaseStatementsForValue(S, ConstantCondValue, CaseStmts, getContext())) { RunCleanupsScope ExecutedScope(*this); // At this point, we are no longer "within" a switch instance, so // we can temporarily enforce this to ensure that any embedded case // statements are not emitted. SwitchInsn = 0; // Okay, we can dead code eliminate everything except this case. Emit the // specified series of statements and we're good. for (unsigned i = 0, e = CaseStmts.size(); i != e; ++i) EmitStmt(CaseStmts[i]); // Now we want to restore the saved switch instance so that nested // switches continue to function properly SwitchInsn = SavedSwitchInsn; return; } } llvm::Value *CondV = EmitScalarExpr(S.getCond()); // Create basic block to hold stuff that comes after switch // statement. We also need to create a default block now so that // explicit case ranges tests can have a place to jump to on // failure. llvm::BasicBlock *DefaultBlock = createBasicBlock("sw.default"); SwitchInsn = Builder.CreateSwitch(CondV, DefaultBlock); CaseRangeBlock = DefaultBlock; // Clear the insertion point to indicate we are in unreachable code. Builder.ClearInsertionPoint(); // All break statements jump to NextBlock. If BreakContinueStack is non empty // then reuse last ContinueBlock. JumpDest OuterContinue; if (!BreakContinueStack.empty()) OuterContinue = BreakContinueStack.back().ContinueBlock; BreakContinueStack.push_back(BreakContinue(SwitchExit, OuterContinue)); // Emit switch body. EmitStmt(S.getBody()); BreakContinueStack.pop_back(); // Update the default block in case explicit case range tests have // been chained on top. SwitchInsn->setDefaultDest(CaseRangeBlock); // If a default was never emitted: if (!DefaultBlock->getParent()) { // If we have cleanups, emit the default block so that there's a // place to jump through the cleanups from. if (ConditionScope.requiresCleanups()) { EmitBlock(DefaultBlock); // Otherwise, just forward the default block to the switch end. } else { DefaultBlock->replaceAllUsesWith(SwitchExit.getBlock()); delete DefaultBlock; } } ConditionScope.ForceCleanup(); // Emit continuation. EmitBlock(SwitchExit.getBlock(), true); SwitchInsn = SavedSwitchInsn; CaseRangeBlock = SavedCRBlock; } static std::string SimplifyConstraint(const char *Constraint, const TargetInfo &Target, SmallVectorImpl *OutCons=0) { std::string Result; while (*Constraint) { switch (*Constraint) { default: Result += Target.convertConstraint(Constraint); break; // Ignore these case '*': case '?': case '!': case '=': // Will see this and the following in mult-alt constraints. case '+': break; case '#': // Ignore the rest of the constraint alternative. while (Constraint[1] && Constraint[1] != ',') Constraint++; break; case ',': Result += "|"; break; case 'g': Result += "imr"; break; case '[': { assert(OutCons && "Must pass output names to constraints with a symbolic name"); unsigned Index; bool result = Target.resolveSymbolicName(Constraint, &(*OutCons)[0], OutCons->size(), Index); assert(result && "Could not resolve symbolic name"); (void)result; Result += llvm::utostr(Index); break; } } Constraint++; } return Result; } /// AddVariableConstraints - Look at AsmExpr and if it is a variable declared /// as using a particular register add that as a constraint that will be used /// in this asm stmt. static std::string AddVariableConstraints(const std::string &Constraint, const Expr &AsmExpr, const TargetInfo &Target, CodeGenModule &CGM, const AsmStmt &Stmt) { const DeclRefExpr *AsmDeclRef = dyn_cast(&AsmExpr); if (!AsmDeclRef) return Constraint; const ValueDecl &Value = *AsmDeclRef->getDecl(); const VarDecl *Variable = dyn_cast(&Value); if (!Variable) return Constraint; if (Variable->getStorageClass() != SC_Register) return Constraint; AsmLabelAttr *Attr = Variable->getAttr(); if (!Attr) return Constraint; StringRef Register = Attr->getLabel(); assert(Target.isValidGCCRegisterName(Register)); // We're using validateOutputConstraint here because we only care if // this is a register constraint. TargetInfo::ConstraintInfo Info(Constraint, ""); if (Target.validateOutputConstraint(Info) && !Info.allowsRegister()) { CGM.ErrorUnsupported(&Stmt, "__asm__"); return Constraint; } // Canonicalize the register here before returning it. Register = Target.getNormalizedGCCRegisterName(Register); return "{" + Register.str() + "}"; } llvm::Value* CodeGenFunction::EmitAsmInputLValue(const TargetInfo::ConstraintInfo &Info, LValue InputValue, QualType InputType, std::string &ConstraintStr, SourceLocation Loc) { llvm::Value *Arg; if (Info.allowsRegister() || !Info.allowsMemory()) { if (CodeGenFunction::hasScalarEvaluationKind(InputType)) { Arg = EmitLoadOfLValue(InputValue, Loc).getScalarVal(); } else { llvm::Type *Ty = ConvertType(InputType); uint64_t Size = CGM.getDataLayout().getTypeSizeInBits(Ty); if (Size <= 64 && llvm::isPowerOf2_64(Size)) { Ty = llvm::IntegerType::get(getLLVMContext(), Size); Ty = llvm::PointerType::getUnqual(Ty); Arg = Builder.CreateLoad(Builder.CreateBitCast(InputValue.getAddress(), Ty)); } else { Arg = InputValue.getAddress(); ConstraintStr += '*'; } } } else { Arg = InputValue.getAddress(); ConstraintStr += '*'; } return Arg; } llvm::Value* CodeGenFunction::EmitAsmInput( const TargetInfo::ConstraintInfo &Info, const Expr *InputExpr, std::string &ConstraintStr) { if (Info.allowsRegister() || !Info.allowsMemory()) if (CodeGenFunction::hasScalarEvaluationKind(InputExpr->getType())) return EmitScalarExpr(InputExpr); InputExpr = InputExpr->IgnoreParenNoopCasts(getContext()); LValue Dest = EmitLValue(InputExpr); return EmitAsmInputLValue(Info, Dest, InputExpr->getType(), ConstraintStr, InputExpr->getExprLoc()); } /// getAsmSrcLocInfo - Return the !srcloc metadata node to attach to an inline /// asm call instruction. The !srcloc MDNode contains a list of constant /// integers which are the source locations of the start of each line in the /// asm. static llvm::MDNode *getAsmSrcLocInfo(const StringLiteral *Str, CodeGenFunction &CGF) { SmallVector Locs; // Add the location of the first line to the MDNode. Locs.push_back(llvm::ConstantInt::get(CGF.Int32Ty, Str->getLocStart().getRawEncoding())); StringRef StrVal = Str->getString(); if (!StrVal.empty()) { const SourceManager &SM = CGF.CGM.getContext().getSourceManager(); const LangOptions &LangOpts = CGF.CGM.getLangOpts(); // Add the location of the start of each subsequent line of the asm to the // MDNode. for (unsigned i = 0, e = StrVal.size()-1; i != e; ++i) { if (StrVal[i] != '\n') continue; SourceLocation LineLoc = Str->getLocationOfByte(i+1, SM, LangOpts, CGF.getTarget()); Locs.push_back(llvm::ConstantInt::get(CGF.Int32Ty, LineLoc.getRawEncoding())); } } return llvm::MDNode::get(CGF.getLLVMContext(), Locs); } void CodeGenFunction::EmitAsmStmt(const AsmStmt &S) { // Assemble the final asm string. std::string AsmString = S.generateAsmString(getContext()); // Get all the output and input constraints together. SmallVector OutputConstraintInfos; SmallVector InputConstraintInfos; for (unsigned i = 0, e = S.getNumOutputs(); i != e; i++) { StringRef Name; if (const GCCAsmStmt *GAS = dyn_cast(&S)) Name = GAS->getOutputName(i); TargetInfo::ConstraintInfo Info(S.getOutputConstraint(i), Name); bool IsValid = getTarget().validateOutputConstraint(Info); (void)IsValid; assert(IsValid && "Failed to parse output constraint"); OutputConstraintInfos.push_back(Info); } for (unsigned i = 0, e = S.getNumInputs(); i != e; i++) { StringRef Name; if (const GCCAsmStmt *GAS = dyn_cast(&S)) Name = GAS->getInputName(i); TargetInfo::ConstraintInfo Info(S.getInputConstraint(i), Name); bool IsValid = getTarget().validateInputConstraint(OutputConstraintInfos.data(), S.getNumOutputs(), Info); assert(IsValid && "Failed to parse input constraint"); (void)IsValid; InputConstraintInfos.push_back(Info); } std::string Constraints; std::vector ResultRegDests; std::vector ResultRegQualTys; std::vector ResultRegTypes; std::vector ResultTruncRegTypes; std::vector ArgTypes; std::vector Args; // Keep track of inout constraints. std::string InOutConstraints; std::vector InOutArgs; std::vector InOutArgTypes; for (unsigned i = 0, e = S.getNumOutputs(); i != e; i++) { TargetInfo::ConstraintInfo &Info = OutputConstraintInfos[i]; // Simplify the output constraint. std::string OutputConstraint(S.getOutputConstraint(i)); OutputConstraint = SimplifyConstraint(OutputConstraint.c_str() + 1, getTarget()); const Expr *OutExpr = S.getOutputExpr(i); OutExpr = OutExpr->IgnoreParenNoopCasts(getContext()); OutputConstraint = AddVariableConstraints(OutputConstraint, *OutExpr, getTarget(), CGM, S); LValue Dest = EmitLValue(OutExpr); if (!Constraints.empty()) Constraints += ','; // If this is a register output, then make the inline asm return it // by-value. If this is a memory result, return the value by-reference. if (!Info.allowsMemory() && hasScalarEvaluationKind(OutExpr->getType())) { Constraints += "=" + OutputConstraint; ResultRegQualTys.push_back(OutExpr->getType()); ResultRegDests.push_back(Dest); ResultRegTypes.push_back(ConvertTypeForMem(OutExpr->getType())); ResultTruncRegTypes.push_back(ResultRegTypes.back()); // If this output is tied to an input, and if the input is larger, then // we need to set the actual result type of the inline asm node to be the // same as the input type. if (Info.hasMatchingInput()) { unsigned InputNo; for (InputNo = 0; InputNo != S.getNumInputs(); ++InputNo) { TargetInfo::ConstraintInfo &Input = InputConstraintInfos[InputNo]; if (Input.hasTiedOperand() && Input.getTiedOperand() == i) break; } assert(InputNo != S.getNumInputs() && "Didn't find matching input!"); QualType InputTy = S.getInputExpr(InputNo)->getType(); QualType OutputType = OutExpr->getType(); uint64_t InputSize = getContext().getTypeSize(InputTy); if (getContext().getTypeSize(OutputType) < InputSize) { // Form the asm to return the value as a larger integer or fp type. ResultRegTypes.back() = ConvertType(InputTy); } } if (llvm::Type* AdjTy = getTargetHooks().adjustInlineAsmType(*this, OutputConstraint, ResultRegTypes.back())) ResultRegTypes.back() = AdjTy; else { CGM.getDiags().Report(S.getAsmLoc(), diag::err_asm_invalid_type_in_input) << OutExpr->getType() << OutputConstraint; } } else { ArgTypes.push_back(Dest.getAddress()->getType()); Args.push_back(Dest.getAddress()); Constraints += "=*"; Constraints += OutputConstraint; } if (Info.isReadWrite()) { InOutConstraints += ','; const Expr *InputExpr = S.getOutputExpr(i); llvm::Value *Arg = EmitAsmInputLValue(Info, Dest, InputExpr->getType(), InOutConstraints, InputExpr->getExprLoc()); if (llvm::Type* AdjTy = getTargetHooks().adjustInlineAsmType(*this, OutputConstraint, Arg->getType())) Arg = Builder.CreateBitCast(Arg, AdjTy); if (Info.allowsRegister()) InOutConstraints += llvm::utostr(i); else InOutConstraints += OutputConstraint; InOutArgTypes.push_back(Arg->getType()); InOutArgs.push_back(Arg); } } unsigned NumConstraints = S.getNumOutputs() + S.getNumInputs(); for (unsigned i = 0, e = S.getNumInputs(); i != e; i++) { const Expr *InputExpr = S.getInputExpr(i); TargetInfo::ConstraintInfo &Info = InputConstraintInfos[i]; if (!Constraints.empty()) Constraints += ','; // Simplify the input constraint. std::string InputConstraint(S.getInputConstraint(i)); InputConstraint = SimplifyConstraint(InputConstraint.c_str(), getTarget(), &OutputConstraintInfos); InputConstraint = AddVariableConstraints(InputConstraint, *InputExpr->IgnoreParenNoopCasts(getContext()), getTarget(), CGM, S); llvm::Value *Arg = EmitAsmInput(Info, InputExpr, Constraints); // If this input argument is tied to a larger output result, extend the // input to be the same size as the output. The LLVM backend wants to see // the input and output of a matching constraint be the same size. Note // that GCC does not define what the top bits are here. We use zext because // that is usually cheaper, but LLVM IR should really get an anyext someday. if (Info.hasTiedOperand()) { unsigned Output = Info.getTiedOperand(); QualType OutputType = S.getOutputExpr(Output)->getType(); QualType InputTy = InputExpr->getType(); if (getContext().getTypeSize(OutputType) > getContext().getTypeSize(InputTy)) { // Use ptrtoint as appropriate so that we can do our extension. if (isa(Arg->getType())) Arg = Builder.CreatePtrToInt(Arg, IntPtrTy); llvm::Type *OutputTy = ConvertType(OutputType); if (isa(OutputTy)) Arg = Builder.CreateZExt(Arg, OutputTy); else if (isa(OutputTy)) Arg = Builder.CreateZExt(Arg, IntPtrTy); else { assert(OutputTy->isFloatingPointTy() && "Unexpected output type"); Arg = Builder.CreateFPExt(Arg, OutputTy); } } } if (llvm::Type* AdjTy = getTargetHooks().adjustInlineAsmType(*this, InputConstraint, Arg->getType())) Arg = Builder.CreateBitCast(Arg, AdjTy); else CGM.getDiags().Report(S.getAsmLoc(), diag::err_asm_invalid_type_in_input) << InputExpr->getType() << InputConstraint; ArgTypes.push_back(Arg->getType()); Args.push_back(Arg); Constraints += InputConstraint; } // Append the "input" part of inout constraints last. for (unsigned i = 0, e = InOutArgs.size(); i != e; i++) { ArgTypes.push_back(InOutArgTypes[i]); Args.push_back(InOutArgs[i]); } Constraints += InOutConstraints; // Clobbers for (unsigned i = 0, e = S.getNumClobbers(); i != e; i++) { StringRef Clobber = S.getClobber(i); if (Clobber != "memory" && Clobber != "cc") Clobber = getTarget().getNormalizedGCCRegisterName(Clobber); if (i != 0 || NumConstraints != 0) Constraints += ','; Constraints += "~{"; Constraints += Clobber; Constraints += '}'; } // Add machine specific clobbers std::string MachineClobbers = getTarget().getClobbers(); if (!MachineClobbers.empty()) { if (!Constraints.empty()) Constraints += ','; Constraints += MachineClobbers; } llvm::Type *ResultType; if (ResultRegTypes.empty()) ResultType = VoidTy; else if (ResultRegTypes.size() == 1) ResultType = ResultRegTypes[0]; else ResultType = llvm::StructType::get(getLLVMContext(), ResultRegTypes); llvm::FunctionType *FTy = llvm::FunctionType::get(ResultType, ArgTypes, false); bool HasSideEffect = S.isVolatile() || S.getNumOutputs() == 0; llvm::InlineAsm::AsmDialect AsmDialect = isa(&S) ? llvm::InlineAsm::AD_Intel : llvm::InlineAsm::AD_ATT; llvm::InlineAsm *IA = llvm::InlineAsm::get(FTy, AsmString, Constraints, HasSideEffect, /* IsAlignStack */ false, AsmDialect); llvm::CallInst *Result = Builder.CreateCall(IA, Args); Result->addAttribute(llvm::AttributeSet::FunctionIndex, llvm::Attribute::NoUnwind); // Slap the source location of the inline asm into a !srcloc metadata on the // call. FIXME: Handle metadata for MS-style inline asms. if (const GCCAsmStmt *gccAsmStmt = dyn_cast(&S)) Result->setMetadata("srcloc", getAsmSrcLocInfo(gccAsmStmt->getAsmString(), *this)); // Extract all of the register value results from the asm. std::vector RegResults; if (ResultRegTypes.size() == 1) { RegResults.push_back(Result); } else { for (unsigned i = 0, e = ResultRegTypes.size(); i != e; ++i) { llvm::Value *Tmp = Builder.CreateExtractValue(Result, i, "asmresult"); RegResults.push_back(Tmp); } } for (unsigned i = 0, e = RegResults.size(); i != e; ++i) { llvm::Value *Tmp = RegResults[i]; // If the result type of the LLVM IR asm doesn't match the result type of // the expression, do the conversion. if (ResultRegTypes[i] != ResultTruncRegTypes[i]) { llvm::Type *TruncTy = ResultTruncRegTypes[i]; // Truncate the integer result to the right size, note that TruncTy can be // a pointer. if (TruncTy->isFloatingPointTy()) Tmp = Builder.CreateFPTrunc(Tmp, TruncTy); else if (TruncTy->isPointerTy() && Tmp->getType()->isIntegerTy()) { uint64_t ResSize = CGM.getDataLayout().getTypeSizeInBits(TruncTy); Tmp = Builder.CreateTrunc(Tmp, llvm::IntegerType::get(getLLVMContext(), (unsigned)ResSize)); Tmp = Builder.CreateIntToPtr(Tmp, TruncTy); } else if (Tmp->getType()->isPointerTy() && TruncTy->isIntegerTy()) { uint64_t TmpSize =CGM.getDataLayout().getTypeSizeInBits(Tmp->getType()); Tmp = Builder.CreatePtrToInt(Tmp, llvm::IntegerType::get(getLLVMContext(), (unsigned)TmpSize)); Tmp = Builder.CreateTrunc(Tmp, TruncTy); } else if (TruncTy->isIntegerTy()) { Tmp = Builder.CreateTrunc(Tmp, TruncTy); } else if (TruncTy->isVectorTy()) { Tmp = Builder.CreateBitCast(Tmp, TruncTy); } } EmitStoreThroughLValue(RValue::get(Tmp), ResultRegDests[i]); } } static LValue InitCapturedStruct(CodeGenFunction &CGF, const CapturedStmt &S) { const RecordDecl *RD = S.getCapturedRecordDecl(); QualType RecordTy = CGF.getContext().getRecordType(RD); // Initialize the captured struct. LValue SlotLV = CGF.MakeNaturalAlignAddrLValue( CGF.CreateMemTemp(RecordTy, "agg.captured"), RecordTy); RecordDecl::field_iterator CurField = RD->field_begin(); for (CapturedStmt::capture_init_iterator I = S.capture_init_begin(), E = S.capture_init_end(); I != E; ++I, ++CurField) { LValue LV = CGF.EmitLValueForFieldInitialization(SlotLV, *CurField); CGF.EmitInitializerForField(*CurField, LV, *I, ArrayRef()); } return SlotLV; } /// Generate an outlined function for the body of a CapturedStmt, store any /// captured variables into the captured struct, and call the outlined function. llvm::Function * CodeGenFunction::EmitCapturedStmt(const CapturedStmt &S, CapturedRegionKind K) { const CapturedDecl *CD = S.getCapturedDecl(); const RecordDecl *RD = S.getCapturedRecordDecl(); assert(CD->hasBody() && "missing CapturedDecl body"); LValue CapStruct = InitCapturedStruct(*this, S); // Emit the CapturedDecl CodeGenFunction CGF(CGM, true); CGF.CapturedStmtInfo = new CGCapturedStmtInfo(S, K); llvm::Function *F = CGF.GenerateCapturedStmtFunction(CD, RD, S.getLocStart()); delete CGF.CapturedStmtInfo; // Emit call to the helper function. EmitCallOrInvoke(F, CapStruct.getAddress()); return F; } /// Creates the outlined function for a CapturedStmt. llvm::Function * CodeGenFunction::GenerateCapturedStmtFunction(const CapturedDecl *CD, const RecordDecl *RD, SourceLocation Loc) { assert(CapturedStmtInfo && "CapturedStmtInfo should be set when generating the captured function"); // Build the argument list. ASTContext &Ctx = CGM.getContext(); FunctionArgList Args; Args.append(CD->param_begin(), CD->param_end()); // Create the function declaration. FunctionType::ExtInfo ExtInfo; const CGFunctionInfo &FuncInfo = CGM.getTypes().arrangeFunctionDeclaration(Ctx.VoidTy, Args, ExtInfo, /*IsVariadic=*/false); llvm::FunctionType *FuncLLVMTy = CGM.getTypes().GetFunctionType(FuncInfo); llvm::Function *F = llvm::Function::Create(FuncLLVMTy, llvm::GlobalValue::InternalLinkage, CapturedStmtInfo->getHelperName(), &CGM.getModule()); CGM.SetInternalFunctionAttributes(CD, F, FuncInfo); // Generate the function. StartFunction(CD, Ctx.VoidTy, F, FuncInfo, Args, CD->getBody()->getLocStart()); // Set the context parameter in CapturedStmtInfo. llvm::Value *DeclPtr = LocalDeclMap[CD->getContextParam()]; assert(DeclPtr && "missing context parameter for CapturedStmt"); CapturedStmtInfo->setContextValue(Builder.CreateLoad(DeclPtr)); // If 'this' is captured, load it into CXXThisValue. if (CapturedStmtInfo->isCXXThisExprCaptured()) { FieldDecl *FD = CapturedStmtInfo->getThisFieldDecl(); LValue LV = MakeNaturalAlignAddrLValue(CapturedStmtInfo->getContextValue(), Ctx.getTagDeclType(RD)); LValue ThisLValue = EmitLValueForField(LV, FD); CXXThisValue = EmitLoadOfLValue(ThisLValue, Loc).getScalarVal(); } CapturedStmtInfo->EmitBody(*this, CD->getBody()); FinishFunction(CD->getBodyRBrace()); return F; } @ 1.1.1.1 log @Import Clang 3.4rc1 r195771. @ text @@ 1.1.1.2 log @Import clang 3.5svn r198450. @ text @d245 1 a245 1 d660 1 a660 2 llvm::Value *BoolCondVal = EvaluateExprAsBool(S.getCond()); Builder.CreateCondBr(BoolCondVal, ForBody, ExitBlock); d740 1 a740 2 llvm::Value *BoolCondVal = EvaluateExprAsBool(S.getCond()); Builder.CreateCondBr(BoolCondVal, ForBody, ExitBlock); d962 1 a962 1 // and part of the constant case includes another case statement. For d1288 1 a1288 1 // All break statements jump to NextBlock. If BreakContinueStack is non-empty d1496 1 a1496 1 assert(IsValid && "Failed to parse output constraint"); @ 1.1.1.3 log @Import Clang 3.5svn r199312 @ text @d19 1 a21 1 #include "clang/Sema/SemaDiagnostic.h" a360 1 RegionCounter Cnt = getPGORegionCounter(D->getStmt()); a361 1 Cnt.beginRegion(Builder); a404 1 PGO.setCurrentRegionUnreachable(); a410 1 PGO.setCurrentRegionUnreachable(); a426 1 PGO.setCurrentRegionUnreachable(); a432 1 RegionCounter Cnt = getPGORegionCounter(&S); a449 2 if (CondConstant) Cnt.beginRegion(Builder); d465 1 a465 2 EmitBranchOnBoolExpr(S.getCond(), ThenBlock, ElseBlock, Cnt.getCount()); d468 1 a468 2 EmitBlock(ThenBlock); Cnt.beginRegion(Builder); a472 1 Cnt.adjustForControlFlow(); a480 1 Cnt.beginElseRegion(); a484 1 Cnt.adjustForControlFlow(); a492 1 Cnt.applyAdjustmentsToRegion(); a495 2 RegionCounter Cnt = getPGORegionCounter(&S); d506 1 a506 1 BreakContinueStack.push_back(BreakContinue(LoopExit, LoopHeader, &Cnt)); a527 1 llvm::BranchInst *CondBr = NULL; d539 1 a539 1 CondBr = Builder.CreateCondBr(BoolCondVal, LoopBody, ExitBlock); a551 1 Cnt.beginRegion(Builder); a553 1 Cnt.adjustForControlFlow(); a556 6 uint64_t LoopCount = Cnt.getCount(); uint64_t ExitCount = Cnt.getLoopExitCount(); if (EmitBoolCondBranch) CondBr->setMetadata(llvm::LLVMContext::MD_prof, PGO.createBranchWeights(LoopCount, ExitCount)); a564 1 PGO.setCurrentRegionCount(ExitCount + Cnt.getBreakCounter().getCount()); a575 2 RegionCounter Cnt = getPGORegionCounter(&S); d577 1 a577 1 BreakContinueStack.push_back(BreakContinue(LoopExit, LoopCond, &Cnt)); a581 1 Cnt.beginRegion(Builder); a585 1 Cnt.adjustForControlFlow(); a605 3 uint64_t LoopCount = Cnt.getCount() - Cnt.getParentCount(); uint64_t ExitCount = Cnt.getLoopExitCount(); d608 1 a608 2 Builder.CreateCondBr(BoolCondVal, LoopBody, LoopExit.getBlock(), PGO.createBranchWeights(LoopCount, ExitCount)); a611 1 PGO.setCurrentRegionCount(ExitCount + Cnt.getBreakCounter().getCount()); a619 2 RegionCounter Cnt = getPGORegionCounter(&S); a641 1 llvm::BranchInst *CondBr = NULL; d661 1 a661 1 CondBr = Builder.CreateCondBr(BoolCondVal, ForBody, ExitBlock); a672 1 Cnt.beginRegion(Builder); d682 1 a682 1 BreakContinueStack.push_back(BreakContinue(LoopExit, Continue, &Cnt)); a695 1 Cnt.adjustForControlFlow(); a698 6 uint64_t LoopCount = Cnt.getCount(); uint64_t ExitCount = Cnt.getLoopExitCount(); if (S.getCond()) CondBr->setMetadata(llvm::LLVMContext::MD_prof, PGO.createBranchWeights(LoopCount, ExitCount)); a708 1 PGO.setCurrentRegionCount(ExitCount + Cnt.getBreakCounter().getCount()); a711 2 RegionCounter Cnt = getPGORegionCounter(&S); d742 1 a742 2 llvm::BranchInst *CondBr = Builder.CreateCondBr(BoolCondVal, ForBody, ExitBlock); a749 1 Cnt.beginRegion(Builder); d755 1 a755 1 BreakContinueStack.push_back(BreakContinue(LoopExit, Continue, &Cnt)); a766 1 Cnt.adjustForControlFlow(); a769 5 uint64_t LoopCount = Cnt.getCount(); uint64_t ExitCount = Cnt.getLoopExitCount(); CondBr->setMetadata(llvm::LLVMContext::MD_prof, PGO.createBranchWeights(LoopCount, ExitCount)); a778 1 PGO.setCurrentRegionCount(ExitCount + Cnt.getBreakCounter().getCount()); a791 1 PGO.setCurrentRegionUnreachable(); d814 1 a814 2 if (getLangOpts().ElideConstructors && S.getNRVOCandidate() && S.getNRVOCandidate()->isNRVOVariable()) { a862 1 PGO.setCurrentRegionUnreachable(); d885 2 a886 8 BreakContinue &BC = BreakContinueStack.back(); // We keep track of breaks from the loop so we can differentiate them from // non-local exits in PGO instrumentation. This only applies to loops, not // breaks from switch statements. if (BC.CountBreak) BC.LoopCnt->getBreakCounter().beginRegion(Builder); EmitBranchThroughCleanup(BC.BreakBlock); PGO.setCurrentRegionUnreachable(); d898 2 a899 6 BreakContinue &BC = BreakContinueStack.back(); // We keep track of continues in the loop so we can differentiate them from // non-local exits in PGO instrumentation. BC.LoopCnt->getContinueCounter().beginRegion(Builder); EmitBranchThroughCleanup(BC.ContinueBlock); PGO.setCurrentRegionUnreachable(); a910 2 RegionCounter CaseCnt = getPGORegionCounter(&S); a915 1 CaseCnt.beginRegion(Builder); d926 1 a926 12 uint64_t Total = CaseCnt.getCount() - CaseCnt.getParentCount(); unsigned NCases = Range.getZExtValue() + 1; // We only have one region counter for the entire set of cases here, so we // need to divide the weights evenly between the generated cases, ensuring // that the total weight is preserved. Ie, a weight of 5 over three cases // will be distributed as weights of 2, 2, and 1. uint64_t Weight = Total / NCases, Rem = Total % NCases; for (unsigned I = 0; I != NCases; ++I) { if (SwitchWeights) SwitchWeights->push_back(Weight + (Rem ? 1 : 0)); if (Rem) Rem--; d951 1 a951 13 llvm::MDNode *Weights = 0; if (SwitchWeights) { uint64_t ThisCount = CaseCnt.getCount() - CaseCnt.getParentCount(); uint64_t DefaultCount = (*SwitchWeights)[0]; Weights = PGO.createBranchWeights(ThisCount, DefaultCount); // Since we're chaining the switch default through each large case range, we // need to update the weight for the default, ie, the first case, to include // this case. (*SwitchWeights)[0] += ThisCount; } Builder.CreateCondBr(Cond, CaseDest, FalseDest, Weights); a976 1 RegionCounter CaseCnt = getPGORegionCounter(&S); d980 20 a1001 3 if (SwitchWeights) SwitchWeights->push_back(CaseCnt.getCount() - CaseCnt.getParentCount()); CaseCnt.beginRegion(Builder); d1019 1 a1019 1 llvm::ConstantInt *CaseVal = a1020 6 CaseCnt = getPGORegionCounter(NextCase); if (SwitchWeights) SwitchWeights->push_back(CaseCnt.getCount() - CaseCnt.getParentCount()); CaseCnt.beginRegion(Builder); a1032 9 llvm::BasicBlock *SkipCountBB = 0; if (CGM.getCodeGenOpts().ProfileInstrGenerate) { // The PGO region here needs to count the number of times the edge occurs, // so fallthrough into this case will jump past the region counter to the // skipcount basic block. SkipCountBB = createBasicBlock("skipcount"); EmitBranch(SkipCountBB); } a1033 6 RegionCounter Cnt = getPGORegionCounter(&S); Cnt.beginRegion(Builder, /*AddIncomingFallThrough=*/true); if (SkipCountBB) EmitBlock(SkipCountBB); d1190 1 a1190 2 ASTContext &C, const SwitchCase *&ResultCase) { a1232 1 ResultCase = Case; a1247 1 SmallVector *SavedSwitchWeights = SwitchWeights; a1254 1 const SwitchCase *Case = 0; d1256 1 a1256 5 getContext(), Case)) { if (Case) { RegionCounter CaseCnt = getPGORegionCounter(Case); CaseCnt.beginRegion(Builder); } a1267 2 RegionCounter ExitCnt = getPGORegionCounter(&S); ExitCnt.beginRegion(Builder); a1284 17 if (PGO.haveRegionCounts()) { // Walk the SwitchCase list to find how many there are. uint64_t DefaultCount = 0; unsigned NumCases = 0; for (const SwitchCase *Case = S.getSwitchCaseList(); Case; Case = Case->getNextSwitchCase()) { if (isa(Case)) DefaultCount = getPGORegionCounter(Case).getCount(); NumCases += 1; } SwitchWeights = new SmallVector(); SwitchWeights->reserve(NumCases); // The default needs to be first. We store the edge count, so we already // know the right weight. SwitchWeights->push_back(DefaultCount); } a1288 1 PGO.setCurrentRegionUnreachable(); d1291 1 a1291 1 // then reuse last ContinueBlock and that block's counter. d1293 2 a1294 6 RegionCounter *OuterCount = 0; if (!BreakContinueStack.empty()) { BreakContinue &BC = BreakContinueStack.back(); OuterContinue = BC.ContinueBlock; OuterCount = BC.LoopCnt; } d1296 1 a1296 2 BreakContinueStack.push_back(BreakContinue(SwitchExit, OuterContinue, OuterCount, /*CountBreak=*/false)); a1324 2 RegionCounter ExitCnt = getPGORegionCounter(&S); ExitCnt.beginRegion(Builder); a1325 9 if (SwitchWeights) { assert(SwitchWeights->size() == 1 + SwitchInsn->getNumCases() && "switch weights do not match switch cases"); // If there's only one jump destination there's no sense weighting it. if (SwitchWeights->size() > 1) SwitchInsn->setMetadata(llvm::LLVMContext::MD_prof, PGO.createBranchWeights(*SwitchWeights)); delete SwitchWeights; } a1326 1 SwitchWeights = SavedSwitchWeights; @ 1.1.1.4 log @Import Clang 3.5svn r201163. @ text @d617 2 a628 2 BreakContinueStack.pop_back(); a675 10 // If the for loop doesn't have an increment we can just use the // condition as the continue block. Otherwise we'll need to create // a block for it (in the current scope, i.e. in the scope of the // condition), and that we will become our continue block. if (S.getInc()) Continue = getJumpDestInCurrentScope("for.inc"); // Store the blocks to use for break and continue. BreakContinueStack.push_back(BreakContinue(LoopExit, Continue, &Cnt)); d713 10 a1077 24 // If the body of the case is just a 'break', try to not emit an empty block. // If we're profiling or we're not optimizing, leave the block in for better // debug and coverage analysis. if (!CGM.getCodeGenOpts().ProfileInstrGenerate && CGM.getCodeGenOpts().OptimizationLevel > 0 && isa(S.getSubStmt())) { JumpDest Block = BreakContinueStack.back().BreakBlock; // Only do this optimization if there are no cleanups that need emitting. if (isObviouslyBranchWithoutCleanups(Block)) { if (SwitchWeights) SwitchWeights->push_back(CaseCnt.getCount() - CaseCnt.getParentCount()); SwitchInsn->addCase(CaseVal, Block.getBlock()); // If there was a fallthrough into this case, make sure to redirect it to // the end of the switch as well. if (Builder.GetInsertBlock()) { Builder.CreateBr(Block.getBlock()); Builder.ClearInsertionPoint(); } return; } } d1981 2 a1982 2 CGM.getTypes().arrangeFreeFunctionDeclaration(Ctx.VoidTy, Args, ExtInfo, /*IsVariadic=*/false); @ 1.1.1.5 log @Import Clang 3.5svn r202566. @ text @a45 1 PGO.setCurrentStmt(S); a78 1 case Stmt::OMPSimdDirectiveClass: d407 1 d414 1 d431 1 d483 1 d492 1 d497 1 d506 1 d522 1 a522 1 BreakContinueStack.push_back(BreakContinue(LoopExit, LoopHeader)); d544 1 d555 2 a556 2 Builder.CreateCondBr(BoolCondVal, LoopBody, ExitBlock, PGO.createLoopWeights(S.getCond(), Cnt)); d572 1 d576 6 d590 1 d605 1 a605 1 BreakContinueStack.push_back(BreakContinue(LoopExit, LoopCond)); d609 2 a610 1 EmitBlockWithFallThrough(LoopBody, Cnt); d615 1 d636 3 d642 1 a642 1 PGO.createLoopWeights(S.getCond(), Cnt)); d646 1 d655 2 a668 2 RegionCounter Cnt = getPGORegionCounter(&S); d684 1 a684 1 BreakContinueStack.push_back(BreakContinue(LoopExit, Continue)); d689 1 d709 1 a709 2 Builder.CreateCondBr(BoolCondVal, ForBody, ExitBlock, PGO.createLoopWeights(S.getCond(), Cnt)); d735 1 d739 6 d755 1 d759 2 a772 2 RegionCounter Cnt = getPGORegionCounter(&S); d791 2 a792 2 Builder.CreateCondBr(BoolCondVal, ForBody, ExitBlock, PGO.createLoopWeights(S.getCond(), Cnt)); d806 1 a806 1 BreakContinueStack.push_back(BreakContinue(LoopExit, Continue)); d818 1 d822 5 d836 1 d850 1 d923 1 d946 8 a953 1 EmitBranchThroughCleanup(BreakContinueStack.back().BreakBlock); d965 6 a970 1 EmitBranchThroughCleanup(BreakContinueStack.back().ContinueBlock); d987 3 a989 2 llvm::BasicBlock *CaseDest = createBasicBlock("sw.bb"); EmitBlockWithFallThrough(CaseDest, CaseCnt); d1000 1 a1000 1 uint64_t Total = CaseCnt.getCount(); d1004 1 a1004 1 // that the total weight is preserved. E.g., a weight of 5 over three cases d1039 1 a1039 1 uint64_t ThisCount = CaseCnt.getCount(); d1089 1 a1089 1 SwitchWeights->push_back(CaseCnt.getCount()); d1102 2 a1103 2 llvm::BasicBlock *CaseDest = createBasicBlock("sw.bb"); EmitBlockWithFallThrough(CaseDest, CaseCnt); d1105 2 a1106 1 SwitchWeights->push_back(CaseCnt.getCount()); d1129 2 a1130 5 SwitchWeights->push_back(CaseCnt.getCount()); if (CGM.getCodeGenOpts().ProfileInstrGenerate) { CaseDest = createBasicBlock("sw.bb"); EmitBlockWithFallThrough(CaseDest, CaseCnt); } d1145 10 d1156 1 a1156 1 EmitBlockWithFallThrough(DefaultBlock, Cnt); d1158 2 d1442 1 d1445 1 a1445 1 // then reuse last ContinueBlock. d1447 6 a1452 2 if (!BreakContinueStack.empty()) OuterContinue = BreakContinueStack.back().ContinueBlock; d1454 2 a1455 1 BreakContinueStack.push_back(BreakContinue(SwitchExit, OuterContinue)); @ 1.1.1.5.2.1 log @Rebase. @ text @a22 1 #include "llvm/IR/CallSite.h" d26 1 d79 2 a176 6 case Stmt::OMPParallelDirectiveClass: EmitOMPParallelDirective(cast(*S)); break; case Stmt::OMPSimdDirectiveClass: EmitOMPSimdDirective(cast(*S)); break; d222 1 a222 1 llvm::Value *RetAlloca = nullptr; d314 3 a316 2 for (llvm::User *u : block->users()) { if (llvm::Instruction *insn = dyn_cast(u)) { d436 1 a436 1 LexicalScope ConditionScope(*this, S.getCond()->getSourceRange()); a511 2 LoopStack.push(LoopHeader.getBlock()); a574 2 LoopStack.pop(); a594 3 LoopStack.push(LoopBody); a624 2 LoopStack.pop(); a655 2 LoopStack.push(CondBlock); a725 2 LoopStack.pop(); a750 2 LoopStack.push(CondBlock); a799 2 LoopStack.pop(); d847 1 a847 1 } else if (!ReturnValue || (RV && RV->getType()->isVoidType())) { d852 1 a852 1 } else if (!RV) { d882 1 a882 1 if (!RV || RV->isEvaluatable(getContext())) d895 3 a897 2 for (const auto *I : S.decls()) EmitDecl(*I); d987 1 a987 1 llvm::MDNode *Weights = nullptr; d1071 1 a1071 1 while (NextCase && NextCase->getRHS() == nullptr) { d1132 1 a1132 1 if (!S) d1140 1 a1140 1 return CollectStatementsForCase(SC->getSubStmt(), nullptr, FoundCase, d1151 1 a1151 1 if (!Case && isa(S)) d1196 1 a1196 1 Case = nullptr; d1210 1 a1210 1 switch (CollectStatementsForCase(*I, nullptr, FoundCase, ResultStmts)) { d1261 1 a1261 1 const DefaultStmt *DefaultCase = nullptr; d1283 1 a1283 1 if (!Case) { d1286 1 a1286 1 if (!DefaultCase) d1307 7 d1324 1 a1324 1 const SwitchCase *Case = nullptr; a1332 5 // Emit the condition variable if needed inside the entire cleanup scope // used by this special case for constant folded switches. if (S.getConditionVariable()) EmitAutoVarDecl(*S.getConditionVariable()); d1336 1 a1336 1 SwitchInsn = nullptr; a1352 5 JumpDest SwitchExit = getJumpDestInCurrentScope("sw.epilog"); RunCleanupsScope ConditionScope(*this); if (S.getConditionVariable()) EmitAutoVarDecl(*S.getConditionVariable()); d1437 1 a1437 1 SmallVectorImpl *OutCons=nullptr) { a1922 6 llvm::Value * CodeGenFunction::GenerateCapturedStmtArgument(const CapturedStmt &S) { LValue CapStruct = InitCapturedStruct(*this, S); return CapStruct.getAddress(); } d1949 1 a1949 3 StartFunction(CD, Ctx.VoidTy, F, FuncInfo, Args, CD->getLocation(), CD->getBody()->getLocStart()); a1964 1 PGO.assignRegionCounters(CD, F); a1966 2 PGO.emitInstrumentationData(); PGO.destroyRegionCounters(); @ 1.1.1.6 log @Import Clang 3.5svn r209886. @ text @a22 1 #include "llvm/IR/CallSite.h" d26 1 d79 2 a176 6 case Stmt::OMPParallelDirectiveClass: EmitOMPParallelDirective(cast(*S)); break; case Stmt::OMPSimdDirectiveClass: EmitOMPSimdDirective(cast(*S)); break; d222 1 a222 1 llvm::Value *RetAlloca = nullptr; d314 3 a316 2 for (llvm::User *u : block->users()) { if (llvm::Instruction *insn = dyn_cast(u)) { d436 1 a436 1 LexicalScope ConditionScope(*this, S.getCond()->getSourceRange()); a511 2 LoopStack.push(LoopHeader.getBlock()); a574 2 LoopStack.pop(); a594 3 LoopStack.push(LoopBody); a624 2 LoopStack.pop(); a655 2 LoopStack.push(CondBlock); a725 2 LoopStack.pop(); a750 2 LoopStack.push(CondBlock); a799 2 LoopStack.pop(); d847 1 a847 1 } else if (!ReturnValue || (RV && RV->getType()->isVoidType())) { d852 1 a852 1 } else if (!RV) { d882 1 a882 1 if (!RV || RV->isEvaluatable(getContext())) d895 3 a897 2 for (const auto *I : S.decls()) EmitDecl(*I); d987 1 a987 1 llvm::MDNode *Weights = nullptr; d1071 1 a1071 1 while (NextCase && NextCase->getRHS() == nullptr) { d1132 1 a1132 1 if (!S) d1140 1 a1140 1 return CollectStatementsForCase(SC->getSubStmt(), nullptr, FoundCase, d1151 1 a1151 1 if (!Case && isa(S)) d1196 1 a1196 1 Case = nullptr; d1210 1 a1210 1 switch (CollectStatementsForCase(*I, nullptr, FoundCase, ResultStmts)) { d1261 1 a1261 1 const DefaultStmt *DefaultCase = nullptr; d1283 1 a1283 1 if (!Case) { d1286 1 a1286 1 if (!DefaultCase) d1307 7 d1324 1 a1324 1 const SwitchCase *Case = nullptr; a1332 5 // Emit the condition variable if needed inside the entire cleanup scope // used by this special case for constant folded switches. if (S.getConditionVariable()) EmitAutoVarDecl(*S.getConditionVariable()); d1336 1 a1336 1 SwitchInsn = nullptr; a1352 5 JumpDest SwitchExit = getJumpDestInCurrentScope("sw.epilog"); RunCleanupsScope ConditionScope(*this); if (S.getConditionVariable()) EmitAutoVarDecl(*S.getConditionVariable()); d1437 1 a1437 1 SmallVectorImpl *OutCons=nullptr) { a1922 6 llvm::Value * CodeGenFunction::GenerateCapturedStmtArgument(const CapturedStmt &S) { LValue CapStruct = InitCapturedStruct(*this, S); return CapStruct.getAddress(); } d1949 1 a1949 3 StartFunction(CD, Ctx.VoidTy, F, FuncInfo, Args, CD->getLocation(), CD->getBody()->getLocStart()); a1964 1 PGO.assignRegionCounters(CD, F); a1966 2 PGO.emitInstrumentationData(); PGO.destroyRegionCounters(); @ 1.1.1.7 log @Import clang 3.6svn r215315. @ text @a20 1 #include "clang/Sema/LoopHint.h" a174 3 case Stmt::SEHLeaveStmtClass: EmitSEHLeaveStmt(cast(*S)); break; a180 45 case Stmt::OMPForDirectiveClass: EmitOMPForDirective(cast(*S)); break; case Stmt::OMPSectionsDirectiveClass: EmitOMPSectionsDirective(cast(*S)); break; case Stmt::OMPSectionDirectiveClass: EmitOMPSectionDirective(cast(*S)); break; case Stmt::OMPSingleDirectiveClass: EmitOMPSingleDirective(cast(*S)); break; case Stmt::OMPMasterDirectiveClass: EmitOMPMasterDirective(cast(*S)); break; case Stmt::OMPCriticalDirectiveClass: EmitOMPCriticalDirective(cast(*S)); break; case Stmt::OMPParallelForDirectiveClass: EmitOMPParallelForDirective(cast(*S)); break; case Stmt::OMPParallelSectionsDirectiveClass: EmitOMPParallelSectionsDirective(cast(*S)); break; case Stmt::OMPTaskDirectiveClass: EmitOMPTaskDirective(cast(*S)); break; case Stmt::OMPTaskyieldDirectiveClass: EmitOMPTaskyieldDirective(cast(*S)); break; case Stmt::OMPBarrierDirectiveClass: EmitOMPBarrierDirective(cast(*S)); break; case Stmt::OMPTaskwaitDirectiveClass: EmitOMPTaskwaitDirective(cast(*S)); break; case Stmt::OMPFlushDirectiveClass: EmitOMPFlushDirective(cast(*S)); break; case Stmt::OMPOrderedDirectiveClass: EmitOMPOrderedDirective(cast(*S)); break; case Stmt::OMPAtomicDirectiveClass: EmitOMPAtomicDirective(cast(*S)); break; d401 1 a401 17 const Stmt *SubStmt = S.getSubStmt(); switch (SubStmt->getStmtClass()) { case Stmt::DoStmtClass: EmitDoStmt(cast(*SubStmt), S.getAttrs()); break; case Stmt::ForStmtClass: EmitForStmt(cast(*SubStmt), S.getAttrs()); break; case Stmt::WhileStmtClass: EmitWhileStmt(cast(*SubStmt), S.getAttrs()); break; case Stmt::CXXForRangeStmtClass: EmitCXXForRangeStmt(cast(*SubStmt), S.getAttrs()); break; default: EmitStmt(SubStmt); } d489 4 a492 5 { // There is no need to emit line number for unconditional branch. SuppressDebugLocation S(Builder); EmitBlock(ElseBlock); } d497 4 a500 5 { // There is no need to emit line number for unconditional branch. SuppressDebugLocation S(Builder); EmitBranch(ContBlock); } d507 1 a507 86 void CodeGenFunction::EmitCondBrHints(llvm::LLVMContext &Context, llvm::BranchInst *CondBr, const ArrayRef &Attrs) { // Return if there are no hints. if (Attrs.empty()) return; // Add vectorize and unroll hints to the metadata on the conditional branch. SmallVector Metadata(1); for (const auto *Attr : Attrs) { const LoopHintAttr *LH = dyn_cast(Attr); // Skip non loop hint attributes if (!LH) continue; LoopHintAttr::OptionType Option = LH->getOption(); LoopHintAttr::LoopHintState State = LH->getState(); int ValueInt = LH->getValue(); const char *MetadataName; switch (Option) { case LoopHintAttr::Vectorize: case LoopHintAttr::VectorizeWidth: MetadataName = "llvm.loop.vectorize.width"; break; case LoopHintAttr::Interleave: case LoopHintAttr::InterleaveCount: MetadataName = "llvm.loop.interleave.count"; break; case LoopHintAttr::Unroll: // With the unroll loop hint, a non-zero value indicates full unrolling. MetadataName = State == LoopHintAttr::Disable ? "llvm.loop.unroll.disable" : "llvm.loop.unroll.full"; break; case LoopHintAttr::UnrollCount: MetadataName = "llvm.loop.unroll.count"; break; } llvm::Value *Value; llvm::MDString *Name; switch (Option) { case LoopHintAttr::Vectorize: case LoopHintAttr::Interleave: if (State != LoopHintAttr::Disable) { // FIXME: In the future I will modifiy the behavior of the metadata // so we can enable/disable vectorization and interleaving separately. Name = llvm::MDString::get(Context, "llvm.loop.vectorize.enable"); Value = Builder.getTrue(); break; } // Vectorization/interleaving is disabled, set width/count to 1. ValueInt = 1; // Fallthrough. case LoopHintAttr::VectorizeWidth: case LoopHintAttr::InterleaveCount: case LoopHintAttr::UnrollCount: Name = llvm::MDString::get(Context, MetadataName); Value = llvm::ConstantInt::get(Int32Ty, ValueInt); break; case LoopHintAttr::Unroll: Name = llvm::MDString::get(Context, MetadataName); Value = nullptr; break; } SmallVector OpValues; OpValues.push_back(Name); if (Value) OpValues.push_back(Value); // Set or overwrite metadata indicated by Name. Metadata.push_back(llvm::MDNode::get(Context, OpValues)); } if (!Metadata.empty()) { // Add llvm.loop MDNode to CondBr. llvm::MDNode *LoopID = llvm::MDNode::get(Context, Metadata); LoopID->replaceOperandWith(0, LoopID); // First op points to itself. CondBr->setMetadata("llvm.loop", LoopID); } } void CodeGenFunction::EmitWhileStmt(const WhileStmt &S, const ArrayRef &WhileAttrs) { d554 2 a555 3 llvm::BranchInst *CondBr = Builder.CreateCondBr(BoolCondVal, LoopBody, ExitBlock, PGO.createLoopWeights(S.getCond(), Cnt)); a560 3 // Attach metadata to loop body conditional branch. EmitCondBrHints(LoopBody->getContext(), CondBr, WhileAttrs); d591 1 a591 2 void CodeGenFunction::EmitDoStmt(const DoStmt &S, const ArrayRef &DoAttrs) { d631 3 a633 8 if (EmitBoolCondBranch) { llvm::BranchInst *CondBr = Builder.CreateCondBr(BoolCondVal, LoopBody, LoopExit.getBlock(), PGO.createLoopWeights(S.getCond(), Cnt)); // Attach metadata to loop body conditional branch. EmitCondBrHints(LoopBody->getContext(), CondBr, DoAttrs); } d646 1 a646 2 void CodeGenFunction::EmitForStmt(const ForStmt &S, const ArrayRef &ForAttrs) { d702 2 a703 6 llvm::BranchInst *CondBr = Builder.CreateCondBr(BoolCondVal, ForBody, ExitBlock, PGO.createLoopWeights(S.getCond(), Cnt)); // Attach metadata to loop body conditional branch. EmitCondBrHints(ForBody->getContext(), CondBr, ForAttrs); d746 1 a746 3 void CodeGenFunction::EmitCXXForRangeStmt(const CXXForRangeStmt &S, const ArrayRef &ForAttrs) { d781 2 a782 5 llvm::BranchInst *CondBr = Builder.CreateCondBr( BoolCondVal, ForBody, ExitBlock, PGO.createLoopWeights(S.getCond(), Cnt)); // Attach metadata to loop body conditional branch. EmitCondBrHints(ForBody->getContext(), CondBr, ForAttrs); d1855 2 a1856 2 // call. if (const GCCAsmStmt *gccAsmStmt = dyn_cast(&S)) { a1858 5 } else { // At least put the line number on MS inline asm blobs. auto Loc = llvm::ConstantInt::get(Int32Ty, S.getAsmLoc().getRawEncoding()); Result->setMetadata("srcloc", llvm::MDNode::get(getLLVMContext(), Loc)); } a1922 16 static void InitVLACaptures(CodeGenFunction &CGF, const CapturedStmt &S) { for (auto &C : S.captures()) { if (C.capturesVariable()) { QualType QTy; auto VD = C.getCapturedVar(); if (const ParmVarDecl *PVD = dyn_cast(VD)) QTy = PVD->getOriginalType(); else QTy = VD->getType(); if (QTy->isVariablyModifiedType()) { CGF.EmitVariablyModifiedType(QTy); } } } } d1927 4 d1936 1 a1936 1 llvm::Function *F = CGF.GenerateCapturedStmtFunction(S); d1953 3 a1955 1 CodeGenFunction::GenerateCapturedStmtFunction(const CapturedStmt &S) { a1957 4 const CapturedDecl *CD = S.getCapturedDecl(); const RecordDecl *RD = S.getCapturedRecordDecl(); SourceLocation Loc = S.getLocStart(); assert(CD->hasBody() && "missing CapturedDecl body"); d1980 1 a1985 3 // Initialize variable-length arrays. InitVLACaptures(*this, S); @ 1.1.1.7.2.1 log @Update LLVM to 3.6.1, requested by joerg in ticket 824. @ text @a187 3 case Stmt::OMPForSimdDirectiveClass: EmitOMPForSimdDirective(cast(*S)); break; a205 3 case Stmt::OMPParallelForSimdDirectiveClass: EmitOMPParallelForSimdDirective(cast(*S)); break; a229 6 case Stmt::OMPTargetDirectiveClass: EmitOMPTargetDirective(cast(*S)); break; case Stmt::OMPTeamsDirectiveClass: EmitOMPTeamsDirective(cast(*S)); break; d556 1 a556 1 ApplyDebugLocation DL(*this); d565 1 a565 1 ApplyDebugLocation DL(*this); d576 1 a576 1 ArrayRef Attrs) { d582 1 a582 3 // // FIXME: Should this really start with a size of 1? SmallVector Metadata(1); d592 2 d613 1 a613 10 Expr *ValueExpr = LH->getValue(); int ValueInt = 1; if (ValueExpr) { llvm::APSInt ValueAPS = ValueExpr->EvaluateKnownConstInt(CGM.getContext()); ValueInt = static_cast(ValueAPS.getSExtValue()); } llvm::Constant *Value; d640 1 a640 1 SmallVector OpValues; d643 1 a643 1 OpValues.push_back(llvm::ConstantAsMetadata::get(Value)); a648 1 // FIXME: This condition is never false. Should it be an assert? d659 1 a659 1 ArrayRef WhileAttrs) { a732 1 EmitStopPoint(&S); d748 1 a748 1 ArrayRef DoAttrs) { d809 1 a809 1 ArrayRef ForAttrs) { d812 5 a816 1 LexicalScope ForScope(*this, S.getSourceRange()); d844 1 a844 1 LexicalScope ConditionScope(*this, S.getSourceRange()); a899 2 EmitStopPoint(&S); d904 3 d915 1 a915 1 ArrayRef ForAttrs) { d918 5 a922 1 LexicalScope ForScope(*this, S.getSourceRange()); d972 1 a972 1 LexicalScope BodyScope(*this, S.getSourceRange()); a976 1 EmitStopPoint(&S); d987 3 a1649 6 case '&': case '%': Result += *Constraint; while (Constraint[1] && Constraint[1] == *Constraint) Constraint++; break; d1760 1 a1760 1 SmallVector Locs; d1762 2 a1763 2 Locs.push_back(llvm::ConstantAsMetadata::get(llvm::ConstantInt::get( CGF.Int32Ty, Str->getLocStart().getRawEncoding()))); d1775 2 a1776 2 Locs.push_back(llvm::ConstantAsMetadata::get( llvm::ConstantInt::get(CGF.Int32Ty, LineLoc.getRawEncoding()))); d1914 1 a1914 13 // If this is a Microsoft-style asm blob, store the return registers (EAX:EDX) // to the return value slot. Only do this when returning in registers. if (isa(&S)) { const ABIArgInfo &RetAI = CurFnInfo->getReturnInfo(); if (RetAI.isDirect() || RetAI.isExtend()) { // Make a fake lvalue for the return value slot. LValue ReturnSlot = MakeAddrLValue(ReturnValue, FnRetTy); CGM.getTargetCodeGenInfo().addReturnRegisterOutputs( *this, ReturnSlot, Constraints, ResultRegTypes, ResultTruncRegTypes, ResultRegDests, AsmString, S.getNumOutputs()); SawAsmBlock = true; } } d1987 1 a1987 1 Clobber = getTarget().getNormalizedGCCRegisterName(Clobber); d1989 1 a1989 1 if (!Constraints.empty()) d2034 1 a2034 3 Result->setMetadata("srcloc", llvm::MDNode::get(getLLVMContext(), llvm::ConstantAsMetadata::get(Loc))); a2047 3 assert(RegResults.size() == ResultRegTypes.size()); assert(RegResults.size() == ResultTruncRegTypes.size()); assert(RegResults.size() == ResultRegDests.size()); d2081 1 a2081 1 LValue CodeGenFunction::InitCapturedStruct(const CapturedStmt &S) { d2083 1 a2083 1 QualType RecordTy = getContext().getRecordType(RD); d2086 2 a2087 2 LValue SlotLV = MakeNaturalAlignAddrLValue( CreateMemTemp(RecordTy, "agg.captured"), RecordTy); d2093 2 a2094 7 LValue LV = EmitLValueForFieldInitialization(SlotLV, *CurField); if (CurField->hasCapturedVLAType()) { auto VAT = CurField->getCapturedVLAType(); EmitStoreThroughLValue(RValue::get(VLASizeMap[VAT->getSizeExpr()]), LV); } else { EmitInitializerForField(*CurField, LV, *I, None); } d2100 16 d2120 1 a2120 1 LValue CapStruct = InitCapturedStruct(S); d2136 1 a2136 1 LValue CapStruct = InitCapturedStruct(S); d2177 1 a2177 10 LValue Base = MakeNaturalAlignAddrLValue(CapturedStmtInfo->getContextValue(), Ctx.getTagDeclType(RD)); for (auto *FD : RD->fields()) { if (FD->hasCapturedVLAType()) { auto *ExprArg = EmitLoadOfLValue(EmitLValueForField(Base, FD), S.getLocStart()).getScalarVal(); auto VAT = FD->getCapturedVLAType(); VLASizeMap[VAT->getSizeExpr()] = ExprArg; } } d2182 3 a2184 1 LValue ThisLValue = EmitLValueForField(Base, FD); d2191 2 @ 1.1.1.8 log @Import Clang 3.6RC1 r227398. @ text @a187 3 case Stmt::OMPForSimdDirectiveClass: EmitOMPForSimdDirective(cast(*S)); break; a205 3 case Stmt::OMPParallelForSimdDirectiveClass: EmitOMPParallelForSimdDirective(cast(*S)); break; a229 6 case Stmt::OMPTargetDirectiveClass: EmitOMPTargetDirective(cast(*S)); break; case Stmt::OMPTeamsDirectiveClass: EmitOMPTeamsDirective(cast(*S)); break; d556 1 a556 1 ApplyDebugLocation DL(*this); d565 1 a565 1 ApplyDebugLocation DL(*this); d576 1 a576 1 ArrayRef Attrs) { d582 1 a582 3 // // FIXME: Should this really start with a size of 1? SmallVector Metadata(1); d592 2 d613 1 a613 10 Expr *ValueExpr = LH->getValue(); int ValueInt = 1; if (ValueExpr) { llvm::APSInt ValueAPS = ValueExpr->EvaluateKnownConstInt(CGM.getContext()); ValueInt = static_cast(ValueAPS.getSExtValue()); } llvm::Constant *Value; d640 1 a640 1 SmallVector OpValues; d643 1 a643 1 OpValues.push_back(llvm::ConstantAsMetadata::get(Value)); a648 1 // FIXME: This condition is never false. Should it be an assert? d659 1 a659 1 ArrayRef WhileAttrs) { a732 1 EmitStopPoint(&S); d748 1 a748 1 ArrayRef DoAttrs) { d809 1 a809 1 ArrayRef ForAttrs) { d812 5 a816 1 LexicalScope ForScope(*this, S.getSourceRange()); d844 1 a844 1 LexicalScope ConditionScope(*this, S.getSourceRange()); a899 2 EmitStopPoint(&S); d904 3 d915 1 a915 1 ArrayRef ForAttrs) { d918 5 a922 1 LexicalScope ForScope(*this, S.getSourceRange()); d972 1 a972 1 LexicalScope BodyScope(*this, S.getSourceRange()); a976 1 EmitStopPoint(&S); d987 3 a1649 6 case '&': case '%': Result += *Constraint; while (Constraint[1] && Constraint[1] == *Constraint) Constraint++; break; d1760 1 a1760 1 SmallVector Locs; d1762 2 a1763 2 Locs.push_back(llvm::ConstantAsMetadata::get(llvm::ConstantInt::get( CGF.Int32Ty, Str->getLocStart().getRawEncoding()))); d1775 2 a1776 2 Locs.push_back(llvm::ConstantAsMetadata::get( llvm::ConstantInt::get(CGF.Int32Ty, LineLoc.getRawEncoding()))); d1914 1 a1914 13 // If this is a Microsoft-style asm blob, store the return registers (EAX:EDX) // to the return value slot. Only do this when returning in registers. if (isa(&S)) { const ABIArgInfo &RetAI = CurFnInfo->getReturnInfo(); if (RetAI.isDirect() || RetAI.isExtend()) { // Make a fake lvalue for the return value slot. LValue ReturnSlot = MakeAddrLValue(ReturnValue, FnRetTy); CGM.getTargetCodeGenInfo().addReturnRegisterOutputs( *this, ReturnSlot, Constraints, ResultRegTypes, ResultTruncRegTypes, ResultRegDests, AsmString, S.getNumOutputs()); SawAsmBlock = true; } } d1987 1 a1987 1 Clobber = getTarget().getNormalizedGCCRegisterName(Clobber); d1989 1 a1989 1 if (!Constraints.empty()) d2034 1 a2034 3 Result->setMetadata("srcloc", llvm::MDNode::get(getLLVMContext(), llvm::ConstantAsMetadata::get(Loc))); a2047 3 assert(RegResults.size() == ResultRegTypes.size()); assert(RegResults.size() == ResultTruncRegTypes.size()); assert(RegResults.size() == ResultRegDests.size()); d2081 1 a2081 1 LValue CodeGenFunction::InitCapturedStruct(const CapturedStmt &S) { d2083 1 a2083 1 QualType RecordTy = getContext().getRecordType(RD); d2086 2 a2087 2 LValue SlotLV = MakeNaturalAlignAddrLValue( CreateMemTemp(RecordTy, "agg.captured"), RecordTy); d2093 2 a2094 7 LValue LV = EmitLValueForFieldInitialization(SlotLV, *CurField); if (CurField->hasCapturedVLAType()) { auto VAT = CurField->getCapturedVLAType(); EmitStoreThroughLValue(RValue::get(VLASizeMap[VAT->getSizeExpr()]), LV); } else { EmitInitializerForField(*CurField, LV, *I, None); } d2100 16 d2120 1 a2120 1 LValue CapStruct = InitCapturedStruct(S); d2136 1 a2136 1 LValue CapStruct = InitCapturedStruct(S); d2177 1 a2177 10 LValue Base = MakeNaturalAlignAddrLValue(CapturedStmtInfo->getContextValue(), Ctx.getTagDeclType(RD)); for (auto *FD : RD->fields()) { if (FD->hasCapturedVLAType()) { auto *ExprArg = EmitLoadOfLValue(EmitLValueForField(Base, FD), S.getLocStart()).getScalarVal(); auto VAT = FD->getCapturedVLAType(); VLASizeMap[VAT->getSizeExpr()] = ExprArg; } } d2182 3 a2184 1 LValue ThisLValue = EmitLValueForField(Base, FD); d2191 2 @ 1.1.1.9 log @Import Clang 3.8.0rc3 r261930. @ text @a18 1 #include "clang/Basic/Builtins.h" a27 2 #include "llvm/IR/MDBuilder.h" a90 1 case Stmt::SEHLeaveStmtClass: a139 4 case Stmt::CoroutineBodyStmtClass: case Stmt::CoreturnStmtClass: CGM.ErrorUnsupported(S, "coroutine"); break; d176 3 a226 3 case Stmt::OMPTaskgroupDirectiveClass: EmitOMPTaskgroupDirective(cast(*S)); break; a241 18 case Stmt::OMPCancellationPointDirectiveClass: EmitOMPCancellationPointDirective(cast(*S)); break; case Stmt::OMPCancelDirectiveClass: EmitOMPCancelDirective(cast(*S)); break; case Stmt::OMPTargetDataDirectiveClass: EmitOMPTargetDataDirective(cast(*S)); break; case Stmt::OMPTaskLoopDirectiveClass: EmitOMPTaskLoopDirective(cast(*S)); break; case Stmt::OMPTaskLoopSimdDirectiveClass: EmitOMPTaskLoopSimdDirective(cast(*S)); break; case Stmt::OMPDistributeDirectiveClass: EmitOMPDistributeDirective(cast(*S)); break; a258 1 case Stmt::SEHLeaveStmtClass: EmitSEHLeaveStmt(cast(*S)); break; d267 2 a268 2 Address CodeGenFunction::EmitCompoundStmt(const CompoundStmt &S, bool GetLast, AggValueSlot AggSlot) { d278 1 a278 1 Address d287 1 a287 1 Address RetAlloca = Address::invalid(); d332 1 a332 1 if (BI->getIterator() != BB->begin()) d354 1 a354 1 CurFn->getBasicBlockList().insertAfter(CurBB->getIterator(), BB); d381 1 a381 2 CurFn->getBasicBlockList().insertAfter(insn->getParent()->getIterator(), block); d427 1 d429 1 a429 1 incrementProfileCounter(D->getStmt()); d517 1 d536 1 a536 1 incrementProfileCounter(&S); d553 1 a553 2 EmitBranchOnBoolExpr(S.getCond(), ThenBlock, ElseBlock, getProfileCount(S.getThen())); d557 1 a557 1 incrementProfileCounter(&S); d567 2 a568 2 // There is no need to emit line number for an unconditional branch. auto NL = ApplyDebugLocation::CreateEmpty(*this); d576 2 a577 2 // There is no need to emit line number for an unconditional branch. auto NL = ApplyDebugLocation::CreateEmpty(*this); d586 94 d682 2 d689 1 a689 1 LoopStack.push(LoopHeader.getBlock(), CGM.getContext(), WhileAttrs); d728 3 a730 3 Builder.CreateCondBr( BoolCondVal, LoopBody, ExitBlock, createProfileWeightsForLoop(S.getCond(), getProfileCount(S.getBody()))); d736 3 d746 1 a746 1 incrementProfileCounter(&S); d775 1 a775 1 uint64_t ParentCount = getCurrentProfileCount(); d783 1 a783 1 LoopStack.push(LoopBody, CGM.getContext(), DoAttrs); d785 1 a785 1 EmitBlockWithFallThrough(LoopBody, &S); d812 6 a817 4 uint64_t BackedgeCount = getProfileCount(S.getBody()) - ParentCount; Builder.CreateCondBr( BoolCondVal, LoopBody, LoopExit.getBlock(), createProfileWeightsForLoop(S.getCond(), BackedgeCount)); d841 2 d850 1 a850 1 LoopStack.push(CondBlock, CGM.getContext(), ForAttrs); d884 6 a889 3 Builder.CreateCondBr( BoolCondVal, ForBody, ExitBlock, createProfileWeightsForLoop(S.getCond(), getProfileCount(S.getBody()))); d901 1 a901 1 incrementProfileCounter(&S); d942 2 d950 1 a950 1 LoopStack.push(CondBlock, CGM.getContext(), ForAttrs); d964 5 a968 3 Builder.CreateCondBr( BoolCondVal, ForBody, ExitBlock, createProfileWeightsForLoop(S.getCond(), getProfileCount(S.getBody()))); d976 1 a976 1 incrementProfileCounter(&S); d1012 1 a1012 1 EmitAggregateCopy(ReturnValue, RV.getAggregateAddress(), Ty); d1014 2 a1015 1 EmitStoreOfComplex(RV.getComplexVal(), MakeAddrLValue(ReturnValue, Ty), a1024 6 // Returning from an outlined SEH helper is UB, and we already warn on it. if (IsOutlinedSEHHelper) { Builder.CreateUnreachable(); Builder.ClearInsertionPoint(); } d1050 2 a1051 2 Builder.CreateFlagStore(Builder.getTrue(), NRVOFlag); } else if (!ReturnValue.isValid() || (RV && RV->getType()->isVoidType())) { d1069 2 a1070 1 EmitComplexExprIntoLValue(RV, MakeAddrLValue(ReturnValue, RV->getType()), d1073 3 a1075 2 case TEK_Aggregate: EmitAggExpr(RV, AggValueSlot::forAddr(ReturnValue, d1082 1 d1136 2 d1142 1 a1142 1 EmitBlockWithFallThrough(CaseDest, &S); d1153 1 a1153 1 uint64_t Total = getProfileCount(&S); d1192 1 a1192 1 uint64_t ThisCount = getProfileCount(&S); d1194 1 a1194 1 Weights = createProfileWeights(ThisCount, DefaultCount); d1227 1 d1242 1 a1242 1 SwitchWeights->push_back(getProfileCount(&S)); d1256 1 a1256 1 EmitBlockWithFallThrough(CaseDest, &S); d1258 1 a1258 1 SwitchWeights->push_back(getProfileCount(&S)); d1279 1 d1281 1 a1281 1 SwitchWeights->push_back(getProfileCount(NextCase)); d1284 1 a1284 1 EmitBlockWithFallThrough(CaseDest, &S); d1300 2 a1301 1 EmitBlockWithFallThrough(DefaultBlock, &S); d1523 4 a1526 2 if (Case) incrementProfileCounter(Case); d1543 2 a1544 1 incrementProfileCounter(&S); d1575 1 a1575 1 DefaultCount = getProfileCount(Case); d1624 2 a1625 17 incrementProfileCounter(&S); // If the switch has a condition wrapped by __builtin_unpredictable, // create metadata that specifies that the switch is unpredictable. // Don't bother if not optimizing because that metadata would not be used. if (CGM.getCodeGenOpts().OptimizationLevel != 0) { if (const CallExpr *Call = dyn_cast(S.getCond())) { const Decl *TargetDecl = Call->getCalleeDecl(); if (const FunctionDecl *FD = dyn_cast_or_null(TargetDecl)) { if (FD->getBuiltinID() == Builtin::BI__builtin_unpredictable) { llvm::MDBuilder MDHelper(getLLVMContext()); SwitchInsn->setMetadata(llvm::LLVMContext::MD_unpredictable, MDHelper.createUnpredictable()); } } } } d1633 1 a1633 1 createProfileWeights(*SwitchWeights)); d1678 3 a1680 1 bool result = Target.resolveSymbolicName(Constraint, *OutCons, Index); d1699 1 a1699 1 const AsmStmt &Stmt, const bool EarlyClobber) { d1724 1 a1724 1 return (EarlyClobber ? "&{" : "{") + Register.str() + "}"; d1746 1 a1746 1 Arg = InputValue.getPointer(); d1751 1 a1751 1 Arg = InputValue.getPointer(); a1761 10 // If this can't be a register or memory, i.e., has to be a constant // (immediate or symbolic), try to emit it as such. if (!Info.allowsRegister() && !Info.allowsMemory()) { llvm::APSInt Result; if (InputExpr->EvaluateAsInt(Result, getContext())) return llvm::ConstantInt::get(getLLVMContext(), Result); assert(!Info.requiresImmediateConstant() && "Required-immediate inlineasm arg isn't constant?"); } d1765 1 a1765 2 if (InputExpr->getStmtClass() == Expr::CXXThisExprClass) return EmitScalarExpr(InputExpr); a1785 2 unsigned StartToken = 0; unsigned ByteOffset = 0; d1789 1 a1789 1 for (unsigned i = 0, e = StrVal.size() - 1; i != e; ++i) { d1791 2 a1792 2 SourceLocation LineLoc = Str->getLocationOfByte( i + 1, SM, LangOpts, CGF.getTarget(), &StartToken, &ByteOffset); d1825 2 a1826 1 getTarget().validateInputConstraint(OutputConstraintInfos, Info); a1844 8 // An inline asm can be marked readonly if it meets the following conditions: // - it doesn't have any sideeffects // - it doesn't clobber memory // - it doesn't return a value by-reference // It can be marked readnone if it doesn't have any input memory constraints // in addition to meeting the conditions listed above. bool ReadOnly = true, ReadNone = true; d1857 1 a1857 2 getTarget(), CGM, S, Info.earlyClobber()); d1903 2 a1904 2 ArgTypes.push_back(Dest.getAddress().getType()); Args.push_back(Dest.getPointer()); a1906 1 ReadOnly = ReadNone = false; a1950 3 if (Info.allowsMemory()) ReadNone = false; d1959 4 a1962 3 InputConstraint = AddVariableConstraints( InputConstraint, *InputExpr->IgnoreParenNoopCasts(getContext()), getTarget(), CGM, S, false /* No EarlyClobber */); d2016 1 a2016 3 if (Clobber == "memory") ReadOnly = ReadNone = false; else if (Clobber != "cc") a2055 19 if (isa(&S)) { // If the assembly contains any labels, mark the call noduplicate to prevent // defining the same ASM label twice (PR23715). This is pretty hacky, but it // works. if (AsmString.find("__MSASMLABEL_") != std::string::npos) Result->addAttribute(llvm::AttributeSet::FunctionIndex, llvm::Attribute::NoDuplicate); } // Attach readnone and readonly attributes. if (!HasSideEffect) { if (ReadNone) Result->addAttribute(llvm::AttributeSet::FunctionIndex, llvm::Attribute::ReadNone); else if (ReadOnly) Result->addAttribute(llvm::AttributeSet::FunctionIndex, llvm::Attribute::ReadOnly); } d2121 2 a2122 2 LValue SlotLV = MakeAddrLValue(CreateMemTemp(RecordTy, "agg.captured"), RecordTy); d2125 2 a2126 2 for (CapturedStmt::const_capture_init_iterator I = S.capture_init_begin(), E = S.capture_init_end(); d2148 1 a2148 1 CGCapturedStmtRAII CapInfoRAII(CGF, new CGCapturedStmtInfo(S, K)); d2153 1 a2153 1 EmitCallOrInvoke(F, CapStruct.getPointer()); d2158 2 a2159 1 Address CodeGenFunction::GenerateCapturedStmtArgument(const CapturedStmt &S) { a2189 2 if (CD->isNothrow()) F->addFnAttr(llvm::Attribute::NoUnwind); d2196 2 a2197 1 Address DeclPtr = GetAddrOfLocalVar(CD->getContextParam()); d2219 1 a2219 1 PGO.assignRegionCounters(GlobalDecl(CD), F); @ 1.1.1.9.2.1 log @Sync with HEAD @ text @a144 2 EmitCoroutineBody(cast(*S)); break; a258 12 case Stmt::OMPTargetEnterDataDirectiveClass: EmitOMPTargetEnterDataDirective(cast(*S)); break; case Stmt::OMPTargetExitDataDirectiveClass: EmitOMPTargetExitDataDirective(cast(*S)); break; case Stmt::OMPTargetParallelDirectiveClass: EmitOMPTargetParallelDirective(cast(*S)); break; case Stmt::OMPTargetParallelForDirectiveClass: EmitOMPTargetParallelForDirective(cast(*S)); break; d265 1 a265 1 case Stmt::OMPDistributeDirectiveClass: d267 1 a267 56 break; case Stmt::OMPTargetUpdateDirectiveClass: EmitOMPTargetUpdateDirective(cast(*S)); break; case Stmt::OMPDistributeParallelForDirectiveClass: EmitOMPDistributeParallelForDirective( cast(*S)); break; case Stmt::OMPDistributeParallelForSimdDirectiveClass: EmitOMPDistributeParallelForSimdDirective( cast(*S)); break; case Stmt::OMPDistributeSimdDirectiveClass: EmitOMPDistributeSimdDirective(cast(*S)); break; case Stmt::OMPTargetParallelForSimdDirectiveClass: EmitOMPTargetParallelForSimdDirective( cast(*S)); break; case Stmt::OMPTargetSimdDirectiveClass: EmitOMPTargetSimdDirective(cast(*S)); break; case Stmt::OMPTeamsDistributeDirectiveClass: EmitOMPTeamsDistributeDirective(cast(*S)); break; case Stmt::OMPTeamsDistributeSimdDirectiveClass: EmitOMPTeamsDistributeSimdDirective( cast(*S)); break; case Stmt::OMPTeamsDistributeParallelForSimdDirectiveClass: EmitOMPTeamsDistributeParallelForSimdDirective( cast(*S)); break; case Stmt::OMPTeamsDistributeParallelForDirectiveClass: EmitOMPTeamsDistributeParallelForDirective( cast(*S)); break; case Stmt::OMPTargetTeamsDirectiveClass: EmitOMPTargetTeamsDirective(cast(*S)); break; case Stmt::OMPTargetTeamsDistributeDirectiveClass: EmitOMPTargetTeamsDistributeDirective( cast(*S)); break; case Stmt::OMPTargetTeamsDistributeParallelForDirectiveClass: EmitOMPTargetTeamsDistributeParallelForDirective( cast(*S)); break; case Stmt::OMPTargetTeamsDistributeParallelForSimdDirectiveClass: EmitOMPTargetTeamsDistributeParallelForSimdDirective( cast(*S)); break; case Stmt::OMPTargetTeamsDistributeSimdDirectiveClass: EmitOMPTargetTeamsDistributeSimdDirective( cast(*S)); break; a544 3 if (S.getInit()) EmitStmt(S.getInit()); d551 1 a551 2 if (ConstantFoldsToSimpleInteger(S.getCond(), CondConstant, S.isConstexpr())) { d560 1 a560 1 if (S.isConstexpr() || !ContainsLabel(Skipped)) { d620 1 a620 4 const SourceRange &R = S.getSourceRange(); LoopStack.push(LoopHeader.getBlock(), CGM.getContext(), WhileAttrs, SourceLocToDebugLoc(R.getBegin()), SourceLocToDebugLoc(R.getEnd())); d711 1 a711 4 const SourceRange &R = S.getSourceRange(); LoopStack.push(LoopBody, CGM.getContext(), DoAttrs, SourceLocToDebugLoc(R.getBegin()), SourceLocToDebugLoc(R.getEnd())); d774 1 a774 4 const SourceRange &R = S.getSourceRange(); LoopStack.push(CondBlock, CGM.getContext(), ForAttrs, SourceLocToDebugLoc(R.getBegin()), SourceLocToDebugLoc(R.getEnd())); d861 1 a861 2 EmitStmt(S.getBeginStmt()); EmitStmt(S.getEndStmt()); d869 1 a869 4 const SourceRange &R = S.getSourceRange(); LoopStack.push(CondBlock, CGM.getContext(), ForAttrs, SourceLocToDebugLoc(R.getBegin()), SourceLocToDebugLoc(R.getEnd())); d1150 1 a1150 1 if (!CGM.getCodeGenOpts().hasProfileClangInstr() && d1197 1 a1197 1 if (CGM.getCodeGenOpts().hasProfileClangInstr()) { a1210 8 // If there is no enclosing switch instance that we're aware of, then this // default statement can be elided. This situation only happens when we've // constant-folded the switch. if (!SwitchInsn) { EmitStmt(S.getSubStmt()); return; } a1276 4 bool StartedInLiveCode = FoundCase; unsigned StartSize = ResultStmts.size(); // If we've not found the case yet, scan through looking for it. d1286 1 a1286 1 HadSkippedDecl |= CodeGenFunction::mightAddDeclToScope(*I); a1321 5 if (!FoundCase) return CSFC_Success; assert(!HadSkippedDecl && "fallthrough after skipping decl"); a1325 1 bool AnyDecls = false; a1326 2 AnyDecls |= CodeGenFunction::mightAddDeclToScope(*I); d1344 1 a1344 18 // If we're about to fall out of a scope without hitting a 'break;', we // can't perform the optimization if there were any decls in that scope // (we'd lose their end-of-lifetime). if (AnyDecls) { // If the entire compound statement was live, there's one more thing we // can try before giving up: emit the whole thing as a single statement. // We can do that unless the statement contains a 'break;'. // FIXME: Such a break must be at the end of a construct within this one. // We could emit this by just ignoring the BreakStmts entirely. if (StartedInLiveCode && !CodeGenFunction::containsBreak(S)) { ResultStmts.resize(StartSize); ResultStmts.push_back(S); } else { return CSFC_Failure; } } return CSFC_FallThrough; a1440 3 if (S.getInit()) EmitStmt(S.getInit()); a1467 4 if (S.getInit()) EmitStmt(S.getInit()); d1540 10 a1549 7 auto *Call = dyn_cast(S.getCond()); if (Call && CGM.getCodeGenOpts().OptimizationLevel != 0) { auto *FD = dyn_cast_or_null(Call->getCalleeDecl()); if (FD && FD->getBuiltinID() == Builtin::BI__builtin_unpredictable) { llvm::MDBuilder MDHelper(getLLVMContext()); SwitchInsn->setMetadata(llvm::LLVMContext::MD_unpredictable, MDHelper.createUnpredictable()); d2006 9 a2037 8 if (getLangOpts().CUDA && getLangOpts().CUDAIsDevice) { // Conservatively, mark all inline asm blocks in CUDA as convergent // (meaning, they may call an intrinsically convergent op, such as bar.sync, // and so can't have certain optimizations applied around them). Result->addAttribute(llvm::AttributeSet::FunctionIndex, llvm::Attribute::Convergent); } d2102 1 a2102 1 EmitInitializerForField(*CurField, LV, *I); d2150 2 a2151 1 CGM.getTypes().arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Args); @ 1.1.1.10 log @Import Clang pre-4.0.0 r291444. @ text @a144 2 EmitCoroutineBody(cast(*S)); break; a258 12 case Stmt::OMPTargetEnterDataDirectiveClass: EmitOMPTargetEnterDataDirective(cast(*S)); break; case Stmt::OMPTargetExitDataDirectiveClass: EmitOMPTargetExitDataDirective(cast(*S)); break; case Stmt::OMPTargetParallelDirectiveClass: EmitOMPTargetParallelDirective(cast(*S)); break; case Stmt::OMPTargetParallelForDirectiveClass: EmitOMPTargetParallelForDirective(cast(*S)); break; d265 1 a265 1 case Stmt::OMPDistributeDirectiveClass: d267 1 a267 52 break; case Stmt::OMPTargetUpdateDirectiveClass: EmitOMPTargetUpdateDirective(cast(*S)); break; case Stmt::OMPDistributeParallelForDirectiveClass: EmitOMPDistributeParallelForDirective( cast(*S)); break; case Stmt::OMPDistributeParallelForSimdDirectiveClass: EmitOMPDistributeParallelForSimdDirective( cast(*S)); break; case Stmt::OMPDistributeSimdDirectiveClass: EmitOMPDistributeSimdDirective(cast(*S)); break; case Stmt::OMPTargetParallelForSimdDirectiveClass: EmitOMPTargetParallelForSimdDirective( cast(*S)); break; case Stmt::OMPTargetSimdDirectiveClass: EmitOMPTargetSimdDirective(cast(*S)); break; case Stmt::OMPTeamsDistributeDirectiveClass: EmitOMPTeamsDistributeDirective(cast(*S)); break; case Stmt::OMPTeamsDistributeSimdDirectiveClass: EmitOMPTeamsDistributeSimdDirective( cast(*S)); break; case Stmt::OMPTeamsDistributeParallelForSimdDirectiveClass: EmitOMPTeamsDistributeParallelForSimdDirective( cast(*S)); break; case Stmt::OMPTeamsDistributeParallelForDirectiveClass: EmitOMPTeamsDistributeParallelForDirective( cast(*S)); break; case Stmt::OMPTargetTeamsDirectiveClass: EmitOMPTargetTeamsDirective(cast(*S)); break; case Stmt::OMPTargetTeamsDistributeDirectiveClass: EmitOMPTargetTeamsDistributeDirective( cast(*S)); break; case Stmt::OMPTargetTeamsDistributeParallelForDirectiveClass: EmitOMPTargetTeamsDistributeParallelForDirective( cast(*S)); break; case Stmt::OMPTargetTeamsDistributeParallelForSimdDirectiveClass: EmitOMPTargetTeamsDistributeParallelForSimdDirective( cast(*S)); break; a544 3 if (S.getInit()) EmitStmt(S.getInit()); d551 1 a551 2 if (ConstantFoldsToSimpleInteger(S.getCond(), CondConstant, S.isConstexpr())) { d560 1 a560 1 if (S.isConstexpr() || !ContainsLabel(Skipped)) { d620 1 a620 4 const SourceRange &R = S.getSourceRange(); LoopStack.push(LoopHeader.getBlock(), CGM.getContext(), WhileAttrs, SourceLocToDebugLoc(R.getBegin()), SourceLocToDebugLoc(R.getEnd())); d711 1 a711 4 const SourceRange &R = S.getSourceRange(); LoopStack.push(LoopBody, CGM.getContext(), DoAttrs, SourceLocToDebugLoc(R.getBegin()), SourceLocToDebugLoc(R.getEnd())); d774 1 a774 4 const SourceRange &R = S.getSourceRange(); LoopStack.push(CondBlock, CGM.getContext(), ForAttrs, SourceLocToDebugLoc(R.getBegin()), SourceLocToDebugLoc(R.getEnd())); d861 1 a861 2 EmitStmt(S.getBeginStmt()); EmitStmt(S.getEndStmt()); d869 1 a869 4 const SourceRange &R = S.getSourceRange(); LoopStack.push(CondBlock, CGM.getContext(), ForAttrs, SourceLocToDebugLoc(R.getBegin()), SourceLocToDebugLoc(R.getEnd())); d1150 1 a1150 1 if (!CGM.getCodeGenOpts().hasProfileClangInstr() && d1197 1 a1197 1 if (CGM.getCodeGenOpts().hasProfileClangInstr()) { a1210 8 // If there is no enclosing switch instance that we're aware of, then this // default statement can be elided. This situation only happens when we've // constant-folded the switch. if (!SwitchInsn) { EmitStmt(S.getSubStmt()); return; } a1276 4 bool StartedInLiveCode = FoundCase; unsigned StartSize = ResultStmts.size(); // If we've not found the case yet, scan through looking for it. d1286 1 a1286 1 HadSkippedDecl |= CodeGenFunction::mightAddDeclToScope(*I); a1321 5 if (!FoundCase) return CSFC_Success; assert(!HadSkippedDecl && "fallthrough after skipping decl"); a1325 1 bool AnyDecls = false; a1326 2 AnyDecls |= CodeGenFunction::mightAddDeclToScope(*I); d1344 1 a1344 18 // If we're about to fall out of a scope without hitting a 'break;', we // can't perform the optimization if there were any decls in that scope // (we'd lose their end-of-lifetime). if (AnyDecls) { // If the entire compound statement was live, there's one more thing we // can try before giving up: emit the whole thing as a single statement. // We can do that unless the statement contains a 'break;'. // FIXME: Such a break must be at the end of a construct within this one. // We could emit this by just ignoring the BreakStmts entirely. if (StartedInLiveCode && !CodeGenFunction::containsBreak(S)) { ResultStmts.resize(StartSize); ResultStmts.push_back(S); } else { return CSFC_Failure; } } return CSFC_FallThrough; a1440 3 if (S.getInit()) EmitStmt(S.getInit()); a1467 4 if (S.getInit()) EmitStmt(S.getInit()); d1540 10 a1549 7 auto *Call = dyn_cast(S.getCond()); if (Call && CGM.getCodeGenOpts().OptimizationLevel != 0) { auto *FD = dyn_cast_or_null(Call->getCalleeDecl()); if (FD && FD->getBuiltinID() == Builtin::BI__builtin_unpredictable) { llvm::MDBuilder MDHelper(getLLVMContext()); SwitchInsn->setMetadata(llvm::LLVMContext::MD_unpredictable, MDHelper.createUnpredictable()); d2006 9 a2037 8 if (getLangOpts().CUDA && getLangOpts().CUDAIsDevice) { // Conservatively, mark all inline asm blocks in CUDA as convergent // (meaning, they may call an intrinsically convergent op, such as bar.sync, // and so can't have certain optimizations applied around them). Result->addAttribute(llvm::AttributeSet::FunctionIndex, llvm::Attribute::Convergent); } d2102 1 a2102 1 EmitInitializerForField(*CurField, LV, *I); d2150 2 a2151 1 CGM.getTypes().arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Args); @ 1.1.1.10.2.1 log @Sync with HEAD @ text @a332 4 case Stmt::OMPTargetTeamsDistributeSimdDirectiveClass: EmitOMPTargetTeamsDistributeSimdDirective( cast(*S)); break; @ 1.1.1.11 log @Import Clang 4.0RC1 r294123. @ text @a332 4 case Stmt::OMPTargetTeamsDistributeSimdDirectiveClass: EmitOMPTargetTeamsDistributeSimdDirective( cast(*S)); break; @ 1.1.1.12 log @Import clang r309604 from branches/release_50 @ text @d148 1 a148 1 EmitCoreturnStmt(cast(*S)); a1026 12 if (requiresReturnValueCheck()) { llvm::Constant *SLoc = EmitCheckSourceLocation(S.getLocStart()); auto *SLocPtr = new llvm::GlobalVariable(CGM.getModule(), SLoc->getType(), false, llvm::GlobalVariable::PrivateLinkage, SLoc); SLocPtr->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global); CGM.getSanitizerMetadata()->disableSanitizerForGlobal(SLocPtr); assert(ReturnLocation.isValid() && "No valid return location"); Builder.CreateStore(Builder.CreateBitCast(SLocPtr, Int8PtrTy), ReturnLocation); } d1169 1 a1169 1 ++LHS; d2130 1 a2130 1 Result->addAttribute(llvm::AttributeList::FunctionIndex, d2136 1 a2136 1 Result->addAttribute(llvm::AttributeList::FunctionIndex, d2139 1 a2139 1 Result->addAttribute(llvm::AttributeList::FunctionIndex, d2160 1 a2160 1 Result->addAttribute(llvm::AttributeList::FunctionIndex, @ 1.1.1.12.4.1 log @Sync with HEAD @ text @d48 1 a48 1 void CodeGenFunction::EmitStmt(const Stmt *S, ArrayRef Attrs) { a76 9 // Ignore all OpenMP directives except for simd if OpenMP with Simd is // enabled. if (getLangOpts().OpenMP && getLangOpts().OpenMPSimd) { if (const auto *D = dyn_cast(S)) { EmitSimpleOMPExecutableDirective(*D); return; } } d134 10 a143 10 case Stmt::IfStmtClass: EmitIfStmt(cast(*S)); break; case Stmt::WhileStmtClass: EmitWhileStmt(cast(*S), Attrs); break; case Stmt::DoStmtClass: EmitDoStmt(cast(*S), Attrs); break; case Stmt::ForStmtClass: EmitForStmt(cast(*S), Attrs); break; case Stmt::ReturnStmtClass: EmitReturnStmt(cast(*S)); break; case Stmt::SwitchStmtClass: EmitSwitchStmt(cast(*S)); break; case Stmt::GCCAsmStmtClass: // Intentional fall-through. case Stmt::MSAsmStmtClass: EmitAsmStmt(cast(*S)); break; d181 1 a181 1 EmitCXXForRangeStmt(cast(*S), Attrs); d558 17 a574 1 EmitStmt(S.getSubStmt(), S.getAttrs()); d618 1 a618 1 EmitDecl(*S.getConditionVariable()); d715 1 a715 1 EmitDecl(*S.getConditionVariable()); d787 5 a799 5 const SourceRange &R = S.getSourceRange(); LoopStack.push(LoopBody, CGM.getContext(), DoAttrs, SourceLocToDebugLoc(R.getBegin()), SourceLocToDebugLoc(R.getEnd())); d875 1 a875 1 EmitDecl(*S.getConditionVariable()); d1015 1 a1015 3 LValue Dest = MakeAddrLValue(ReturnValue, Ty); LValue Src = MakeAddrLValue(RV.getAggregateAddress(), Ty); EmitAggregateCopy(Dest, Src, Ty, overlapForReturnValue()); d1045 1 a1045 1 // Emit the result value, even if unused, to evaluate the side effects. d1093 5 a1097 6 EmitAggExpr(RV, AggValueSlot::forAddr( ReturnValue, Qualifiers(), AggValueSlot::IsDestructed, AggValueSlot::DoesNotNeedGCBarriers, AggValueSlot::IsNotAliased, overlapForReturnValue())); d1582 1 a1582 1 EmitDecl(*S.getConditionVariable()); d1611 1 a1611 1 EmitDecl(*S.getConditionVariable()); d1934 1 a1934 1 getTarget(), &OutputConstraintInfos); d2141 1 a2141 2 llvm::CallInst *Result = Builder.CreateCall(IA, Args, getBundlesForFunclet(IA)); d2168 4 a2171 5 if (getLangOpts().assumeFunctionsAreConvergent()) { // Conservatively, mark all inline asm blocks in CUDA or OpenCL as // convergent (meaning, they may call an intrinsically convergent op, such // as bar.sync, and so can't have certain optimizations applied around // them). d2213 1 a2213 1 Tmp = Builder.CreateZExtOrTrunc(Tmp, TruncTy); d2286 1 @ 1.1.1.12.4.2 log @Mostly merge changes from HEAD upto 20200411 @ text @@ 1.1.1.12.2.1 log @Sync with HEAD @ text @d48 1 a48 1 void CodeGenFunction::EmitStmt(const Stmt *S, ArrayRef Attrs) { a76 9 // Ignore all OpenMP directives except for simd if OpenMP with Simd is // enabled. if (getLangOpts().OpenMP && getLangOpts().OpenMPSimd) { if (const auto *D = dyn_cast(S)) { EmitSimpleOMPExecutableDirective(*D); return; } } d134 10 a143 10 case Stmt::IfStmtClass: EmitIfStmt(cast(*S)); break; case Stmt::WhileStmtClass: EmitWhileStmt(cast(*S), Attrs); break; case Stmt::DoStmtClass: EmitDoStmt(cast(*S), Attrs); break; case Stmt::ForStmtClass: EmitForStmt(cast(*S), Attrs); break; case Stmt::ReturnStmtClass: EmitReturnStmt(cast(*S)); break; case Stmt::SwitchStmtClass: EmitSwitchStmt(cast(*S)); break; case Stmt::GCCAsmStmtClass: // Intentional fall-through. case Stmt::MSAsmStmtClass: EmitAsmStmt(cast(*S)); break; d181 1 a181 1 EmitCXXForRangeStmt(cast(*S), Attrs); d558 17 a574 1 EmitStmt(S.getSubStmt(), S.getAttrs()); d618 1 a618 1 EmitDecl(*S.getConditionVariable()); d715 1 a715 1 EmitDecl(*S.getConditionVariable()); d787 5 a799 5 const SourceRange &R = S.getSourceRange(); LoopStack.push(LoopBody, CGM.getContext(), DoAttrs, SourceLocToDebugLoc(R.getBegin()), SourceLocToDebugLoc(R.getEnd())); d875 1 a875 1 EmitDecl(*S.getConditionVariable()); d1015 1 a1015 3 LValue Dest = MakeAddrLValue(ReturnValue, Ty); LValue Src = MakeAddrLValue(RV.getAggregateAddress(), Ty); EmitAggregateCopy(Dest, Src, Ty, overlapForReturnValue()); d1045 1 a1045 1 // Emit the result value, even if unused, to evaluate the side effects. d1093 5 a1097 6 EmitAggExpr(RV, AggValueSlot::forAddr( ReturnValue, Qualifiers(), AggValueSlot::IsDestructed, AggValueSlot::DoesNotNeedGCBarriers, AggValueSlot::IsNotAliased, overlapForReturnValue())); d1582 1 a1582 1 EmitDecl(*S.getConditionVariable()); d1611 1 a1611 1 EmitDecl(*S.getConditionVariable()); d1934 1 a1934 1 getTarget(), &OutputConstraintInfos); d2141 1 a2141 2 llvm::CallInst *Result = Builder.CreateCall(IA, Args, getBundlesForFunclet(IA)); d2168 4 a2171 5 if (getLangOpts().assumeFunctionsAreConvergent()) { // Conservatively, mark all inline asm blocks in CUDA or OpenCL as // convergent (meaning, they may call an intrinsically convergent op, such // as bar.sync, and so can't have certain optimizations applied around // them). d2213 1 a2213 1 Tmp = Builder.CreateZExtOrTrunc(Tmp, TruncTy); d2286 1 @ 1.1.1.13 log @Import clang r337282 from trunk @ text @d48 1 a48 1 void CodeGenFunction::EmitStmt(const Stmt *S, ArrayRef Attrs) { a76 9 // Ignore all OpenMP directives except for simd if OpenMP with Simd is // enabled. if (getLangOpts().OpenMP && getLangOpts().OpenMPSimd) { if (const auto *D = dyn_cast(S)) { EmitSimpleOMPExecutableDirective(*D); return; } } d134 10 a143 10 case Stmt::IfStmtClass: EmitIfStmt(cast(*S)); break; case Stmt::WhileStmtClass: EmitWhileStmt(cast(*S), Attrs); break; case Stmt::DoStmtClass: EmitDoStmt(cast(*S), Attrs); break; case Stmt::ForStmtClass: EmitForStmt(cast(*S), Attrs); break; case Stmt::ReturnStmtClass: EmitReturnStmt(cast(*S)); break; case Stmt::SwitchStmtClass: EmitSwitchStmt(cast(*S)); break; case Stmt::GCCAsmStmtClass: // Intentional fall-through. case Stmt::MSAsmStmtClass: EmitAsmStmt(cast(*S)); break; d181 1 a181 1 EmitCXXForRangeStmt(cast(*S), Attrs); d558 17 a574 1 EmitStmt(S.getSubStmt(), S.getAttrs()); d618 1 a618 1 EmitDecl(*S.getConditionVariable()); d715 1 a715 1 EmitDecl(*S.getConditionVariable()); d787 5 a799 5 const SourceRange &R = S.getSourceRange(); LoopStack.push(LoopBody, CGM.getContext(), DoAttrs, SourceLocToDebugLoc(R.getBegin()), SourceLocToDebugLoc(R.getEnd())); d875 1 a875 1 EmitDecl(*S.getConditionVariable()); d1015 1 a1015 3 LValue Dest = MakeAddrLValue(ReturnValue, Ty); LValue Src = MakeAddrLValue(RV.getAggregateAddress(), Ty); EmitAggregateCopy(Dest, Src, Ty, overlapForReturnValue()); d1045 1 a1045 1 // Emit the result value, even if unused, to evaluate the side effects. d1093 5 a1097 6 EmitAggExpr(RV, AggValueSlot::forAddr( ReturnValue, Qualifiers(), AggValueSlot::IsDestructed, AggValueSlot::DoesNotNeedGCBarriers, AggValueSlot::IsNotAliased, overlapForReturnValue())); d1582 1 a1582 1 EmitDecl(*S.getConditionVariable()); d1611 1 a1611 1 EmitDecl(*S.getConditionVariable()); d1934 1 a1934 1 getTarget(), &OutputConstraintInfos); d2141 1 a2141 2 llvm::CallInst *Result = Builder.CreateCall(IA, Args, getBundlesForFunclet(IA)); d2168 4 a2171 5 if (getLangOpts().assumeFunctionsAreConvergent()) { // Conservatively, mark all inline asm blocks in CUDA or OpenCL as // convergent (meaning, they may call an intrinsically convergent op, such // as bar.sync, and so can't have certain optimizations applied around // them). d2213 1 a2213 1 Tmp = Builder.CreateZExtOrTrunc(Tmp, TruncTy); d2286 1 @ 1.1.1.14 log @Mark old LLVM instance as dead. @ text @@ 1.1.1.7.4.1 log @file CGStmt.cpp was added on branch tls-maxphys on 2014-08-19 23:47:27 +0000 @ text @d1 2195 @ 1.1.1.7.4.2 log @Rebase to HEAD as of a few days ago. @ text @a0 2195 //===--- CGStmt.cpp - Emit LLVM Code from Statements ----------------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This contains code to emit Stmt nodes as LLVM code. // //===----------------------------------------------------------------------===// #include "CodeGenFunction.h" #include "CGDebugInfo.h" #include "CodeGenModule.h" #include "TargetInfo.h" #include "clang/AST/StmtVisitor.h" #include "clang/Basic/PrettyStackTrace.h" #include "clang/Basic/TargetInfo.h" #include "clang/Sema/LoopHint.h" #include "clang/Sema/SemaDiagnostic.h" #include "llvm/ADT/StringExtras.h" #include "llvm/IR/CallSite.h" #include "llvm/IR/DataLayout.h" #include "llvm/IR/InlineAsm.h" #include "llvm/IR/Intrinsics.h" using namespace clang; using namespace CodeGen; //===----------------------------------------------------------------------===// // Statement Emission //===----------------------------------------------------------------------===// void CodeGenFunction::EmitStopPoint(const Stmt *S) { if (CGDebugInfo *DI = getDebugInfo()) { SourceLocation Loc; Loc = S->getLocStart(); DI->EmitLocation(Builder, Loc); LastStopPoint = Loc; } } void CodeGenFunction::EmitStmt(const Stmt *S) { assert(S && "Null statement?"); PGO.setCurrentStmt(S); // These statements have their own debug info handling. if (EmitSimpleStmt(S)) return; // Check if we are generating unreachable code. if (!HaveInsertPoint()) { // If so, and the statement doesn't contain a label, then we do not need to // generate actual code. This is safe because (1) the current point is // unreachable, so we don't need to execute the code, and (2) we've already // handled the statements which update internal data structures (like the // local variable map) which could be used by subsequent statements. if (!ContainsLabel(S)) { // Verify that any decl statements were handled as simple, they may be in // scope of subsequent reachable statements. assert(!isa(*S) && "Unexpected DeclStmt!"); return; } // Otherwise, make a new block to hold the code. EnsureInsertPoint(); } // Generate a stoppoint if we are emitting debug info. EmitStopPoint(S); switch (S->getStmtClass()) { case Stmt::NoStmtClass: case Stmt::CXXCatchStmtClass: case Stmt::SEHExceptStmtClass: case Stmt::SEHFinallyStmtClass: case Stmt::MSDependentExistsStmtClass: llvm_unreachable("invalid statement class to emit generically"); case Stmt::NullStmtClass: case Stmt::CompoundStmtClass: case Stmt::DeclStmtClass: case Stmt::LabelStmtClass: case Stmt::AttributedStmtClass: case Stmt::GotoStmtClass: case Stmt::BreakStmtClass: case Stmt::ContinueStmtClass: case Stmt::DefaultStmtClass: case Stmt::CaseStmtClass: llvm_unreachable("should have emitted these statements as simple"); #define STMT(Type, Base) #define ABSTRACT_STMT(Op) #define EXPR(Type, Base) \ case Stmt::Type##Class: #include "clang/AST/StmtNodes.inc" { // Remember the block we came in on. llvm::BasicBlock *incoming = Builder.GetInsertBlock(); assert(incoming && "expression emission must have an insertion point"); EmitIgnoredExpr(cast(S)); llvm::BasicBlock *outgoing = Builder.GetInsertBlock(); assert(outgoing && "expression emission cleared block!"); // The expression emitters assume (reasonably!) that the insertion // point is always set. To maintain that, the call-emission code // for noreturn functions has to enter a new block with no // predecessors. We want to kill that block and mark the current // insertion point unreachable in the common case of a call like // "exit();". Since expression emission doesn't otherwise create // blocks with no predecessors, we can just test for that. // However, we must be careful not to do this to our incoming // block, because *statement* emission does sometimes create // reachable blocks which will have no predecessors until later in // the function. This occurs with, e.g., labels that are not // reachable by fallthrough. if (incoming != outgoing && outgoing->use_empty()) { outgoing->eraseFromParent(); Builder.ClearInsertionPoint(); } break; } case Stmt::IndirectGotoStmtClass: EmitIndirectGotoStmt(cast(*S)); break; case Stmt::IfStmtClass: EmitIfStmt(cast(*S)); break; case Stmt::WhileStmtClass: EmitWhileStmt(cast(*S)); break; case Stmt::DoStmtClass: EmitDoStmt(cast(*S)); break; case Stmt::ForStmtClass: EmitForStmt(cast(*S)); break; case Stmt::ReturnStmtClass: EmitReturnStmt(cast(*S)); break; case Stmt::SwitchStmtClass: EmitSwitchStmt(cast(*S)); break; case Stmt::GCCAsmStmtClass: // Intentional fall-through. case Stmt::MSAsmStmtClass: EmitAsmStmt(cast(*S)); break; case Stmt::CapturedStmtClass: { const CapturedStmt *CS = cast(S); EmitCapturedStmt(*CS, CS->getCapturedRegionKind()); } break; case Stmt::ObjCAtTryStmtClass: EmitObjCAtTryStmt(cast(*S)); break; case Stmt::ObjCAtCatchStmtClass: llvm_unreachable( "@@catch statements should be handled by EmitObjCAtTryStmt"); case Stmt::ObjCAtFinallyStmtClass: llvm_unreachable( "@@finally statements should be handled by EmitObjCAtTryStmt"); case Stmt::ObjCAtThrowStmtClass: EmitObjCAtThrowStmt(cast(*S)); break; case Stmt::ObjCAtSynchronizedStmtClass: EmitObjCAtSynchronizedStmt(cast(*S)); break; case Stmt::ObjCForCollectionStmtClass: EmitObjCForCollectionStmt(cast(*S)); break; case Stmt::ObjCAutoreleasePoolStmtClass: EmitObjCAutoreleasePoolStmt(cast(*S)); break; case Stmt::CXXTryStmtClass: EmitCXXTryStmt(cast(*S)); break; case Stmt::CXXForRangeStmtClass: EmitCXXForRangeStmt(cast(*S)); break; case Stmt::SEHTryStmtClass: EmitSEHTryStmt(cast(*S)); break; case Stmt::SEHLeaveStmtClass: EmitSEHLeaveStmt(cast(*S)); break; case Stmt::OMPParallelDirectiveClass: EmitOMPParallelDirective(cast(*S)); break; case Stmt::OMPSimdDirectiveClass: EmitOMPSimdDirective(cast(*S)); break; case Stmt::OMPForDirectiveClass: EmitOMPForDirective(cast(*S)); break; case Stmt::OMPSectionsDirectiveClass: EmitOMPSectionsDirective(cast(*S)); break; case Stmt::OMPSectionDirectiveClass: EmitOMPSectionDirective(cast(*S)); break; case Stmt::OMPSingleDirectiveClass: EmitOMPSingleDirective(cast(*S)); break; case Stmt::OMPMasterDirectiveClass: EmitOMPMasterDirective(cast(*S)); break; case Stmt::OMPCriticalDirectiveClass: EmitOMPCriticalDirective(cast(*S)); break; case Stmt::OMPParallelForDirectiveClass: EmitOMPParallelForDirective(cast(*S)); break; case Stmt::OMPParallelSectionsDirectiveClass: EmitOMPParallelSectionsDirective(cast(*S)); break; case Stmt::OMPTaskDirectiveClass: EmitOMPTaskDirective(cast(*S)); break; case Stmt::OMPTaskyieldDirectiveClass: EmitOMPTaskyieldDirective(cast(*S)); break; case Stmt::OMPBarrierDirectiveClass: EmitOMPBarrierDirective(cast(*S)); break; case Stmt::OMPTaskwaitDirectiveClass: EmitOMPTaskwaitDirective(cast(*S)); break; case Stmt::OMPFlushDirectiveClass: EmitOMPFlushDirective(cast(*S)); break; case Stmt::OMPOrderedDirectiveClass: EmitOMPOrderedDirective(cast(*S)); break; case Stmt::OMPAtomicDirectiveClass: EmitOMPAtomicDirective(cast(*S)); break; } } bool CodeGenFunction::EmitSimpleStmt(const Stmt *S) { switch (S->getStmtClass()) { default: return false; case Stmt::NullStmtClass: break; case Stmt::CompoundStmtClass: EmitCompoundStmt(cast(*S)); break; case Stmt::DeclStmtClass: EmitDeclStmt(cast(*S)); break; case Stmt::LabelStmtClass: EmitLabelStmt(cast(*S)); break; case Stmt::AttributedStmtClass: EmitAttributedStmt(cast(*S)); break; case Stmt::GotoStmtClass: EmitGotoStmt(cast(*S)); break; case Stmt::BreakStmtClass: EmitBreakStmt(cast(*S)); break; case Stmt::ContinueStmtClass: EmitContinueStmt(cast(*S)); break; case Stmt::DefaultStmtClass: EmitDefaultStmt(cast(*S)); break; case Stmt::CaseStmtClass: EmitCaseStmt(cast(*S)); break; } return true; } /// EmitCompoundStmt - Emit a compound statement {..} node. If GetLast is true, /// this captures the expression result of the last sub-statement and returns it /// (for use by the statement expression extension). llvm::Value* CodeGenFunction::EmitCompoundStmt(const CompoundStmt &S, bool GetLast, AggValueSlot AggSlot) { PrettyStackTraceLoc CrashInfo(getContext().getSourceManager(),S.getLBracLoc(), "LLVM IR generation of compound statement ('{}')"); // Keep track of the current cleanup stack depth, including debug scopes. LexicalScope Scope(*this, S.getSourceRange()); return EmitCompoundStmtWithoutScope(S, GetLast, AggSlot); } llvm::Value* CodeGenFunction::EmitCompoundStmtWithoutScope(const CompoundStmt &S, bool GetLast, AggValueSlot AggSlot) { for (CompoundStmt::const_body_iterator I = S.body_begin(), E = S.body_end()-GetLast; I != E; ++I) EmitStmt(*I); llvm::Value *RetAlloca = nullptr; if (GetLast) { // We have to special case labels here. They are statements, but when put // at the end of a statement expression, they yield the value of their // subexpression. Handle this by walking through all labels we encounter, // emitting them before we evaluate the subexpr. const Stmt *LastStmt = S.body_back(); while (const LabelStmt *LS = dyn_cast(LastStmt)) { EmitLabel(LS->getDecl()); LastStmt = LS->getSubStmt(); } EnsureInsertPoint(); QualType ExprTy = cast(LastStmt)->getType(); if (hasAggregateEvaluationKind(ExprTy)) { EmitAggExpr(cast(LastStmt), AggSlot); } else { // We can't return an RValue here because there might be cleanups at // the end of the StmtExpr. Because of that, we have to emit the result // here into a temporary alloca. RetAlloca = CreateMemTemp(ExprTy); EmitAnyExprToMem(cast(LastStmt), RetAlloca, Qualifiers(), /*IsInit*/false); } } return RetAlloca; } void CodeGenFunction::SimplifyForwardingBlocks(llvm::BasicBlock *BB) { llvm::BranchInst *BI = dyn_cast(BB->getTerminator()); // If there is a cleanup stack, then we it isn't worth trying to // simplify this block (we would need to remove it from the scope map // and cleanup entry). if (!EHStack.empty()) return; // Can only simplify direct branches. if (!BI || !BI->isUnconditional()) return; // Can only simplify empty blocks. if (BI != BB->begin()) return; BB->replaceAllUsesWith(BI->getSuccessor(0)); BI->eraseFromParent(); BB->eraseFromParent(); } void CodeGenFunction::EmitBlock(llvm::BasicBlock *BB, bool IsFinished) { llvm::BasicBlock *CurBB = Builder.GetInsertBlock(); // Fall out of the current block (if necessary). EmitBranch(BB); if (IsFinished && BB->use_empty()) { delete BB; return; } // Place the block after the current block, if possible, or else at // the end of the function. if (CurBB && CurBB->getParent()) CurFn->getBasicBlockList().insertAfter(CurBB, BB); else CurFn->getBasicBlockList().push_back(BB); Builder.SetInsertPoint(BB); } void CodeGenFunction::EmitBranch(llvm::BasicBlock *Target) { // Emit a branch from the current block to the target one if this // was a real block. If this was just a fall-through block after a // terminator, don't emit it. llvm::BasicBlock *CurBB = Builder.GetInsertBlock(); if (!CurBB || CurBB->getTerminator()) { // If there is no insert point or the previous block is already // terminated, don't touch it. } else { // Otherwise, create a fall-through branch. Builder.CreateBr(Target); } Builder.ClearInsertionPoint(); } void CodeGenFunction::EmitBlockAfterUses(llvm::BasicBlock *block) { bool inserted = false; for (llvm::User *u : block->users()) { if (llvm::Instruction *insn = dyn_cast(u)) { CurFn->getBasicBlockList().insertAfter(insn->getParent(), block); inserted = true; break; } } if (!inserted) CurFn->getBasicBlockList().push_back(block); Builder.SetInsertPoint(block); } CodeGenFunction::JumpDest CodeGenFunction::getJumpDestForLabel(const LabelDecl *D) { JumpDest &Dest = LabelMap[D]; if (Dest.isValid()) return Dest; // Create, but don't insert, the new block. Dest = JumpDest(createBasicBlock(D->getName()), EHScopeStack::stable_iterator::invalid(), NextCleanupDestIndex++); return Dest; } void CodeGenFunction::EmitLabel(const LabelDecl *D) { // Add this label to the current lexical scope if we're within any // normal cleanups. Jumps "in" to this label --- when permitted by // the language --- may need to be routed around such cleanups. if (EHStack.hasNormalCleanups() && CurLexicalScope) CurLexicalScope->addLabel(D); JumpDest &Dest = LabelMap[D]; // If we didn't need a forward reference to this label, just go // ahead and create a destination at the current scope. if (!Dest.isValid()) { Dest = getJumpDestInCurrentScope(D->getName()); // Otherwise, we need to give this label a target depth and remove // it from the branch-fixups list. } else { assert(!Dest.getScopeDepth().isValid() && "already emitted label!"); Dest.setScopeDepth(EHStack.stable_begin()); ResolveBranchFixups(Dest.getBlock()); } RegionCounter Cnt = getPGORegionCounter(D->getStmt()); EmitBlock(Dest.getBlock()); Cnt.beginRegion(Builder); } /// Change the cleanup scope of the labels in this lexical scope to /// match the scope of the enclosing context. void CodeGenFunction::LexicalScope::rescopeLabels() { assert(!Labels.empty()); EHScopeStack::stable_iterator innermostScope = CGF.EHStack.getInnermostNormalCleanup(); // Change the scope depth of all the labels. for (SmallVectorImpl::const_iterator i = Labels.begin(), e = Labels.end(); i != e; ++i) { assert(CGF.LabelMap.count(*i)); JumpDest &dest = CGF.LabelMap.find(*i)->second; assert(dest.getScopeDepth().isValid()); assert(innermostScope.encloses(dest.getScopeDepth())); dest.setScopeDepth(innermostScope); } // Reparent the labels if the new scope also has cleanups. if (innermostScope != EHScopeStack::stable_end() && ParentScope) { ParentScope->Labels.append(Labels.begin(), Labels.end()); } } void CodeGenFunction::EmitLabelStmt(const LabelStmt &S) { EmitLabel(S.getDecl()); EmitStmt(S.getSubStmt()); } void CodeGenFunction::EmitAttributedStmt(const AttributedStmt &S) { const Stmt *SubStmt = S.getSubStmt(); switch (SubStmt->getStmtClass()) { case Stmt::DoStmtClass: EmitDoStmt(cast(*SubStmt), S.getAttrs()); break; case Stmt::ForStmtClass: EmitForStmt(cast(*SubStmt), S.getAttrs()); break; case Stmt::WhileStmtClass: EmitWhileStmt(cast(*SubStmt), S.getAttrs()); break; case Stmt::CXXForRangeStmtClass: EmitCXXForRangeStmt(cast(*SubStmt), S.getAttrs()); break; default: EmitStmt(SubStmt); } } void CodeGenFunction::EmitGotoStmt(const GotoStmt &S) { // If this code is reachable then emit a stop point (if generating // debug info). We have to do this ourselves because we are on the // "simple" statement path. if (HaveInsertPoint()) EmitStopPoint(&S); EmitBranchThroughCleanup(getJumpDestForLabel(S.getLabel())); } void CodeGenFunction::EmitIndirectGotoStmt(const IndirectGotoStmt &S) { if (const LabelDecl *Target = S.getConstantTarget()) { EmitBranchThroughCleanup(getJumpDestForLabel(Target)); return; } // Ensure that we have an i8* for our PHI node. llvm::Value *V = Builder.CreateBitCast(EmitScalarExpr(S.getTarget()), Int8PtrTy, "addr"); llvm::BasicBlock *CurBB = Builder.GetInsertBlock(); // Get the basic block for the indirect goto. llvm::BasicBlock *IndGotoBB = GetIndirectGotoBlock(); // The first instruction in the block has to be the PHI for the switch dest, // add an entry for this branch. cast(IndGotoBB->begin())->addIncoming(V, CurBB); EmitBranch(IndGotoBB); } void CodeGenFunction::EmitIfStmt(const IfStmt &S) { // C99 6.8.4.1: The first substatement is executed if the expression compares // unequal to 0. The condition must be a scalar type. LexicalScope ConditionScope(*this, S.getCond()->getSourceRange()); RegionCounter Cnt = getPGORegionCounter(&S); if (S.getConditionVariable()) EmitAutoVarDecl(*S.getConditionVariable()); // If the condition constant folds and can be elided, try to avoid emitting // the condition and the dead arm of the if/else. bool CondConstant; if (ConstantFoldsToSimpleInteger(S.getCond(), CondConstant)) { // Figure out which block (then or else) is executed. const Stmt *Executed = S.getThen(); const Stmt *Skipped = S.getElse(); if (!CondConstant) // Condition false? std::swap(Executed, Skipped); // If the skipped block has no labels in it, just emit the executed block. // This avoids emitting dead code and simplifies the CFG substantially. if (!ContainsLabel(Skipped)) { if (CondConstant) Cnt.beginRegion(Builder); if (Executed) { RunCleanupsScope ExecutedScope(*this); EmitStmt(Executed); } return; } } // Otherwise, the condition did not fold, or we couldn't elide it. Just emit // the conditional branch. llvm::BasicBlock *ThenBlock = createBasicBlock("if.then"); llvm::BasicBlock *ContBlock = createBasicBlock("if.end"); llvm::BasicBlock *ElseBlock = ContBlock; if (S.getElse()) ElseBlock = createBasicBlock("if.else"); EmitBranchOnBoolExpr(S.getCond(), ThenBlock, ElseBlock, Cnt.getCount()); // Emit the 'then' code. EmitBlock(ThenBlock); Cnt.beginRegion(Builder); { RunCleanupsScope ThenScope(*this); EmitStmt(S.getThen()); } EmitBranch(ContBlock); // Emit the 'else' code if present. if (const Stmt *Else = S.getElse()) { { // There is no need to emit line number for unconditional branch. SuppressDebugLocation S(Builder); EmitBlock(ElseBlock); } { RunCleanupsScope ElseScope(*this); EmitStmt(Else); } { // There is no need to emit line number for unconditional branch. SuppressDebugLocation S(Builder); EmitBranch(ContBlock); } } // Emit the continuation block for code after the if. EmitBlock(ContBlock, true); } void CodeGenFunction::EmitCondBrHints(llvm::LLVMContext &Context, llvm::BranchInst *CondBr, const ArrayRef &Attrs) { // Return if there are no hints. if (Attrs.empty()) return; // Add vectorize and unroll hints to the metadata on the conditional branch. SmallVector Metadata(1); for (const auto *Attr : Attrs) { const LoopHintAttr *LH = dyn_cast(Attr); // Skip non loop hint attributes if (!LH) continue; LoopHintAttr::OptionType Option = LH->getOption(); LoopHintAttr::LoopHintState State = LH->getState(); int ValueInt = LH->getValue(); const char *MetadataName; switch (Option) { case LoopHintAttr::Vectorize: case LoopHintAttr::VectorizeWidth: MetadataName = "llvm.loop.vectorize.width"; break; case LoopHintAttr::Interleave: case LoopHintAttr::InterleaveCount: MetadataName = "llvm.loop.interleave.count"; break; case LoopHintAttr::Unroll: // With the unroll loop hint, a non-zero value indicates full unrolling. MetadataName = State == LoopHintAttr::Disable ? "llvm.loop.unroll.disable" : "llvm.loop.unroll.full"; break; case LoopHintAttr::UnrollCount: MetadataName = "llvm.loop.unroll.count"; break; } llvm::Value *Value; llvm::MDString *Name; switch (Option) { case LoopHintAttr::Vectorize: case LoopHintAttr::Interleave: if (State != LoopHintAttr::Disable) { // FIXME: In the future I will modifiy the behavior of the metadata // so we can enable/disable vectorization and interleaving separately. Name = llvm::MDString::get(Context, "llvm.loop.vectorize.enable"); Value = Builder.getTrue(); break; } // Vectorization/interleaving is disabled, set width/count to 1. ValueInt = 1; // Fallthrough. case LoopHintAttr::VectorizeWidth: case LoopHintAttr::InterleaveCount: case LoopHintAttr::UnrollCount: Name = llvm::MDString::get(Context, MetadataName); Value = llvm::ConstantInt::get(Int32Ty, ValueInt); break; case LoopHintAttr::Unroll: Name = llvm::MDString::get(Context, MetadataName); Value = nullptr; break; } SmallVector OpValues; OpValues.push_back(Name); if (Value) OpValues.push_back(Value); // Set or overwrite metadata indicated by Name. Metadata.push_back(llvm::MDNode::get(Context, OpValues)); } if (!Metadata.empty()) { // Add llvm.loop MDNode to CondBr. llvm::MDNode *LoopID = llvm::MDNode::get(Context, Metadata); LoopID->replaceOperandWith(0, LoopID); // First op points to itself. CondBr->setMetadata("llvm.loop", LoopID); } } void CodeGenFunction::EmitWhileStmt(const WhileStmt &S, const ArrayRef &WhileAttrs) { RegionCounter Cnt = getPGORegionCounter(&S); // Emit the header for the loop, which will also become // the continue target. JumpDest LoopHeader = getJumpDestInCurrentScope("while.cond"); EmitBlock(LoopHeader.getBlock()); LoopStack.push(LoopHeader.getBlock()); // Create an exit block for when the condition fails, which will // also become the break target. JumpDest LoopExit = getJumpDestInCurrentScope("while.end"); // Store the blocks to use for break and continue. BreakContinueStack.push_back(BreakContinue(LoopExit, LoopHeader)); // C++ [stmt.while]p2: // When the condition of a while statement is a declaration, the // scope of the variable that is declared extends from its point // of declaration (3.3.2) to the end of the while statement. // [...] // The object created in a condition is destroyed and created // with each iteration of the loop. RunCleanupsScope ConditionScope(*this); if (S.getConditionVariable()) EmitAutoVarDecl(*S.getConditionVariable()); // Evaluate the conditional in the while header. C99 6.8.5.1: The // evaluation of the controlling expression takes place before each // execution of the loop body. llvm::Value *BoolCondVal = EvaluateExprAsBool(S.getCond()); // while(1) is common, avoid extra exit blocks. Be sure // to correctly handle break/continue though. bool EmitBoolCondBranch = true; if (llvm::ConstantInt *C = dyn_cast(BoolCondVal)) if (C->isOne()) EmitBoolCondBranch = false; // As long as the condition is true, go to the loop body. llvm::BasicBlock *LoopBody = createBasicBlock("while.body"); if (EmitBoolCondBranch) { llvm::BasicBlock *ExitBlock = LoopExit.getBlock(); if (ConditionScope.requiresCleanups()) ExitBlock = createBasicBlock("while.exit"); llvm::BranchInst *CondBr = Builder.CreateCondBr(BoolCondVal, LoopBody, ExitBlock, PGO.createLoopWeights(S.getCond(), Cnt)); if (ExitBlock != LoopExit.getBlock()) { EmitBlock(ExitBlock); EmitBranchThroughCleanup(LoopExit); } // Attach metadata to loop body conditional branch. EmitCondBrHints(LoopBody->getContext(), CondBr, WhileAttrs); } // Emit the loop body. We have to emit this in a cleanup scope // because it might be a singleton DeclStmt. { RunCleanupsScope BodyScope(*this); EmitBlock(LoopBody); Cnt.beginRegion(Builder); EmitStmt(S.getBody()); } BreakContinueStack.pop_back(); // Immediately force cleanup. ConditionScope.ForceCleanup(); // Branch to the loop header again. EmitBranch(LoopHeader.getBlock()); LoopStack.pop(); // Emit the exit block. EmitBlock(LoopExit.getBlock(), true); // The LoopHeader typically is just a branch if we skipped emitting // a branch, try to erase it. if (!EmitBoolCondBranch) SimplifyForwardingBlocks(LoopHeader.getBlock()); } void CodeGenFunction::EmitDoStmt(const DoStmt &S, const ArrayRef &DoAttrs) { JumpDest LoopExit = getJumpDestInCurrentScope("do.end"); JumpDest LoopCond = getJumpDestInCurrentScope("do.cond"); RegionCounter Cnt = getPGORegionCounter(&S); // Store the blocks to use for break and continue. BreakContinueStack.push_back(BreakContinue(LoopExit, LoopCond)); // Emit the body of the loop. llvm::BasicBlock *LoopBody = createBasicBlock("do.body"); LoopStack.push(LoopBody); EmitBlockWithFallThrough(LoopBody, Cnt); { RunCleanupsScope BodyScope(*this); EmitStmt(S.getBody()); } EmitBlock(LoopCond.getBlock()); // C99 6.8.5.2: "The evaluation of the controlling expression takes place // after each execution of the loop body." // Evaluate the conditional in the while header. // C99 6.8.5p2/p4: The first substatement is executed if the expression // compares unequal to 0. The condition must be a scalar type. llvm::Value *BoolCondVal = EvaluateExprAsBool(S.getCond()); BreakContinueStack.pop_back(); // "do {} while (0)" is common in macros, avoid extra blocks. Be sure // to correctly handle break/continue though. bool EmitBoolCondBranch = true; if (llvm::ConstantInt *C = dyn_cast(BoolCondVal)) if (C->isZero()) EmitBoolCondBranch = false; // As long as the condition is true, iterate the loop. if (EmitBoolCondBranch) { llvm::BranchInst *CondBr = Builder.CreateCondBr(BoolCondVal, LoopBody, LoopExit.getBlock(), PGO.createLoopWeights(S.getCond(), Cnt)); // Attach metadata to loop body conditional branch. EmitCondBrHints(LoopBody->getContext(), CondBr, DoAttrs); } LoopStack.pop(); // Emit the exit block. EmitBlock(LoopExit.getBlock()); // The DoCond block typically is just a branch if we skipped // emitting a branch, try to erase it. if (!EmitBoolCondBranch) SimplifyForwardingBlocks(LoopCond.getBlock()); } void CodeGenFunction::EmitForStmt(const ForStmt &S, const ArrayRef &ForAttrs) { JumpDest LoopExit = getJumpDestInCurrentScope("for.end"); RunCleanupsScope ForScope(*this); CGDebugInfo *DI = getDebugInfo(); if (DI) DI->EmitLexicalBlockStart(Builder, S.getSourceRange().getBegin()); // Evaluate the first part before the loop. if (S.getInit()) EmitStmt(S.getInit()); RegionCounter Cnt = getPGORegionCounter(&S); // Start the loop with a block that tests the condition. // If there's an increment, the continue scope will be overwritten // later. JumpDest Continue = getJumpDestInCurrentScope("for.cond"); llvm::BasicBlock *CondBlock = Continue.getBlock(); EmitBlock(CondBlock); LoopStack.push(CondBlock); // If the for loop doesn't have an increment we can just use the // condition as the continue block. Otherwise we'll need to create // a block for it (in the current scope, i.e. in the scope of the // condition), and that we will become our continue block. if (S.getInc()) Continue = getJumpDestInCurrentScope("for.inc"); // Store the blocks to use for break and continue. BreakContinueStack.push_back(BreakContinue(LoopExit, Continue)); // Create a cleanup scope for the condition variable cleanups. RunCleanupsScope ConditionScope(*this); if (S.getCond()) { // If the for statement has a condition scope, emit the local variable // declaration. if (S.getConditionVariable()) { EmitAutoVarDecl(*S.getConditionVariable()); } llvm::BasicBlock *ExitBlock = LoopExit.getBlock(); // If there are any cleanups between here and the loop-exit scope, // create a block to stage a loop exit along. if (ForScope.requiresCleanups()) ExitBlock = createBasicBlock("for.cond.cleanup"); // As long as the condition is true, iterate the loop. llvm::BasicBlock *ForBody = createBasicBlock("for.body"); // C99 6.8.5p2/p4: The first substatement is executed if the expression // compares unequal to 0. The condition must be a scalar type. llvm::Value *BoolCondVal = EvaluateExprAsBool(S.getCond()); llvm::BranchInst *CondBr = Builder.CreateCondBr(BoolCondVal, ForBody, ExitBlock, PGO.createLoopWeights(S.getCond(), Cnt)); // Attach metadata to loop body conditional branch. EmitCondBrHints(ForBody->getContext(), CondBr, ForAttrs); if (ExitBlock != LoopExit.getBlock()) { EmitBlock(ExitBlock); EmitBranchThroughCleanup(LoopExit); } EmitBlock(ForBody); } else { // Treat it as a non-zero constant. Don't even create a new block for the // body, just fall into it. } Cnt.beginRegion(Builder); { // Create a separate cleanup scope for the body, in case it is not // a compound statement. RunCleanupsScope BodyScope(*this); EmitStmt(S.getBody()); } // If there is an increment, emit it next. if (S.getInc()) { EmitBlock(Continue.getBlock()); EmitStmt(S.getInc()); } BreakContinueStack.pop_back(); ConditionScope.ForceCleanup(); EmitBranch(CondBlock); ForScope.ForceCleanup(); if (DI) DI->EmitLexicalBlockEnd(Builder, S.getSourceRange().getEnd()); LoopStack.pop(); // Emit the fall-through block. EmitBlock(LoopExit.getBlock(), true); } void CodeGenFunction::EmitCXXForRangeStmt(const CXXForRangeStmt &S, const ArrayRef &ForAttrs) { JumpDest LoopExit = getJumpDestInCurrentScope("for.end"); RunCleanupsScope ForScope(*this); CGDebugInfo *DI = getDebugInfo(); if (DI) DI->EmitLexicalBlockStart(Builder, S.getSourceRange().getBegin()); // Evaluate the first pieces before the loop. EmitStmt(S.getRangeStmt()); EmitStmt(S.getBeginEndStmt()); RegionCounter Cnt = getPGORegionCounter(&S); // Start the loop with a block that tests the condition. // If there's an increment, the continue scope will be overwritten // later. llvm::BasicBlock *CondBlock = createBasicBlock("for.cond"); EmitBlock(CondBlock); LoopStack.push(CondBlock); // If there are any cleanups between here and the loop-exit scope, // create a block to stage a loop exit along. llvm::BasicBlock *ExitBlock = LoopExit.getBlock(); if (ForScope.requiresCleanups()) ExitBlock = createBasicBlock("for.cond.cleanup"); // The loop body, consisting of the specified body and the loop variable. llvm::BasicBlock *ForBody = createBasicBlock("for.body"); // The body is executed if the expression, contextually converted // to bool, is true. llvm::Value *BoolCondVal = EvaluateExprAsBool(S.getCond()); llvm::BranchInst *CondBr = Builder.CreateCondBr( BoolCondVal, ForBody, ExitBlock, PGO.createLoopWeights(S.getCond(), Cnt)); // Attach metadata to loop body conditional branch. EmitCondBrHints(ForBody->getContext(), CondBr, ForAttrs); if (ExitBlock != LoopExit.getBlock()) { EmitBlock(ExitBlock); EmitBranchThroughCleanup(LoopExit); } EmitBlock(ForBody); Cnt.beginRegion(Builder); // Create a block for the increment. In case of a 'continue', we jump there. JumpDest Continue = getJumpDestInCurrentScope("for.inc"); // Store the blocks to use for break and continue. BreakContinueStack.push_back(BreakContinue(LoopExit, Continue)); { // Create a separate cleanup scope for the loop variable and body. RunCleanupsScope BodyScope(*this); EmitStmt(S.getLoopVarStmt()); EmitStmt(S.getBody()); } // If there is an increment, emit it next. EmitBlock(Continue.getBlock()); EmitStmt(S.getInc()); BreakContinueStack.pop_back(); EmitBranch(CondBlock); ForScope.ForceCleanup(); if (DI) DI->EmitLexicalBlockEnd(Builder, S.getSourceRange().getEnd()); LoopStack.pop(); // Emit the fall-through block. EmitBlock(LoopExit.getBlock(), true); } void CodeGenFunction::EmitReturnOfRValue(RValue RV, QualType Ty) { if (RV.isScalar()) { Builder.CreateStore(RV.getScalarVal(), ReturnValue); } else if (RV.isAggregate()) { EmitAggregateCopy(ReturnValue, RV.getAggregateAddr(), Ty); } else { EmitStoreOfComplex(RV.getComplexVal(), MakeNaturalAlignAddrLValue(ReturnValue, Ty), /*init*/ true); } EmitBranchThroughCleanup(ReturnBlock); } /// EmitReturnStmt - Note that due to GCC extensions, this can have an operand /// if the function returns void, or may be missing one if the function returns /// non-void. Fun stuff :). void CodeGenFunction::EmitReturnStmt(const ReturnStmt &S) { // Emit the result value, even if unused, to evalute the side effects. const Expr *RV = S.getRetValue(); // Treat block literals in a return expression as if they appeared // in their own scope. This permits a small, easily-implemented // exception to our over-conservative rules about not jumping to // statements following block literals with non-trivial cleanups. RunCleanupsScope cleanupScope(*this); if (const ExprWithCleanups *cleanups = dyn_cast_or_null(RV)) { enterFullExpression(cleanups); RV = cleanups->getSubExpr(); } // FIXME: Clean this up by using an LValue for ReturnTemp, // EmitStoreThroughLValue, and EmitAnyExpr. if (getLangOpts().ElideConstructors && S.getNRVOCandidate() && S.getNRVOCandidate()->isNRVOVariable()) { // Apply the named return value optimization for this return statement, // which means doing nothing: the appropriate result has already been // constructed into the NRVO variable. // If there is an NRVO flag for this variable, set it to 1 into indicate // that the cleanup code should not destroy the variable. if (llvm::Value *NRVOFlag = NRVOFlags[S.getNRVOCandidate()]) Builder.CreateStore(Builder.getTrue(), NRVOFlag); } else if (!ReturnValue || (RV && RV->getType()->isVoidType())) { // Make sure not to return anything, but evaluate the expression // for side effects. if (RV) EmitAnyExpr(RV); } else if (!RV) { // Do nothing (return value is left uninitialized) } else if (FnRetTy->isReferenceType()) { // If this function returns a reference, take the address of the expression // rather than the value. RValue Result = EmitReferenceBindingToExpr(RV); Builder.CreateStore(Result.getScalarVal(), ReturnValue); } else { switch (getEvaluationKind(RV->getType())) { case TEK_Scalar: Builder.CreateStore(EmitScalarExpr(RV), ReturnValue); break; case TEK_Complex: EmitComplexExprIntoLValue(RV, MakeNaturalAlignAddrLValue(ReturnValue, RV->getType()), /*isInit*/ true); break; case TEK_Aggregate: { CharUnits Alignment = getContext().getTypeAlignInChars(RV->getType()); EmitAggExpr(RV, AggValueSlot::forAddr(ReturnValue, Alignment, Qualifiers(), AggValueSlot::IsDestructed, AggValueSlot::DoesNotNeedGCBarriers, AggValueSlot::IsNotAliased)); break; } } } ++NumReturnExprs; if (!RV || RV->isEvaluatable(getContext())) ++NumSimpleReturnExprs; cleanupScope.ForceCleanup(); EmitBranchThroughCleanup(ReturnBlock); } void CodeGenFunction::EmitDeclStmt(const DeclStmt &S) { // As long as debug info is modeled with instructions, we have to ensure we // have a place to insert here and write the stop point here. if (HaveInsertPoint()) EmitStopPoint(&S); for (const auto *I : S.decls()) EmitDecl(*I); } void CodeGenFunction::EmitBreakStmt(const BreakStmt &S) { assert(!BreakContinueStack.empty() && "break stmt not in a loop or switch!"); // If this code is reachable then emit a stop point (if generating // debug info). We have to do this ourselves because we are on the // "simple" statement path. if (HaveInsertPoint()) EmitStopPoint(&S); EmitBranchThroughCleanup(BreakContinueStack.back().BreakBlock); } void CodeGenFunction::EmitContinueStmt(const ContinueStmt &S) { assert(!BreakContinueStack.empty() && "continue stmt not in a loop!"); // If this code is reachable then emit a stop point (if generating // debug info). We have to do this ourselves because we are on the // "simple" statement path. if (HaveInsertPoint()) EmitStopPoint(&S); EmitBranchThroughCleanup(BreakContinueStack.back().ContinueBlock); } /// EmitCaseStmtRange - If case statement range is not too big then /// add multiple cases to switch instruction, one for each value within /// the range. If range is too big then emit "if" condition check. void CodeGenFunction::EmitCaseStmtRange(const CaseStmt &S) { assert(S.getRHS() && "Expected RHS value in CaseStmt"); llvm::APSInt LHS = S.getLHS()->EvaluateKnownConstInt(getContext()); llvm::APSInt RHS = S.getRHS()->EvaluateKnownConstInt(getContext()); RegionCounter CaseCnt = getPGORegionCounter(&S); // Emit the code for this case. We do this first to make sure it is // properly chained from our predecessor before generating the // switch machinery to enter this block. llvm::BasicBlock *CaseDest = createBasicBlock("sw.bb"); EmitBlockWithFallThrough(CaseDest, CaseCnt); EmitStmt(S.getSubStmt()); // If range is empty, do nothing. if (LHS.isSigned() ? RHS.slt(LHS) : RHS.ult(LHS)) return; llvm::APInt Range = RHS - LHS; // FIXME: parameters such as this should not be hardcoded. if (Range.ult(llvm::APInt(Range.getBitWidth(), 64))) { // Range is small enough to add multiple switch instruction cases. uint64_t Total = CaseCnt.getCount(); unsigned NCases = Range.getZExtValue() + 1; // We only have one region counter for the entire set of cases here, so we // need to divide the weights evenly between the generated cases, ensuring // that the total weight is preserved. E.g., a weight of 5 over three cases // will be distributed as weights of 2, 2, and 1. uint64_t Weight = Total / NCases, Rem = Total % NCases; for (unsigned I = 0; I != NCases; ++I) { if (SwitchWeights) SwitchWeights->push_back(Weight + (Rem ? 1 : 0)); if (Rem) Rem--; SwitchInsn->addCase(Builder.getInt(LHS), CaseDest); LHS++; } return; } // The range is too big. Emit "if" condition into a new block, // making sure to save and restore the current insertion point. llvm::BasicBlock *RestoreBB = Builder.GetInsertBlock(); // Push this test onto the chain of range checks (which terminates // in the default basic block). The switch's default will be changed // to the top of this chain after switch emission is complete. llvm::BasicBlock *FalseDest = CaseRangeBlock; CaseRangeBlock = createBasicBlock("sw.caserange"); CurFn->getBasicBlockList().push_back(CaseRangeBlock); Builder.SetInsertPoint(CaseRangeBlock); // Emit range check. llvm::Value *Diff = Builder.CreateSub(SwitchInsn->getCondition(), Builder.getInt(LHS)); llvm::Value *Cond = Builder.CreateICmpULE(Diff, Builder.getInt(Range), "inbounds"); llvm::MDNode *Weights = nullptr; if (SwitchWeights) { uint64_t ThisCount = CaseCnt.getCount(); uint64_t DefaultCount = (*SwitchWeights)[0]; Weights = PGO.createBranchWeights(ThisCount, DefaultCount); // Since we're chaining the switch default through each large case range, we // need to update the weight for the default, ie, the first case, to include // this case. (*SwitchWeights)[0] += ThisCount; } Builder.CreateCondBr(Cond, CaseDest, FalseDest, Weights); // Restore the appropriate insertion point. if (RestoreBB) Builder.SetInsertPoint(RestoreBB); else Builder.ClearInsertionPoint(); } void CodeGenFunction::EmitCaseStmt(const CaseStmt &S) { // If there is no enclosing switch instance that we're aware of, then this // case statement and its block can be elided. This situation only happens // when we've constant-folded the switch, are emitting the constant case, // and part of the constant case includes another case statement. For // instance: switch (4) { case 4: do { case 5: } while (1); } if (!SwitchInsn) { EmitStmt(S.getSubStmt()); return; } // Handle case ranges. if (S.getRHS()) { EmitCaseStmtRange(S); return; } RegionCounter CaseCnt = getPGORegionCounter(&S); llvm::ConstantInt *CaseVal = Builder.getInt(S.getLHS()->EvaluateKnownConstInt(getContext())); // If the body of the case is just a 'break', try to not emit an empty block. // If we're profiling or we're not optimizing, leave the block in for better // debug and coverage analysis. if (!CGM.getCodeGenOpts().ProfileInstrGenerate && CGM.getCodeGenOpts().OptimizationLevel > 0 && isa(S.getSubStmt())) { JumpDest Block = BreakContinueStack.back().BreakBlock; // Only do this optimization if there are no cleanups that need emitting. if (isObviouslyBranchWithoutCleanups(Block)) { if (SwitchWeights) SwitchWeights->push_back(CaseCnt.getCount()); SwitchInsn->addCase(CaseVal, Block.getBlock()); // If there was a fallthrough into this case, make sure to redirect it to // the end of the switch as well. if (Builder.GetInsertBlock()) { Builder.CreateBr(Block.getBlock()); Builder.ClearInsertionPoint(); } return; } } llvm::BasicBlock *CaseDest = createBasicBlock("sw.bb"); EmitBlockWithFallThrough(CaseDest, CaseCnt); if (SwitchWeights) SwitchWeights->push_back(CaseCnt.getCount()); SwitchInsn->addCase(CaseVal, CaseDest); // Recursively emitting the statement is acceptable, but is not wonderful for // code where we have many case statements nested together, i.e.: // case 1: // case 2: // case 3: etc. // Handling this recursively will create a new block for each case statement // that falls through to the next case which is IR intensive. It also causes // deep recursion which can run into stack depth limitations. Handle // sequential non-range case statements specially. const CaseStmt *CurCase = &S; const CaseStmt *NextCase = dyn_cast(S.getSubStmt()); // Otherwise, iteratively add consecutive cases to this switch stmt. while (NextCase && NextCase->getRHS() == nullptr) { CurCase = NextCase; llvm::ConstantInt *CaseVal = Builder.getInt(CurCase->getLHS()->EvaluateKnownConstInt(getContext())); CaseCnt = getPGORegionCounter(NextCase); if (SwitchWeights) SwitchWeights->push_back(CaseCnt.getCount()); if (CGM.getCodeGenOpts().ProfileInstrGenerate) { CaseDest = createBasicBlock("sw.bb"); EmitBlockWithFallThrough(CaseDest, CaseCnt); } SwitchInsn->addCase(CaseVal, CaseDest); NextCase = dyn_cast(CurCase->getSubStmt()); } // Normal default recursion for non-cases. EmitStmt(CurCase->getSubStmt()); } void CodeGenFunction::EmitDefaultStmt(const DefaultStmt &S) { llvm::BasicBlock *DefaultBlock = SwitchInsn->getDefaultDest(); assert(DefaultBlock->empty() && "EmitDefaultStmt: Default block already defined?"); RegionCounter Cnt = getPGORegionCounter(&S); EmitBlockWithFallThrough(DefaultBlock, Cnt); EmitStmt(S.getSubStmt()); } /// CollectStatementsForCase - Given the body of a 'switch' statement and a /// constant value that is being switched on, see if we can dead code eliminate /// the body of the switch to a simple series of statements to emit. Basically, /// on a switch (5) we want to find these statements: /// case 5: /// printf(...); <-- /// ++i; <-- /// break; /// /// and add them to the ResultStmts vector. If it is unsafe to do this /// transformation (for example, one of the elided statements contains a label /// that might be jumped to), return CSFC_Failure. If we handled it and 'S' /// should include statements after it (e.g. the printf() line is a substmt of /// the case) then return CSFC_FallThrough. If we handled it and found a break /// statement, then return CSFC_Success. /// /// If Case is non-null, then we are looking for the specified case, checking /// that nothing we jump over contains labels. If Case is null, then we found /// the case and are looking for the break. /// /// If the recursive walk actually finds our Case, then we set FoundCase to /// true. /// enum CSFC_Result { CSFC_Failure, CSFC_FallThrough, CSFC_Success }; static CSFC_Result CollectStatementsForCase(const Stmt *S, const SwitchCase *Case, bool &FoundCase, SmallVectorImpl &ResultStmts) { // If this is a null statement, just succeed. if (!S) return Case ? CSFC_Success : CSFC_FallThrough; // If this is the switchcase (case 4: or default) that we're looking for, then // we're in business. Just add the substatement. if (const SwitchCase *SC = dyn_cast(S)) { if (S == Case) { FoundCase = true; return CollectStatementsForCase(SC->getSubStmt(), nullptr, FoundCase, ResultStmts); } // Otherwise, this is some other case or default statement, just ignore it. return CollectStatementsForCase(SC->getSubStmt(), Case, FoundCase, ResultStmts); } // If we are in the live part of the code and we found our break statement, // return a success! if (!Case && isa(S)) return CSFC_Success; // If this is a switch statement, then it might contain the SwitchCase, the // break, or neither. if (const CompoundStmt *CS = dyn_cast(S)) { // Handle this as two cases: we might be looking for the SwitchCase (if so // the skipped statements must be skippable) or we might already have it. CompoundStmt::const_body_iterator I = CS->body_begin(), E = CS->body_end(); if (Case) { // Keep track of whether we see a skipped declaration. The code could be // using the declaration even if it is skipped, so we can't optimize out // the decl if the kept statements might refer to it. bool HadSkippedDecl = false; // If we're looking for the case, just see if we can skip each of the // substatements. for (; Case && I != E; ++I) { HadSkippedDecl |= isa(*I); switch (CollectStatementsForCase(*I, Case, FoundCase, ResultStmts)) { case CSFC_Failure: return CSFC_Failure; case CSFC_Success: // A successful result means that either 1) that the statement doesn't // have the case and is skippable, or 2) does contain the case value // and also contains the break to exit the switch. In the later case, // we just verify the rest of the statements are elidable. if (FoundCase) { // If we found the case and skipped declarations, we can't do the // optimization. if (HadSkippedDecl) return CSFC_Failure; for (++I; I != E; ++I) if (CodeGenFunction::ContainsLabel(*I, true)) return CSFC_Failure; return CSFC_Success; } break; case CSFC_FallThrough: // If we have a fallthrough condition, then we must have found the // case started to include statements. Consider the rest of the // statements in the compound statement as candidates for inclusion. assert(FoundCase && "Didn't find case but returned fallthrough?"); // We recursively found Case, so we're not looking for it anymore. Case = nullptr; // If we found the case and skipped declarations, we can't do the // optimization. if (HadSkippedDecl) return CSFC_Failure; break; } } } // If we have statements in our range, then we know that the statements are // live and need to be added to the set of statements we're tracking. for (; I != E; ++I) { switch (CollectStatementsForCase(*I, nullptr, FoundCase, ResultStmts)) { case CSFC_Failure: return CSFC_Failure; case CSFC_FallThrough: // A fallthrough result means that the statement was simple and just // included in ResultStmt, keep adding them afterwards. break; case CSFC_Success: // A successful result means that we found the break statement and // stopped statement inclusion. We just ensure that any leftover stmts // are skippable and return success ourselves. for (++I; I != E; ++I) if (CodeGenFunction::ContainsLabel(*I, true)) return CSFC_Failure; return CSFC_Success; } } return Case ? CSFC_Success : CSFC_FallThrough; } // Okay, this is some other statement that we don't handle explicitly, like a // for statement or increment etc. If we are skipping over this statement, // just verify it doesn't have labels, which would make it invalid to elide. if (Case) { if (CodeGenFunction::ContainsLabel(S, true)) return CSFC_Failure; return CSFC_Success; } // Otherwise, we want to include this statement. Everything is cool with that // so long as it doesn't contain a break out of the switch we're in. if (CodeGenFunction::containsBreak(S)) return CSFC_Failure; // Otherwise, everything is great. Include the statement and tell the caller // that we fall through and include the next statement as well. ResultStmts.push_back(S); return CSFC_FallThrough; } /// FindCaseStatementsForValue - Find the case statement being jumped to and /// then invoke CollectStatementsForCase to find the list of statements to emit /// for a switch on constant. See the comment above CollectStatementsForCase /// for more details. static bool FindCaseStatementsForValue(const SwitchStmt &S, const llvm::APSInt &ConstantCondValue, SmallVectorImpl &ResultStmts, ASTContext &C, const SwitchCase *&ResultCase) { // First step, find the switch case that is being branched to. We can do this // efficiently by scanning the SwitchCase list. const SwitchCase *Case = S.getSwitchCaseList(); const DefaultStmt *DefaultCase = nullptr; for (; Case; Case = Case->getNextSwitchCase()) { // It's either a default or case. Just remember the default statement in // case we're not jumping to any numbered cases. if (const DefaultStmt *DS = dyn_cast(Case)) { DefaultCase = DS; continue; } // Check to see if this case is the one we're looking for. const CaseStmt *CS = cast(Case); // Don't handle case ranges yet. if (CS->getRHS()) return false; // If we found our case, remember it as 'case'. if (CS->getLHS()->EvaluateKnownConstInt(C) == ConstantCondValue) break; } // If we didn't find a matching case, we use a default if it exists, or we // elide the whole switch body! if (!Case) { // It is safe to elide the body of the switch if it doesn't contain labels // etc. If it is safe, return successfully with an empty ResultStmts list. if (!DefaultCase) return !CodeGenFunction::ContainsLabel(&S); Case = DefaultCase; } // Ok, we know which case is being jumped to, try to collect all the // statements that follow it. This can fail for a variety of reasons. Also, // check to see that the recursive walk actually found our case statement. // Insane cases like this can fail to find it in the recursive walk since we // don't handle every stmt kind: // switch (4) { // while (1) { // case 4: ... bool FoundCase = false; ResultCase = Case; return CollectStatementsForCase(S.getBody(), Case, FoundCase, ResultStmts) != CSFC_Failure && FoundCase; } void CodeGenFunction::EmitSwitchStmt(const SwitchStmt &S) { // Handle nested switch statements. llvm::SwitchInst *SavedSwitchInsn = SwitchInsn; SmallVector *SavedSwitchWeights = SwitchWeights; llvm::BasicBlock *SavedCRBlock = CaseRangeBlock; // See if we can constant fold the condition of the switch and therefore only // emit the live case statement (if any) of the switch. llvm::APSInt ConstantCondValue; if (ConstantFoldsToSimpleInteger(S.getCond(), ConstantCondValue)) { SmallVector CaseStmts; const SwitchCase *Case = nullptr; if (FindCaseStatementsForValue(S, ConstantCondValue, CaseStmts, getContext(), Case)) { if (Case) { RegionCounter CaseCnt = getPGORegionCounter(Case); CaseCnt.beginRegion(Builder); } RunCleanupsScope ExecutedScope(*this); // Emit the condition variable if needed inside the entire cleanup scope // used by this special case for constant folded switches. if (S.getConditionVariable()) EmitAutoVarDecl(*S.getConditionVariable()); // At this point, we are no longer "within" a switch instance, so // we can temporarily enforce this to ensure that any embedded case // statements are not emitted. SwitchInsn = nullptr; // Okay, we can dead code eliminate everything except this case. Emit the // specified series of statements and we're good. for (unsigned i = 0, e = CaseStmts.size(); i != e; ++i) EmitStmt(CaseStmts[i]); RegionCounter ExitCnt = getPGORegionCounter(&S); ExitCnt.beginRegion(Builder); // Now we want to restore the saved switch instance so that nested // switches continue to function properly SwitchInsn = SavedSwitchInsn; return; } } JumpDest SwitchExit = getJumpDestInCurrentScope("sw.epilog"); RunCleanupsScope ConditionScope(*this); if (S.getConditionVariable()) EmitAutoVarDecl(*S.getConditionVariable()); llvm::Value *CondV = EmitScalarExpr(S.getCond()); // Create basic block to hold stuff that comes after switch // statement. We also need to create a default block now so that // explicit case ranges tests can have a place to jump to on // failure. llvm::BasicBlock *DefaultBlock = createBasicBlock("sw.default"); SwitchInsn = Builder.CreateSwitch(CondV, DefaultBlock); if (PGO.haveRegionCounts()) { // Walk the SwitchCase list to find how many there are. uint64_t DefaultCount = 0; unsigned NumCases = 0; for (const SwitchCase *Case = S.getSwitchCaseList(); Case; Case = Case->getNextSwitchCase()) { if (isa(Case)) DefaultCount = getPGORegionCounter(Case).getCount(); NumCases += 1; } SwitchWeights = new SmallVector(); SwitchWeights->reserve(NumCases); // The default needs to be first. We store the edge count, so we already // know the right weight. SwitchWeights->push_back(DefaultCount); } CaseRangeBlock = DefaultBlock; // Clear the insertion point to indicate we are in unreachable code. Builder.ClearInsertionPoint(); // All break statements jump to NextBlock. If BreakContinueStack is non-empty // then reuse last ContinueBlock. JumpDest OuterContinue; if (!BreakContinueStack.empty()) OuterContinue = BreakContinueStack.back().ContinueBlock; BreakContinueStack.push_back(BreakContinue(SwitchExit, OuterContinue)); // Emit switch body. EmitStmt(S.getBody()); BreakContinueStack.pop_back(); // Update the default block in case explicit case range tests have // been chained on top. SwitchInsn->setDefaultDest(CaseRangeBlock); // If a default was never emitted: if (!DefaultBlock->getParent()) { // If we have cleanups, emit the default block so that there's a // place to jump through the cleanups from. if (ConditionScope.requiresCleanups()) { EmitBlock(DefaultBlock); // Otherwise, just forward the default block to the switch end. } else { DefaultBlock->replaceAllUsesWith(SwitchExit.getBlock()); delete DefaultBlock; } } ConditionScope.ForceCleanup(); // Emit continuation. EmitBlock(SwitchExit.getBlock(), true); RegionCounter ExitCnt = getPGORegionCounter(&S); ExitCnt.beginRegion(Builder); if (SwitchWeights) { assert(SwitchWeights->size() == 1 + SwitchInsn->getNumCases() && "switch weights do not match switch cases"); // If there's only one jump destination there's no sense weighting it. if (SwitchWeights->size() > 1) SwitchInsn->setMetadata(llvm::LLVMContext::MD_prof, PGO.createBranchWeights(*SwitchWeights)); delete SwitchWeights; } SwitchInsn = SavedSwitchInsn; SwitchWeights = SavedSwitchWeights; CaseRangeBlock = SavedCRBlock; } static std::string SimplifyConstraint(const char *Constraint, const TargetInfo &Target, SmallVectorImpl *OutCons=nullptr) { std::string Result; while (*Constraint) { switch (*Constraint) { default: Result += Target.convertConstraint(Constraint); break; // Ignore these case '*': case '?': case '!': case '=': // Will see this and the following in mult-alt constraints. case '+': break; case '#': // Ignore the rest of the constraint alternative. while (Constraint[1] && Constraint[1] != ',') Constraint++; break; case ',': Result += "|"; break; case 'g': Result += "imr"; break; case '[': { assert(OutCons && "Must pass output names to constraints with a symbolic name"); unsigned Index; bool result = Target.resolveSymbolicName(Constraint, &(*OutCons)[0], OutCons->size(), Index); assert(result && "Could not resolve symbolic name"); (void)result; Result += llvm::utostr(Index); break; } } Constraint++; } return Result; } /// AddVariableConstraints - Look at AsmExpr and if it is a variable declared /// as using a particular register add that as a constraint that will be used /// in this asm stmt. static std::string AddVariableConstraints(const std::string &Constraint, const Expr &AsmExpr, const TargetInfo &Target, CodeGenModule &CGM, const AsmStmt &Stmt) { const DeclRefExpr *AsmDeclRef = dyn_cast(&AsmExpr); if (!AsmDeclRef) return Constraint; const ValueDecl &Value = *AsmDeclRef->getDecl(); const VarDecl *Variable = dyn_cast(&Value); if (!Variable) return Constraint; if (Variable->getStorageClass() != SC_Register) return Constraint; AsmLabelAttr *Attr = Variable->getAttr(); if (!Attr) return Constraint; StringRef Register = Attr->getLabel(); assert(Target.isValidGCCRegisterName(Register)); // We're using validateOutputConstraint here because we only care if // this is a register constraint. TargetInfo::ConstraintInfo Info(Constraint, ""); if (Target.validateOutputConstraint(Info) && !Info.allowsRegister()) { CGM.ErrorUnsupported(&Stmt, "__asm__"); return Constraint; } // Canonicalize the register here before returning it. Register = Target.getNormalizedGCCRegisterName(Register); return "{" + Register.str() + "}"; } llvm::Value* CodeGenFunction::EmitAsmInputLValue(const TargetInfo::ConstraintInfo &Info, LValue InputValue, QualType InputType, std::string &ConstraintStr, SourceLocation Loc) { llvm::Value *Arg; if (Info.allowsRegister() || !Info.allowsMemory()) { if (CodeGenFunction::hasScalarEvaluationKind(InputType)) { Arg = EmitLoadOfLValue(InputValue, Loc).getScalarVal(); } else { llvm::Type *Ty = ConvertType(InputType); uint64_t Size = CGM.getDataLayout().getTypeSizeInBits(Ty); if (Size <= 64 && llvm::isPowerOf2_64(Size)) { Ty = llvm::IntegerType::get(getLLVMContext(), Size); Ty = llvm::PointerType::getUnqual(Ty); Arg = Builder.CreateLoad(Builder.CreateBitCast(InputValue.getAddress(), Ty)); } else { Arg = InputValue.getAddress(); ConstraintStr += '*'; } } } else { Arg = InputValue.getAddress(); ConstraintStr += '*'; } return Arg; } llvm::Value* CodeGenFunction::EmitAsmInput( const TargetInfo::ConstraintInfo &Info, const Expr *InputExpr, std::string &ConstraintStr) { if (Info.allowsRegister() || !Info.allowsMemory()) if (CodeGenFunction::hasScalarEvaluationKind(InputExpr->getType())) return EmitScalarExpr(InputExpr); InputExpr = InputExpr->IgnoreParenNoopCasts(getContext()); LValue Dest = EmitLValue(InputExpr); return EmitAsmInputLValue(Info, Dest, InputExpr->getType(), ConstraintStr, InputExpr->getExprLoc()); } /// getAsmSrcLocInfo - Return the !srcloc metadata node to attach to an inline /// asm call instruction. The !srcloc MDNode contains a list of constant /// integers which are the source locations of the start of each line in the /// asm. static llvm::MDNode *getAsmSrcLocInfo(const StringLiteral *Str, CodeGenFunction &CGF) { SmallVector Locs; // Add the location of the first line to the MDNode. Locs.push_back(llvm::ConstantInt::get(CGF.Int32Ty, Str->getLocStart().getRawEncoding())); StringRef StrVal = Str->getString(); if (!StrVal.empty()) { const SourceManager &SM = CGF.CGM.getContext().getSourceManager(); const LangOptions &LangOpts = CGF.CGM.getLangOpts(); // Add the location of the start of each subsequent line of the asm to the // MDNode. for (unsigned i = 0, e = StrVal.size()-1; i != e; ++i) { if (StrVal[i] != '\n') continue; SourceLocation LineLoc = Str->getLocationOfByte(i+1, SM, LangOpts, CGF.getTarget()); Locs.push_back(llvm::ConstantInt::get(CGF.Int32Ty, LineLoc.getRawEncoding())); } } return llvm::MDNode::get(CGF.getLLVMContext(), Locs); } void CodeGenFunction::EmitAsmStmt(const AsmStmt &S) { // Assemble the final asm string. std::string AsmString = S.generateAsmString(getContext()); // Get all the output and input constraints together. SmallVector OutputConstraintInfos; SmallVector InputConstraintInfos; for (unsigned i = 0, e = S.getNumOutputs(); i != e; i++) { StringRef Name; if (const GCCAsmStmt *GAS = dyn_cast(&S)) Name = GAS->getOutputName(i); TargetInfo::ConstraintInfo Info(S.getOutputConstraint(i), Name); bool IsValid = getTarget().validateOutputConstraint(Info); (void)IsValid; assert(IsValid && "Failed to parse output constraint"); OutputConstraintInfos.push_back(Info); } for (unsigned i = 0, e = S.getNumInputs(); i != e; i++) { StringRef Name; if (const GCCAsmStmt *GAS = dyn_cast(&S)) Name = GAS->getInputName(i); TargetInfo::ConstraintInfo Info(S.getInputConstraint(i), Name); bool IsValid = getTarget().validateInputConstraint(OutputConstraintInfos.data(), S.getNumOutputs(), Info); assert(IsValid && "Failed to parse input constraint"); (void)IsValid; InputConstraintInfos.push_back(Info); } std::string Constraints; std::vector ResultRegDests; std::vector ResultRegQualTys; std::vector ResultRegTypes; std::vector ResultTruncRegTypes; std::vector ArgTypes; std::vector Args; // Keep track of inout constraints. std::string InOutConstraints; std::vector InOutArgs; std::vector InOutArgTypes; for (unsigned i = 0, e = S.getNumOutputs(); i != e; i++) { TargetInfo::ConstraintInfo &Info = OutputConstraintInfos[i]; // Simplify the output constraint. std::string OutputConstraint(S.getOutputConstraint(i)); OutputConstraint = SimplifyConstraint(OutputConstraint.c_str() + 1, getTarget()); const Expr *OutExpr = S.getOutputExpr(i); OutExpr = OutExpr->IgnoreParenNoopCasts(getContext()); OutputConstraint = AddVariableConstraints(OutputConstraint, *OutExpr, getTarget(), CGM, S); LValue Dest = EmitLValue(OutExpr); if (!Constraints.empty()) Constraints += ','; // If this is a register output, then make the inline asm return it // by-value. If this is a memory result, return the value by-reference. if (!Info.allowsMemory() && hasScalarEvaluationKind(OutExpr->getType())) { Constraints += "=" + OutputConstraint; ResultRegQualTys.push_back(OutExpr->getType()); ResultRegDests.push_back(Dest); ResultRegTypes.push_back(ConvertTypeForMem(OutExpr->getType())); ResultTruncRegTypes.push_back(ResultRegTypes.back()); // If this output is tied to an input, and if the input is larger, then // we need to set the actual result type of the inline asm node to be the // same as the input type. if (Info.hasMatchingInput()) { unsigned InputNo; for (InputNo = 0; InputNo != S.getNumInputs(); ++InputNo) { TargetInfo::ConstraintInfo &Input = InputConstraintInfos[InputNo]; if (Input.hasTiedOperand() && Input.getTiedOperand() == i) break; } assert(InputNo != S.getNumInputs() && "Didn't find matching input!"); QualType InputTy = S.getInputExpr(InputNo)->getType(); QualType OutputType = OutExpr->getType(); uint64_t InputSize = getContext().getTypeSize(InputTy); if (getContext().getTypeSize(OutputType) < InputSize) { // Form the asm to return the value as a larger integer or fp type. ResultRegTypes.back() = ConvertType(InputTy); } } if (llvm::Type* AdjTy = getTargetHooks().adjustInlineAsmType(*this, OutputConstraint, ResultRegTypes.back())) ResultRegTypes.back() = AdjTy; else { CGM.getDiags().Report(S.getAsmLoc(), diag::err_asm_invalid_type_in_input) << OutExpr->getType() << OutputConstraint; } } else { ArgTypes.push_back(Dest.getAddress()->getType()); Args.push_back(Dest.getAddress()); Constraints += "=*"; Constraints += OutputConstraint; } if (Info.isReadWrite()) { InOutConstraints += ','; const Expr *InputExpr = S.getOutputExpr(i); llvm::Value *Arg = EmitAsmInputLValue(Info, Dest, InputExpr->getType(), InOutConstraints, InputExpr->getExprLoc()); if (llvm::Type* AdjTy = getTargetHooks().adjustInlineAsmType(*this, OutputConstraint, Arg->getType())) Arg = Builder.CreateBitCast(Arg, AdjTy); if (Info.allowsRegister()) InOutConstraints += llvm::utostr(i); else InOutConstraints += OutputConstraint; InOutArgTypes.push_back(Arg->getType()); InOutArgs.push_back(Arg); } } unsigned NumConstraints = S.getNumOutputs() + S.getNumInputs(); for (unsigned i = 0, e = S.getNumInputs(); i != e; i++) { const Expr *InputExpr = S.getInputExpr(i); TargetInfo::ConstraintInfo &Info = InputConstraintInfos[i]; if (!Constraints.empty()) Constraints += ','; // Simplify the input constraint. std::string InputConstraint(S.getInputConstraint(i)); InputConstraint = SimplifyConstraint(InputConstraint.c_str(), getTarget(), &OutputConstraintInfos); InputConstraint = AddVariableConstraints(InputConstraint, *InputExpr->IgnoreParenNoopCasts(getContext()), getTarget(), CGM, S); llvm::Value *Arg = EmitAsmInput(Info, InputExpr, Constraints); // If this input argument is tied to a larger output result, extend the // input to be the same size as the output. The LLVM backend wants to see // the input and output of a matching constraint be the same size. Note // that GCC does not define what the top bits are here. We use zext because // that is usually cheaper, but LLVM IR should really get an anyext someday. if (Info.hasTiedOperand()) { unsigned Output = Info.getTiedOperand(); QualType OutputType = S.getOutputExpr(Output)->getType(); QualType InputTy = InputExpr->getType(); if (getContext().getTypeSize(OutputType) > getContext().getTypeSize(InputTy)) { // Use ptrtoint as appropriate so that we can do our extension. if (isa(Arg->getType())) Arg = Builder.CreatePtrToInt(Arg, IntPtrTy); llvm::Type *OutputTy = ConvertType(OutputType); if (isa(OutputTy)) Arg = Builder.CreateZExt(Arg, OutputTy); else if (isa(OutputTy)) Arg = Builder.CreateZExt(Arg, IntPtrTy); else { assert(OutputTy->isFloatingPointTy() && "Unexpected output type"); Arg = Builder.CreateFPExt(Arg, OutputTy); } } } if (llvm::Type* AdjTy = getTargetHooks().adjustInlineAsmType(*this, InputConstraint, Arg->getType())) Arg = Builder.CreateBitCast(Arg, AdjTy); else CGM.getDiags().Report(S.getAsmLoc(), diag::err_asm_invalid_type_in_input) << InputExpr->getType() << InputConstraint; ArgTypes.push_back(Arg->getType()); Args.push_back(Arg); Constraints += InputConstraint; } // Append the "input" part of inout constraints last. for (unsigned i = 0, e = InOutArgs.size(); i != e; i++) { ArgTypes.push_back(InOutArgTypes[i]); Args.push_back(InOutArgs[i]); } Constraints += InOutConstraints; // Clobbers for (unsigned i = 0, e = S.getNumClobbers(); i != e; i++) { StringRef Clobber = S.getClobber(i); if (Clobber != "memory" && Clobber != "cc") Clobber = getTarget().getNormalizedGCCRegisterName(Clobber); if (i != 0 || NumConstraints != 0) Constraints += ','; Constraints += "~{"; Constraints += Clobber; Constraints += '}'; } // Add machine specific clobbers std::string MachineClobbers = getTarget().getClobbers(); if (!MachineClobbers.empty()) { if (!Constraints.empty()) Constraints += ','; Constraints += MachineClobbers; } llvm::Type *ResultType; if (ResultRegTypes.empty()) ResultType = VoidTy; else if (ResultRegTypes.size() == 1) ResultType = ResultRegTypes[0]; else ResultType = llvm::StructType::get(getLLVMContext(), ResultRegTypes); llvm::FunctionType *FTy = llvm::FunctionType::get(ResultType, ArgTypes, false); bool HasSideEffect = S.isVolatile() || S.getNumOutputs() == 0; llvm::InlineAsm::AsmDialect AsmDialect = isa(&S) ? llvm::InlineAsm::AD_Intel : llvm::InlineAsm::AD_ATT; llvm::InlineAsm *IA = llvm::InlineAsm::get(FTy, AsmString, Constraints, HasSideEffect, /* IsAlignStack */ false, AsmDialect); llvm::CallInst *Result = Builder.CreateCall(IA, Args); Result->addAttribute(llvm::AttributeSet::FunctionIndex, llvm::Attribute::NoUnwind); // Slap the source location of the inline asm into a !srcloc metadata on the // call. if (const GCCAsmStmt *gccAsmStmt = dyn_cast(&S)) { Result->setMetadata("srcloc", getAsmSrcLocInfo(gccAsmStmt->getAsmString(), *this)); } else { // At least put the line number on MS inline asm blobs. auto Loc = llvm::ConstantInt::get(Int32Ty, S.getAsmLoc().getRawEncoding()); Result->setMetadata("srcloc", llvm::MDNode::get(getLLVMContext(), Loc)); } // Extract all of the register value results from the asm. std::vector RegResults; if (ResultRegTypes.size() == 1) { RegResults.push_back(Result); } else { for (unsigned i = 0, e = ResultRegTypes.size(); i != e; ++i) { llvm::Value *Tmp = Builder.CreateExtractValue(Result, i, "asmresult"); RegResults.push_back(Tmp); } } for (unsigned i = 0, e = RegResults.size(); i != e; ++i) { llvm::Value *Tmp = RegResults[i]; // If the result type of the LLVM IR asm doesn't match the result type of // the expression, do the conversion. if (ResultRegTypes[i] != ResultTruncRegTypes[i]) { llvm::Type *TruncTy = ResultTruncRegTypes[i]; // Truncate the integer result to the right size, note that TruncTy can be // a pointer. if (TruncTy->isFloatingPointTy()) Tmp = Builder.CreateFPTrunc(Tmp, TruncTy); else if (TruncTy->isPointerTy() && Tmp->getType()->isIntegerTy()) { uint64_t ResSize = CGM.getDataLayout().getTypeSizeInBits(TruncTy); Tmp = Builder.CreateTrunc(Tmp, llvm::IntegerType::get(getLLVMContext(), (unsigned)ResSize)); Tmp = Builder.CreateIntToPtr(Tmp, TruncTy); } else if (Tmp->getType()->isPointerTy() && TruncTy->isIntegerTy()) { uint64_t TmpSize =CGM.getDataLayout().getTypeSizeInBits(Tmp->getType()); Tmp = Builder.CreatePtrToInt(Tmp, llvm::IntegerType::get(getLLVMContext(), (unsigned)TmpSize)); Tmp = Builder.CreateTrunc(Tmp, TruncTy); } else if (TruncTy->isIntegerTy()) { Tmp = Builder.CreateTrunc(Tmp, TruncTy); } else if (TruncTy->isVectorTy()) { Tmp = Builder.CreateBitCast(Tmp, TruncTy); } } EmitStoreThroughLValue(RValue::get(Tmp), ResultRegDests[i]); } } static LValue InitCapturedStruct(CodeGenFunction &CGF, const CapturedStmt &S) { const RecordDecl *RD = S.getCapturedRecordDecl(); QualType RecordTy = CGF.getContext().getRecordType(RD); // Initialize the captured struct. LValue SlotLV = CGF.MakeNaturalAlignAddrLValue( CGF.CreateMemTemp(RecordTy, "agg.captured"), RecordTy); RecordDecl::field_iterator CurField = RD->field_begin(); for (CapturedStmt::capture_init_iterator I = S.capture_init_begin(), E = S.capture_init_end(); I != E; ++I, ++CurField) { LValue LV = CGF.EmitLValueForFieldInitialization(SlotLV, *CurField); CGF.EmitInitializerForField(*CurField, LV, *I, ArrayRef()); } return SlotLV; } static void InitVLACaptures(CodeGenFunction &CGF, const CapturedStmt &S) { for (auto &C : S.captures()) { if (C.capturesVariable()) { QualType QTy; auto VD = C.getCapturedVar(); if (const ParmVarDecl *PVD = dyn_cast(VD)) QTy = PVD->getOriginalType(); else QTy = VD->getType(); if (QTy->isVariablyModifiedType()) { CGF.EmitVariablyModifiedType(QTy); } } } } /// Generate an outlined function for the body of a CapturedStmt, store any /// captured variables into the captured struct, and call the outlined function. llvm::Function * CodeGenFunction::EmitCapturedStmt(const CapturedStmt &S, CapturedRegionKind K) { LValue CapStruct = InitCapturedStruct(*this, S); // Emit the CapturedDecl CodeGenFunction CGF(CGM, true); CGF.CapturedStmtInfo = new CGCapturedStmtInfo(S, K); llvm::Function *F = CGF.GenerateCapturedStmtFunction(S); delete CGF.CapturedStmtInfo; // Emit call to the helper function. EmitCallOrInvoke(F, CapStruct.getAddress()); return F; } llvm::Value * CodeGenFunction::GenerateCapturedStmtArgument(const CapturedStmt &S) { LValue CapStruct = InitCapturedStruct(*this, S); return CapStruct.getAddress(); } /// Creates the outlined function for a CapturedStmt. llvm::Function * CodeGenFunction::GenerateCapturedStmtFunction(const CapturedStmt &S) { assert(CapturedStmtInfo && "CapturedStmtInfo should be set when generating the captured function"); const CapturedDecl *CD = S.getCapturedDecl(); const RecordDecl *RD = S.getCapturedRecordDecl(); SourceLocation Loc = S.getLocStart(); assert(CD->hasBody() && "missing CapturedDecl body"); // Build the argument list. ASTContext &Ctx = CGM.getContext(); FunctionArgList Args; Args.append(CD->param_begin(), CD->param_end()); // Create the function declaration. FunctionType::ExtInfo ExtInfo; const CGFunctionInfo &FuncInfo = CGM.getTypes().arrangeFreeFunctionDeclaration(Ctx.VoidTy, Args, ExtInfo, /*IsVariadic=*/false); llvm::FunctionType *FuncLLVMTy = CGM.getTypes().GetFunctionType(FuncInfo); llvm::Function *F = llvm::Function::Create(FuncLLVMTy, llvm::GlobalValue::InternalLinkage, CapturedStmtInfo->getHelperName(), &CGM.getModule()); CGM.SetInternalFunctionAttributes(CD, F, FuncInfo); // Generate the function. StartFunction(CD, Ctx.VoidTy, F, FuncInfo, Args, CD->getLocation(), CD->getBody()->getLocStart()); // Set the context parameter in CapturedStmtInfo. llvm::Value *DeclPtr = LocalDeclMap[CD->getContextParam()]; assert(DeclPtr && "missing context parameter for CapturedStmt"); CapturedStmtInfo->setContextValue(Builder.CreateLoad(DeclPtr)); // Initialize variable-length arrays. InitVLACaptures(*this, S); // If 'this' is captured, load it into CXXThisValue. if (CapturedStmtInfo->isCXXThisExprCaptured()) { FieldDecl *FD = CapturedStmtInfo->getThisFieldDecl(); LValue LV = MakeNaturalAlignAddrLValue(CapturedStmtInfo->getContextValue(), Ctx.getTagDeclType(RD)); LValue ThisLValue = EmitLValueForField(LV, FD); CXXThisValue = EmitLoadOfLValue(ThisLValue, Loc).getScalarVal(); } PGO.assignRegionCounters(CD, F); CapturedStmtInfo->EmitBody(*this, CD->getBody()); FinishFunction(CD->getBodyRBrace()); PGO.emitInstrumentationData(); PGO.destroyRegionCounters(); return F; } @ 1.1.1.5.4.1 log @file CGStmt.cpp was added on branch yamt-pagecache on 2014-05-22 16:18:27 +0000 @ text @d1 1969 @ 1.1.1.5.4.2 log @sync with head. for a reference, the tree before this commit was tagged as yamt-pagecache-tag8. this commit was splitted into small chunks to avoid a limitation of cvs. ("Protocol error: too many arguments") @ text @a0 1969 //===--- CGStmt.cpp - Emit LLVM Code from Statements ----------------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This contains code to emit Stmt nodes as LLVM code. // //===----------------------------------------------------------------------===// #include "CodeGenFunction.h" #include "CGDebugInfo.h" #include "CodeGenModule.h" #include "TargetInfo.h" #include "clang/AST/StmtVisitor.h" #include "clang/Basic/PrettyStackTrace.h" #include "clang/Basic/TargetInfo.h" #include "clang/Sema/SemaDiagnostic.h" #include "llvm/ADT/StringExtras.h" #include "llvm/IR/DataLayout.h" #include "llvm/IR/InlineAsm.h" #include "llvm/IR/Intrinsics.h" #include "llvm/Support/CallSite.h" using namespace clang; using namespace CodeGen; //===----------------------------------------------------------------------===// // Statement Emission //===----------------------------------------------------------------------===// void CodeGenFunction::EmitStopPoint(const Stmt *S) { if (CGDebugInfo *DI = getDebugInfo()) { SourceLocation Loc; Loc = S->getLocStart(); DI->EmitLocation(Builder, Loc); LastStopPoint = Loc; } } void CodeGenFunction::EmitStmt(const Stmt *S) { assert(S && "Null statement?"); PGO.setCurrentStmt(S); // These statements have their own debug info handling. if (EmitSimpleStmt(S)) return; // Check if we are generating unreachable code. if (!HaveInsertPoint()) { // If so, and the statement doesn't contain a label, then we do not need to // generate actual code. This is safe because (1) the current point is // unreachable, so we don't need to execute the code, and (2) we've already // handled the statements which update internal data structures (like the // local variable map) which could be used by subsequent statements. if (!ContainsLabel(S)) { // Verify that any decl statements were handled as simple, they may be in // scope of subsequent reachable statements. assert(!isa(*S) && "Unexpected DeclStmt!"); return; } // Otherwise, make a new block to hold the code. EnsureInsertPoint(); } // Generate a stoppoint if we are emitting debug info. EmitStopPoint(S); switch (S->getStmtClass()) { case Stmt::NoStmtClass: case Stmt::CXXCatchStmtClass: case Stmt::SEHExceptStmtClass: case Stmt::SEHFinallyStmtClass: case Stmt::MSDependentExistsStmtClass: case Stmt::OMPParallelDirectiveClass: case Stmt::OMPSimdDirectiveClass: llvm_unreachable("invalid statement class to emit generically"); case Stmt::NullStmtClass: case Stmt::CompoundStmtClass: case Stmt::DeclStmtClass: case Stmt::LabelStmtClass: case Stmt::AttributedStmtClass: case Stmt::GotoStmtClass: case Stmt::BreakStmtClass: case Stmt::ContinueStmtClass: case Stmt::DefaultStmtClass: case Stmt::CaseStmtClass: llvm_unreachable("should have emitted these statements as simple"); #define STMT(Type, Base) #define ABSTRACT_STMT(Op) #define EXPR(Type, Base) \ case Stmt::Type##Class: #include "clang/AST/StmtNodes.inc" { // Remember the block we came in on. llvm::BasicBlock *incoming = Builder.GetInsertBlock(); assert(incoming && "expression emission must have an insertion point"); EmitIgnoredExpr(cast(S)); llvm::BasicBlock *outgoing = Builder.GetInsertBlock(); assert(outgoing && "expression emission cleared block!"); // The expression emitters assume (reasonably!) that the insertion // point is always set. To maintain that, the call-emission code // for noreturn functions has to enter a new block with no // predecessors. We want to kill that block and mark the current // insertion point unreachable in the common case of a call like // "exit();". Since expression emission doesn't otherwise create // blocks with no predecessors, we can just test for that. // However, we must be careful not to do this to our incoming // block, because *statement* emission does sometimes create // reachable blocks which will have no predecessors until later in // the function. This occurs with, e.g., labels that are not // reachable by fallthrough. if (incoming != outgoing && outgoing->use_empty()) { outgoing->eraseFromParent(); Builder.ClearInsertionPoint(); } break; } case Stmt::IndirectGotoStmtClass: EmitIndirectGotoStmt(cast(*S)); break; case Stmt::IfStmtClass: EmitIfStmt(cast(*S)); break; case Stmt::WhileStmtClass: EmitWhileStmt(cast(*S)); break; case Stmt::DoStmtClass: EmitDoStmt(cast(*S)); break; case Stmt::ForStmtClass: EmitForStmt(cast(*S)); break; case Stmt::ReturnStmtClass: EmitReturnStmt(cast(*S)); break; case Stmt::SwitchStmtClass: EmitSwitchStmt(cast(*S)); break; case Stmt::GCCAsmStmtClass: // Intentional fall-through. case Stmt::MSAsmStmtClass: EmitAsmStmt(cast(*S)); break; case Stmt::CapturedStmtClass: { const CapturedStmt *CS = cast(S); EmitCapturedStmt(*CS, CS->getCapturedRegionKind()); } break; case Stmt::ObjCAtTryStmtClass: EmitObjCAtTryStmt(cast(*S)); break; case Stmt::ObjCAtCatchStmtClass: llvm_unreachable( "@@catch statements should be handled by EmitObjCAtTryStmt"); case Stmt::ObjCAtFinallyStmtClass: llvm_unreachable( "@@finally statements should be handled by EmitObjCAtTryStmt"); case Stmt::ObjCAtThrowStmtClass: EmitObjCAtThrowStmt(cast(*S)); break; case Stmt::ObjCAtSynchronizedStmtClass: EmitObjCAtSynchronizedStmt(cast(*S)); break; case Stmt::ObjCForCollectionStmtClass: EmitObjCForCollectionStmt(cast(*S)); break; case Stmt::ObjCAutoreleasePoolStmtClass: EmitObjCAutoreleasePoolStmt(cast(*S)); break; case Stmt::CXXTryStmtClass: EmitCXXTryStmt(cast(*S)); break; case Stmt::CXXForRangeStmtClass: EmitCXXForRangeStmt(cast(*S)); break; case Stmt::SEHTryStmtClass: EmitSEHTryStmt(cast(*S)); break; } } bool CodeGenFunction::EmitSimpleStmt(const Stmt *S) { switch (S->getStmtClass()) { default: return false; case Stmt::NullStmtClass: break; case Stmt::CompoundStmtClass: EmitCompoundStmt(cast(*S)); break; case Stmt::DeclStmtClass: EmitDeclStmt(cast(*S)); break; case Stmt::LabelStmtClass: EmitLabelStmt(cast(*S)); break; case Stmt::AttributedStmtClass: EmitAttributedStmt(cast(*S)); break; case Stmt::GotoStmtClass: EmitGotoStmt(cast(*S)); break; case Stmt::BreakStmtClass: EmitBreakStmt(cast(*S)); break; case Stmt::ContinueStmtClass: EmitContinueStmt(cast(*S)); break; case Stmt::DefaultStmtClass: EmitDefaultStmt(cast(*S)); break; case Stmt::CaseStmtClass: EmitCaseStmt(cast(*S)); break; } return true; } /// EmitCompoundStmt - Emit a compound statement {..} node. If GetLast is true, /// this captures the expression result of the last sub-statement and returns it /// (for use by the statement expression extension). llvm::Value* CodeGenFunction::EmitCompoundStmt(const CompoundStmt &S, bool GetLast, AggValueSlot AggSlot) { PrettyStackTraceLoc CrashInfo(getContext().getSourceManager(),S.getLBracLoc(), "LLVM IR generation of compound statement ('{}')"); // Keep track of the current cleanup stack depth, including debug scopes. LexicalScope Scope(*this, S.getSourceRange()); return EmitCompoundStmtWithoutScope(S, GetLast, AggSlot); } llvm::Value* CodeGenFunction::EmitCompoundStmtWithoutScope(const CompoundStmt &S, bool GetLast, AggValueSlot AggSlot) { for (CompoundStmt::const_body_iterator I = S.body_begin(), E = S.body_end()-GetLast; I != E; ++I) EmitStmt(*I); llvm::Value *RetAlloca = 0; if (GetLast) { // We have to special case labels here. They are statements, but when put // at the end of a statement expression, they yield the value of their // subexpression. Handle this by walking through all labels we encounter, // emitting them before we evaluate the subexpr. const Stmt *LastStmt = S.body_back(); while (const LabelStmt *LS = dyn_cast(LastStmt)) { EmitLabel(LS->getDecl()); LastStmt = LS->getSubStmt(); } EnsureInsertPoint(); QualType ExprTy = cast(LastStmt)->getType(); if (hasAggregateEvaluationKind(ExprTy)) { EmitAggExpr(cast(LastStmt), AggSlot); } else { // We can't return an RValue here because there might be cleanups at // the end of the StmtExpr. Because of that, we have to emit the result // here into a temporary alloca. RetAlloca = CreateMemTemp(ExprTy); EmitAnyExprToMem(cast(LastStmt), RetAlloca, Qualifiers(), /*IsInit*/false); } } return RetAlloca; } void CodeGenFunction::SimplifyForwardingBlocks(llvm::BasicBlock *BB) { llvm::BranchInst *BI = dyn_cast(BB->getTerminator()); // If there is a cleanup stack, then we it isn't worth trying to // simplify this block (we would need to remove it from the scope map // and cleanup entry). if (!EHStack.empty()) return; // Can only simplify direct branches. if (!BI || !BI->isUnconditional()) return; // Can only simplify empty blocks. if (BI != BB->begin()) return; BB->replaceAllUsesWith(BI->getSuccessor(0)); BI->eraseFromParent(); BB->eraseFromParent(); } void CodeGenFunction::EmitBlock(llvm::BasicBlock *BB, bool IsFinished) { llvm::BasicBlock *CurBB = Builder.GetInsertBlock(); // Fall out of the current block (if necessary). EmitBranch(BB); if (IsFinished && BB->use_empty()) { delete BB; return; } // Place the block after the current block, if possible, or else at // the end of the function. if (CurBB && CurBB->getParent()) CurFn->getBasicBlockList().insertAfter(CurBB, BB); else CurFn->getBasicBlockList().push_back(BB); Builder.SetInsertPoint(BB); } void CodeGenFunction::EmitBranch(llvm::BasicBlock *Target) { // Emit a branch from the current block to the target one if this // was a real block. If this was just a fall-through block after a // terminator, don't emit it. llvm::BasicBlock *CurBB = Builder.GetInsertBlock(); if (!CurBB || CurBB->getTerminator()) { // If there is no insert point or the previous block is already // terminated, don't touch it. } else { // Otherwise, create a fall-through branch. Builder.CreateBr(Target); } Builder.ClearInsertionPoint(); } void CodeGenFunction::EmitBlockAfterUses(llvm::BasicBlock *block) { bool inserted = false; for (llvm::BasicBlock::use_iterator i = block->use_begin(), e = block->use_end(); i != e; ++i) { if (llvm::Instruction *insn = dyn_cast(*i)) { CurFn->getBasicBlockList().insertAfter(insn->getParent(), block); inserted = true; break; } } if (!inserted) CurFn->getBasicBlockList().push_back(block); Builder.SetInsertPoint(block); } CodeGenFunction::JumpDest CodeGenFunction::getJumpDestForLabel(const LabelDecl *D) { JumpDest &Dest = LabelMap[D]; if (Dest.isValid()) return Dest; // Create, but don't insert, the new block. Dest = JumpDest(createBasicBlock(D->getName()), EHScopeStack::stable_iterator::invalid(), NextCleanupDestIndex++); return Dest; } void CodeGenFunction::EmitLabel(const LabelDecl *D) { // Add this label to the current lexical scope if we're within any // normal cleanups. Jumps "in" to this label --- when permitted by // the language --- may need to be routed around such cleanups. if (EHStack.hasNormalCleanups() && CurLexicalScope) CurLexicalScope->addLabel(D); JumpDest &Dest = LabelMap[D]; // If we didn't need a forward reference to this label, just go // ahead and create a destination at the current scope. if (!Dest.isValid()) { Dest = getJumpDestInCurrentScope(D->getName()); // Otherwise, we need to give this label a target depth and remove // it from the branch-fixups list. } else { assert(!Dest.getScopeDepth().isValid() && "already emitted label!"); Dest.setScopeDepth(EHStack.stable_begin()); ResolveBranchFixups(Dest.getBlock()); } RegionCounter Cnt = getPGORegionCounter(D->getStmt()); EmitBlock(Dest.getBlock()); Cnt.beginRegion(Builder); } /// Change the cleanup scope of the labels in this lexical scope to /// match the scope of the enclosing context. void CodeGenFunction::LexicalScope::rescopeLabels() { assert(!Labels.empty()); EHScopeStack::stable_iterator innermostScope = CGF.EHStack.getInnermostNormalCleanup(); // Change the scope depth of all the labels. for (SmallVectorImpl::const_iterator i = Labels.begin(), e = Labels.end(); i != e; ++i) { assert(CGF.LabelMap.count(*i)); JumpDest &dest = CGF.LabelMap.find(*i)->second; assert(dest.getScopeDepth().isValid()); assert(innermostScope.encloses(dest.getScopeDepth())); dest.setScopeDepth(innermostScope); } // Reparent the labels if the new scope also has cleanups. if (innermostScope != EHScopeStack::stable_end() && ParentScope) { ParentScope->Labels.append(Labels.begin(), Labels.end()); } } void CodeGenFunction::EmitLabelStmt(const LabelStmt &S) { EmitLabel(S.getDecl()); EmitStmt(S.getSubStmt()); } void CodeGenFunction::EmitAttributedStmt(const AttributedStmt &S) { EmitStmt(S.getSubStmt()); } void CodeGenFunction::EmitGotoStmt(const GotoStmt &S) { // If this code is reachable then emit a stop point (if generating // debug info). We have to do this ourselves because we are on the // "simple" statement path. if (HaveInsertPoint()) EmitStopPoint(&S); EmitBranchThroughCleanup(getJumpDestForLabel(S.getLabel())); } void CodeGenFunction::EmitIndirectGotoStmt(const IndirectGotoStmt &S) { if (const LabelDecl *Target = S.getConstantTarget()) { EmitBranchThroughCleanup(getJumpDestForLabel(Target)); return; } // Ensure that we have an i8* for our PHI node. llvm::Value *V = Builder.CreateBitCast(EmitScalarExpr(S.getTarget()), Int8PtrTy, "addr"); llvm::BasicBlock *CurBB = Builder.GetInsertBlock(); // Get the basic block for the indirect goto. llvm::BasicBlock *IndGotoBB = GetIndirectGotoBlock(); // The first instruction in the block has to be the PHI for the switch dest, // add an entry for this branch. cast(IndGotoBB->begin())->addIncoming(V, CurBB); EmitBranch(IndGotoBB); } void CodeGenFunction::EmitIfStmt(const IfStmt &S) { // C99 6.8.4.1: The first substatement is executed if the expression compares // unequal to 0. The condition must be a scalar type. LexicalScope ConditionScope(*this, S.getSourceRange()); RegionCounter Cnt = getPGORegionCounter(&S); if (S.getConditionVariable()) EmitAutoVarDecl(*S.getConditionVariable()); // If the condition constant folds and can be elided, try to avoid emitting // the condition and the dead arm of the if/else. bool CondConstant; if (ConstantFoldsToSimpleInteger(S.getCond(), CondConstant)) { // Figure out which block (then or else) is executed. const Stmt *Executed = S.getThen(); const Stmt *Skipped = S.getElse(); if (!CondConstant) // Condition false? std::swap(Executed, Skipped); // If the skipped block has no labels in it, just emit the executed block. // This avoids emitting dead code and simplifies the CFG substantially. if (!ContainsLabel(Skipped)) { if (CondConstant) Cnt.beginRegion(Builder); if (Executed) { RunCleanupsScope ExecutedScope(*this); EmitStmt(Executed); } return; } } // Otherwise, the condition did not fold, or we couldn't elide it. Just emit // the conditional branch. llvm::BasicBlock *ThenBlock = createBasicBlock("if.then"); llvm::BasicBlock *ContBlock = createBasicBlock("if.end"); llvm::BasicBlock *ElseBlock = ContBlock; if (S.getElse()) ElseBlock = createBasicBlock("if.else"); EmitBranchOnBoolExpr(S.getCond(), ThenBlock, ElseBlock, Cnt.getCount()); // Emit the 'then' code. EmitBlock(ThenBlock); Cnt.beginRegion(Builder); { RunCleanupsScope ThenScope(*this); EmitStmt(S.getThen()); } EmitBranch(ContBlock); // Emit the 'else' code if present. if (const Stmt *Else = S.getElse()) { // There is no need to emit line number for unconditional branch. if (getDebugInfo()) Builder.SetCurrentDebugLocation(llvm::DebugLoc()); EmitBlock(ElseBlock); { RunCleanupsScope ElseScope(*this); EmitStmt(Else); } // There is no need to emit line number for unconditional branch. if (getDebugInfo()) Builder.SetCurrentDebugLocation(llvm::DebugLoc()); EmitBranch(ContBlock); } // Emit the continuation block for code after the if. EmitBlock(ContBlock, true); } void CodeGenFunction::EmitWhileStmt(const WhileStmt &S) { RegionCounter Cnt = getPGORegionCounter(&S); // Emit the header for the loop, which will also become // the continue target. JumpDest LoopHeader = getJumpDestInCurrentScope("while.cond"); EmitBlock(LoopHeader.getBlock()); // Create an exit block for when the condition fails, which will // also become the break target. JumpDest LoopExit = getJumpDestInCurrentScope("while.end"); // Store the blocks to use for break and continue. BreakContinueStack.push_back(BreakContinue(LoopExit, LoopHeader)); // C++ [stmt.while]p2: // When the condition of a while statement is a declaration, the // scope of the variable that is declared extends from its point // of declaration (3.3.2) to the end of the while statement. // [...] // The object created in a condition is destroyed and created // with each iteration of the loop. RunCleanupsScope ConditionScope(*this); if (S.getConditionVariable()) EmitAutoVarDecl(*S.getConditionVariable()); // Evaluate the conditional in the while header. C99 6.8.5.1: The // evaluation of the controlling expression takes place before each // execution of the loop body. llvm::Value *BoolCondVal = EvaluateExprAsBool(S.getCond()); // while(1) is common, avoid extra exit blocks. Be sure // to correctly handle break/continue though. bool EmitBoolCondBranch = true; if (llvm::ConstantInt *C = dyn_cast(BoolCondVal)) if (C->isOne()) EmitBoolCondBranch = false; // As long as the condition is true, go to the loop body. llvm::BasicBlock *LoopBody = createBasicBlock("while.body"); if (EmitBoolCondBranch) { llvm::BasicBlock *ExitBlock = LoopExit.getBlock(); if (ConditionScope.requiresCleanups()) ExitBlock = createBasicBlock("while.exit"); Builder.CreateCondBr(BoolCondVal, LoopBody, ExitBlock, PGO.createLoopWeights(S.getCond(), Cnt)); if (ExitBlock != LoopExit.getBlock()) { EmitBlock(ExitBlock); EmitBranchThroughCleanup(LoopExit); } } // Emit the loop body. We have to emit this in a cleanup scope // because it might be a singleton DeclStmt. { RunCleanupsScope BodyScope(*this); EmitBlock(LoopBody); Cnt.beginRegion(Builder); EmitStmt(S.getBody()); } BreakContinueStack.pop_back(); // Immediately force cleanup. ConditionScope.ForceCleanup(); // Branch to the loop header again. EmitBranch(LoopHeader.getBlock()); // Emit the exit block. EmitBlock(LoopExit.getBlock(), true); // The LoopHeader typically is just a branch if we skipped emitting // a branch, try to erase it. if (!EmitBoolCondBranch) SimplifyForwardingBlocks(LoopHeader.getBlock()); } void CodeGenFunction::EmitDoStmt(const DoStmt &S) { JumpDest LoopExit = getJumpDestInCurrentScope("do.end"); JumpDest LoopCond = getJumpDestInCurrentScope("do.cond"); RegionCounter Cnt = getPGORegionCounter(&S); // Store the blocks to use for break and continue. BreakContinueStack.push_back(BreakContinue(LoopExit, LoopCond)); // Emit the body of the loop. llvm::BasicBlock *LoopBody = createBasicBlock("do.body"); EmitBlockWithFallThrough(LoopBody, Cnt); { RunCleanupsScope BodyScope(*this); EmitStmt(S.getBody()); } EmitBlock(LoopCond.getBlock()); // C99 6.8.5.2: "The evaluation of the controlling expression takes place // after each execution of the loop body." // Evaluate the conditional in the while header. // C99 6.8.5p2/p4: The first substatement is executed if the expression // compares unequal to 0. The condition must be a scalar type. llvm::Value *BoolCondVal = EvaluateExprAsBool(S.getCond()); BreakContinueStack.pop_back(); // "do {} while (0)" is common in macros, avoid extra blocks. Be sure // to correctly handle break/continue though. bool EmitBoolCondBranch = true; if (llvm::ConstantInt *C = dyn_cast(BoolCondVal)) if (C->isZero()) EmitBoolCondBranch = false; // As long as the condition is true, iterate the loop. if (EmitBoolCondBranch) Builder.CreateCondBr(BoolCondVal, LoopBody, LoopExit.getBlock(), PGO.createLoopWeights(S.getCond(), Cnt)); // Emit the exit block. EmitBlock(LoopExit.getBlock()); // The DoCond block typically is just a branch if we skipped // emitting a branch, try to erase it. if (!EmitBoolCondBranch) SimplifyForwardingBlocks(LoopCond.getBlock()); } void CodeGenFunction::EmitForStmt(const ForStmt &S) { JumpDest LoopExit = getJumpDestInCurrentScope("for.end"); RunCleanupsScope ForScope(*this); CGDebugInfo *DI = getDebugInfo(); if (DI) DI->EmitLexicalBlockStart(Builder, S.getSourceRange().getBegin()); // Evaluate the first part before the loop. if (S.getInit()) EmitStmt(S.getInit()); RegionCounter Cnt = getPGORegionCounter(&S); // Start the loop with a block that tests the condition. // If there's an increment, the continue scope will be overwritten // later. JumpDest Continue = getJumpDestInCurrentScope("for.cond"); llvm::BasicBlock *CondBlock = Continue.getBlock(); EmitBlock(CondBlock); // If the for loop doesn't have an increment we can just use the // condition as the continue block. Otherwise we'll need to create // a block for it (in the current scope, i.e. in the scope of the // condition), and that we will become our continue block. if (S.getInc()) Continue = getJumpDestInCurrentScope("for.inc"); // Store the blocks to use for break and continue. BreakContinueStack.push_back(BreakContinue(LoopExit, Continue)); // Create a cleanup scope for the condition variable cleanups. RunCleanupsScope ConditionScope(*this); if (S.getCond()) { // If the for statement has a condition scope, emit the local variable // declaration. if (S.getConditionVariable()) { EmitAutoVarDecl(*S.getConditionVariable()); } llvm::BasicBlock *ExitBlock = LoopExit.getBlock(); // If there are any cleanups between here and the loop-exit scope, // create a block to stage a loop exit along. if (ForScope.requiresCleanups()) ExitBlock = createBasicBlock("for.cond.cleanup"); // As long as the condition is true, iterate the loop. llvm::BasicBlock *ForBody = createBasicBlock("for.body"); // C99 6.8.5p2/p4: The first substatement is executed if the expression // compares unequal to 0. The condition must be a scalar type. llvm::Value *BoolCondVal = EvaluateExprAsBool(S.getCond()); Builder.CreateCondBr(BoolCondVal, ForBody, ExitBlock, PGO.createLoopWeights(S.getCond(), Cnt)); if (ExitBlock != LoopExit.getBlock()) { EmitBlock(ExitBlock); EmitBranchThroughCleanup(LoopExit); } EmitBlock(ForBody); } else { // Treat it as a non-zero constant. Don't even create a new block for the // body, just fall into it. } Cnt.beginRegion(Builder); { // Create a separate cleanup scope for the body, in case it is not // a compound statement. RunCleanupsScope BodyScope(*this); EmitStmt(S.getBody()); } // If there is an increment, emit it next. if (S.getInc()) { EmitBlock(Continue.getBlock()); EmitStmt(S.getInc()); } BreakContinueStack.pop_back(); ConditionScope.ForceCleanup(); EmitBranch(CondBlock); ForScope.ForceCleanup(); if (DI) DI->EmitLexicalBlockEnd(Builder, S.getSourceRange().getEnd()); // Emit the fall-through block. EmitBlock(LoopExit.getBlock(), true); } void CodeGenFunction::EmitCXXForRangeStmt(const CXXForRangeStmt &S) { JumpDest LoopExit = getJumpDestInCurrentScope("for.end"); RunCleanupsScope ForScope(*this); CGDebugInfo *DI = getDebugInfo(); if (DI) DI->EmitLexicalBlockStart(Builder, S.getSourceRange().getBegin()); // Evaluate the first pieces before the loop. EmitStmt(S.getRangeStmt()); EmitStmt(S.getBeginEndStmt()); RegionCounter Cnt = getPGORegionCounter(&S); // Start the loop with a block that tests the condition. // If there's an increment, the continue scope will be overwritten // later. llvm::BasicBlock *CondBlock = createBasicBlock("for.cond"); EmitBlock(CondBlock); // If there are any cleanups between here and the loop-exit scope, // create a block to stage a loop exit along. llvm::BasicBlock *ExitBlock = LoopExit.getBlock(); if (ForScope.requiresCleanups()) ExitBlock = createBasicBlock("for.cond.cleanup"); // The loop body, consisting of the specified body and the loop variable. llvm::BasicBlock *ForBody = createBasicBlock("for.body"); // The body is executed if the expression, contextually converted // to bool, is true. llvm::Value *BoolCondVal = EvaluateExprAsBool(S.getCond()); Builder.CreateCondBr(BoolCondVal, ForBody, ExitBlock, PGO.createLoopWeights(S.getCond(), Cnt)); if (ExitBlock != LoopExit.getBlock()) { EmitBlock(ExitBlock); EmitBranchThroughCleanup(LoopExit); } EmitBlock(ForBody); Cnt.beginRegion(Builder); // Create a block for the increment. In case of a 'continue', we jump there. JumpDest Continue = getJumpDestInCurrentScope("for.inc"); // Store the blocks to use for break and continue. BreakContinueStack.push_back(BreakContinue(LoopExit, Continue)); { // Create a separate cleanup scope for the loop variable and body. RunCleanupsScope BodyScope(*this); EmitStmt(S.getLoopVarStmt()); EmitStmt(S.getBody()); } // If there is an increment, emit it next. EmitBlock(Continue.getBlock()); EmitStmt(S.getInc()); BreakContinueStack.pop_back(); EmitBranch(CondBlock); ForScope.ForceCleanup(); if (DI) DI->EmitLexicalBlockEnd(Builder, S.getSourceRange().getEnd()); // Emit the fall-through block. EmitBlock(LoopExit.getBlock(), true); } void CodeGenFunction::EmitReturnOfRValue(RValue RV, QualType Ty) { if (RV.isScalar()) { Builder.CreateStore(RV.getScalarVal(), ReturnValue); } else if (RV.isAggregate()) { EmitAggregateCopy(ReturnValue, RV.getAggregateAddr(), Ty); } else { EmitStoreOfComplex(RV.getComplexVal(), MakeNaturalAlignAddrLValue(ReturnValue, Ty), /*init*/ true); } EmitBranchThroughCleanup(ReturnBlock); } /// EmitReturnStmt - Note that due to GCC extensions, this can have an operand /// if the function returns void, or may be missing one if the function returns /// non-void. Fun stuff :). void CodeGenFunction::EmitReturnStmt(const ReturnStmt &S) { // Emit the result value, even if unused, to evalute the side effects. const Expr *RV = S.getRetValue(); // Treat block literals in a return expression as if they appeared // in their own scope. This permits a small, easily-implemented // exception to our over-conservative rules about not jumping to // statements following block literals with non-trivial cleanups. RunCleanupsScope cleanupScope(*this); if (const ExprWithCleanups *cleanups = dyn_cast_or_null(RV)) { enterFullExpression(cleanups); RV = cleanups->getSubExpr(); } // FIXME: Clean this up by using an LValue for ReturnTemp, // EmitStoreThroughLValue, and EmitAnyExpr. if (getLangOpts().ElideConstructors && S.getNRVOCandidate() && S.getNRVOCandidate()->isNRVOVariable()) { // Apply the named return value optimization for this return statement, // which means doing nothing: the appropriate result has already been // constructed into the NRVO variable. // If there is an NRVO flag for this variable, set it to 1 into indicate // that the cleanup code should not destroy the variable. if (llvm::Value *NRVOFlag = NRVOFlags[S.getNRVOCandidate()]) Builder.CreateStore(Builder.getTrue(), NRVOFlag); } else if (!ReturnValue) { // Make sure not to return anything, but evaluate the expression // for side effects. if (RV) EmitAnyExpr(RV); } else if (RV == 0) { // Do nothing (return value is left uninitialized) } else if (FnRetTy->isReferenceType()) { // If this function returns a reference, take the address of the expression // rather than the value. RValue Result = EmitReferenceBindingToExpr(RV); Builder.CreateStore(Result.getScalarVal(), ReturnValue); } else { switch (getEvaluationKind(RV->getType())) { case TEK_Scalar: Builder.CreateStore(EmitScalarExpr(RV), ReturnValue); break; case TEK_Complex: EmitComplexExprIntoLValue(RV, MakeNaturalAlignAddrLValue(ReturnValue, RV->getType()), /*isInit*/ true); break; case TEK_Aggregate: { CharUnits Alignment = getContext().getTypeAlignInChars(RV->getType()); EmitAggExpr(RV, AggValueSlot::forAddr(ReturnValue, Alignment, Qualifiers(), AggValueSlot::IsDestructed, AggValueSlot::DoesNotNeedGCBarriers, AggValueSlot::IsNotAliased)); break; } } } ++NumReturnExprs; if (RV == 0 || RV->isEvaluatable(getContext())) ++NumSimpleReturnExprs; cleanupScope.ForceCleanup(); EmitBranchThroughCleanup(ReturnBlock); } void CodeGenFunction::EmitDeclStmt(const DeclStmt &S) { // As long as debug info is modeled with instructions, we have to ensure we // have a place to insert here and write the stop point here. if (HaveInsertPoint()) EmitStopPoint(&S); for (DeclStmt::const_decl_iterator I = S.decl_begin(), E = S.decl_end(); I != E; ++I) EmitDecl(**I); } void CodeGenFunction::EmitBreakStmt(const BreakStmt &S) { assert(!BreakContinueStack.empty() && "break stmt not in a loop or switch!"); // If this code is reachable then emit a stop point (if generating // debug info). We have to do this ourselves because we are on the // "simple" statement path. if (HaveInsertPoint()) EmitStopPoint(&S); EmitBranchThroughCleanup(BreakContinueStack.back().BreakBlock); } void CodeGenFunction::EmitContinueStmt(const ContinueStmt &S) { assert(!BreakContinueStack.empty() && "continue stmt not in a loop!"); // If this code is reachable then emit a stop point (if generating // debug info). We have to do this ourselves because we are on the // "simple" statement path. if (HaveInsertPoint()) EmitStopPoint(&S); EmitBranchThroughCleanup(BreakContinueStack.back().ContinueBlock); } /// EmitCaseStmtRange - If case statement range is not too big then /// add multiple cases to switch instruction, one for each value within /// the range. If range is too big then emit "if" condition check. void CodeGenFunction::EmitCaseStmtRange(const CaseStmt &S) { assert(S.getRHS() && "Expected RHS value in CaseStmt"); llvm::APSInt LHS = S.getLHS()->EvaluateKnownConstInt(getContext()); llvm::APSInt RHS = S.getRHS()->EvaluateKnownConstInt(getContext()); RegionCounter CaseCnt = getPGORegionCounter(&S); // Emit the code for this case. We do this first to make sure it is // properly chained from our predecessor before generating the // switch machinery to enter this block. llvm::BasicBlock *CaseDest = createBasicBlock("sw.bb"); EmitBlockWithFallThrough(CaseDest, CaseCnt); EmitStmt(S.getSubStmt()); // If range is empty, do nothing. if (LHS.isSigned() ? RHS.slt(LHS) : RHS.ult(LHS)) return; llvm::APInt Range = RHS - LHS; // FIXME: parameters such as this should not be hardcoded. if (Range.ult(llvm::APInt(Range.getBitWidth(), 64))) { // Range is small enough to add multiple switch instruction cases. uint64_t Total = CaseCnt.getCount(); unsigned NCases = Range.getZExtValue() + 1; // We only have one region counter for the entire set of cases here, so we // need to divide the weights evenly between the generated cases, ensuring // that the total weight is preserved. E.g., a weight of 5 over three cases // will be distributed as weights of 2, 2, and 1. uint64_t Weight = Total / NCases, Rem = Total % NCases; for (unsigned I = 0; I != NCases; ++I) { if (SwitchWeights) SwitchWeights->push_back(Weight + (Rem ? 1 : 0)); if (Rem) Rem--; SwitchInsn->addCase(Builder.getInt(LHS), CaseDest); LHS++; } return; } // The range is too big. Emit "if" condition into a new block, // making sure to save and restore the current insertion point. llvm::BasicBlock *RestoreBB = Builder.GetInsertBlock(); // Push this test onto the chain of range checks (which terminates // in the default basic block). The switch's default will be changed // to the top of this chain after switch emission is complete. llvm::BasicBlock *FalseDest = CaseRangeBlock; CaseRangeBlock = createBasicBlock("sw.caserange"); CurFn->getBasicBlockList().push_back(CaseRangeBlock); Builder.SetInsertPoint(CaseRangeBlock); // Emit range check. llvm::Value *Diff = Builder.CreateSub(SwitchInsn->getCondition(), Builder.getInt(LHS)); llvm::Value *Cond = Builder.CreateICmpULE(Diff, Builder.getInt(Range), "inbounds"); llvm::MDNode *Weights = 0; if (SwitchWeights) { uint64_t ThisCount = CaseCnt.getCount(); uint64_t DefaultCount = (*SwitchWeights)[0]; Weights = PGO.createBranchWeights(ThisCount, DefaultCount); // Since we're chaining the switch default through each large case range, we // need to update the weight for the default, ie, the first case, to include // this case. (*SwitchWeights)[0] += ThisCount; } Builder.CreateCondBr(Cond, CaseDest, FalseDest, Weights); // Restore the appropriate insertion point. if (RestoreBB) Builder.SetInsertPoint(RestoreBB); else Builder.ClearInsertionPoint(); } void CodeGenFunction::EmitCaseStmt(const CaseStmt &S) { // If there is no enclosing switch instance that we're aware of, then this // case statement and its block can be elided. This situation only happens // when we've constant-folded the switch, are emitting the constant case, // and part of the constant case includes another case statement. For // instance: switch (4) { case 4: do { case 5: } while (1); } if (!SwitchInsn) { EmitStmt(S.getSubStmt()); return; } // Handle case ranges. if (S.getRHS()) { EmitCaseStmtRange(S); return; } RegionCounter CaseCnt = getPGORegionCounter(&S); llvm::ConstantInt *CaseVal = Builder.getInt(S.getLHS()->EvaluateKnownConstInt(getContext())); // If the body of the case is just a 'break', try to not emit an empty block. // If we're profiling or we're not optimizing, leave the block in for better // debug and coverage analysis. if (!CGM.getCodeGenOpts().ProfileInstrGenerate && CGM.getCodeGenOpts().OptimizationLevel > 0 && isa(S.getSubStmt())) { JumpDest Block = BreakContinueStack.back().BreakBlock; // Only do this optimization if there are no cleanups that need emitting. if (isObviouslyBranchWithoutCleanups(Block)) { if (SwitchWeights) SwitchWeights->push_back(CaseCnt.getCount()); SwitchInsn->addCase(CaseVal, Block.getBlock()); // If there was a fallthrough into this case, make sure to redirect it to // the end of the switch as well. if (Builder.GetInsertBlock()) { Builder.CreateBr(Block.getBlock()); Builder.ClearInsertionPoint(); } return; } } llvm::BasicBlock *CaseDest = createBasicBlock("sw.bb"); EmitBlockWithFallThrough(CaseDest, CaseCnt); if (SwitchWeights) SwitchWeights->push_back(CaseCnt.getCount()); SwitchInsn->addCase(CaseVal, CaseDest); // Recursively emitting the statement is acceptable, but is not wonderful for // code where we have many case statements nested together, i.e.: // case 1: // case 2: // case 3: etc. // Handling this recursively will create a new block for each case statement // that falls through to the next case which is IR intensive. It also causes // deep recursion which can run into stack depth limitations. Handle // sequential non-range case statements specially. const CaseStmt *CurCase = &S; const CaseStmt *NextCase = dyn_cast(S.getSubStmt()); // Otherwise, iteratively add consecutive cases to this switch stmt. while (NextCase && NextCase->getRHS() == 0) { CurCase = NextCase; llvm::ConstantInt *CaseVal = Builder.getInt(CurCase->getLHS()->EvaluateKnownConstInt(getContext())); CaseCnt = getPGORegionCounter(NextCase); if (SwitchWeights) SwitchWeights->push_back(CaseCnt.getCount()); if (CGM.getCodeGenOpts().ProfileInstrGenerate) { CaseDest = createBasicBlock("sw.bb"); EmitBlockWithFallThrough(CaseDest, CaseCnt); } SwitchInsn->addCase(CaseVal, CaseDest); NextCase = dyn_cast(CurCase->getSubStmt()); } // Normal default recursion for non-cases. EmitStmt(CurCase->getSubStmt()); } void CodeGenFunction::EmitDefaultStmt(const DefaultStmt &S) { llvm::BasicBlock *DefaultBlock = SwitchInsn->getDefaultDest(); assert(DefaultBlock->empty() && "EmitDefaultStmt: Default block already defined?"); RegionCounter Cnt = getPGORegionCounter(&S); EmitBlockWithFallThrough(DefaultBlock, Cnt); EmitStmt(S.getSubStmt()); } /// CollectStatementsForCase - Given the body of a 'switch' statement and a /// constant value that is being switched on, see if we can dead code eliminate /// the body of the switch to a simple series of statements to emit. Basically, /// on a switch (5) we want to find these statements: /// case 5: /// printf(...); <-- /// ++i; <-- /// break; /// /// and add them to the ResultStmts vector. If it is unsafe to do this /// transformation (for example, one of the elided statements contains a label /// that might be jumped to), return CSFC_Failure. If we handled it and 'S' /// should include statements after it (e.g. the printf() line is a substmt of /// the case) then return CSFC_FallThrough. If we handled it and found a break /// statement, then return CSFC_Success. /// /// If Case is non-null, then we are looking for the specified case, checking /// that nothing we jump over contains labels. If Case is null, then we found /// the case and are looking for the break. /// /// If the recursive walk actually finds our Case, then we set FoundCase to /// true. /// enum CSFC_Result { CSFC_Failure, CSFC_FallThrough, CSFC_Success }; static CSFC_Result CollectStatementsForCase(const Stmt *S, const SwitchCase *Case, bool &FoundCase, SmallVectorImpl &ResultStmts) { // If this is a null statement, just succeed. if (S == 0) return Case ? CSFC_Success : CSFC_FallThrough; // If this is the switchcase (case 4: or default) that we're looking for, then // we're in business. Just add the substatement. if (const SwitchCase *SC = dyn_cast(S)) { if (S == Case) { FoundCase = true; return CollectStatementsForCase(SC->getSubStmt(), 0, FoundCase, ResultStmts); } // Otherwise, this is some other case or default statement, just ignore it. return CollectStatementsForCase(SC->getSubStmt(), Case, FoundCase, ResultStmts); } // If we are in the live part of the code and we found our break statement, // return a success! if (Case == 0 && isa(S)) return CSFC_Success; // If this is a switch statement, then it might contain the SwitchCase, the // break, or neither. if (const CompoundStmt *CS = dyn_cast(S)) { // Handle this as two cases: we might be looking for the SwitchCase (if so // the skipped statements must be skippable) or we might already have it. CompoundStmt::const_body_iterator I = CS->body_begin(), E = CS->body_end(); if (Case) { // Keep track of whether we see a skipped declaration. The code could be // using the declaration even if it is skipped, so we can't optimize out // the decl if the kept statements might refer to it. bool HadSkippedDecl = false; // If we're looking for the case, just see if we can skip each of the // substatements. for (; Case && I != E; ++I) { HadSkippedDecl |= isa(*I); switch (CollectStatementsForCase(*I, Case, FoundCase, ResultStmts)) { case CSFC_Failure: return CSFC_Failure; case CSFC_Success: // A successful result means that either 1) that the statement doesn't // have the case and is skippable, or 2) does contain the case value // and also contains the break to exit the switch. In the later case, // we just verify the rest of the statements are elidable. if (FoundCase) { // If we found the case and skipped declarations, we can't do the // optimization. if (HadSkippedDecl) return CSFC_Failure; for (++I; I != E; ++I) if (CodeGenFunction::ContainsLabel(*I, true)) return CSFC_Failure; return CSFC_Success; } break; case CSFC_FallThrough: // If we have a fallthrough condition, then we must have found the // case started to include statements. Consider the rest of the // statements in the compound statement as candidates for inclusion. assert(FoundCase && "Didn't find case but returned fallthrough?"); // We recursively found Case, so we're not looking for it anymore. Case = 0; // If we found the case and skipped declarations, we can't do the // optimization. if (HadSkippedDecl) return CSFC_Failure; break; } } } // If we have statements in our range, then we know that the statements are // live and need to be added to the set of statements we're tracking. for (; I != E; ++I) { switch (CollectStatementsForCase(*I, 0, FoundCase, ResultStmts)) { case CSFC_Failure: return CSFC_Failure; case CSFC_FallThrough: // A fallthrough result means that the statement was simple and just // included in ResultStmt, keep adding them afterwards. break; case CSFC_Success: // A successful result means that we found the break statement and // stopped statement inclusion. We just ensure that any leftover stmts // are skippable and return success ourselves. for (++I; I != E; ++I) if (CodeGenFunction::ContainsLabel(*I, true)) return CSFC_Failure; return CSFC_Success; } } return Case ? CSFC_Success : CSFC_FallThrough; } // Okay, this is some other statement that we don't handle explicitly, like a // for statement or increment etc. If we are skipping over this statement, // just verify it doesn't have labels, which would make it invalid to elide. if (Case) { if (CodeGenFunction::ContainsLabel(S, true)) return CSFC_Failure; return CSFC_Success; } // Otherwise, we want to include this statement. Everything is cool with that // so long as it doesn't contain a break out of the switch we're in. if (CodeGenFunction::containsBreak(S)) return CSFC_Failure; // Otherwise, everything is great. Include the statement and tell the caller // that we fall through and include the next statement as well. ResultStmts.push_back(S); return CSFC_FallThrough; } /// FindCaseStatementsForValue - Find the case statement being jumped to and /// then invoke CollectStatementsForCase to find the list of statements to emit /// for a switch on constant. See the comment above CollectStatementsForCase /// for more details. static bool FindCaseStatementsForValue(const SwitchStmt &S, const llvm::APSInt &ConstantCondValue, SmallVectorImpl &ResultStmts, ASTContext &C, const SwitchCase *&ResultCase) { // First step, find the switch case that is being branched to. We can do this // efficiently by scanning the SwitchCase list. const SwitchCase *Case = S.getSwitchCaseList(); const DefaultStmt *DefaultCase = 0; for (; Case; Case = Case->getNextSwitchCase()) { // It's either a default or case. Just remember the default statement in // case we're not jumping to any numbered cases. if (const DefaultStmt *DS = dyn_cast(Case)) { DefaultCase = DS; continue; } // Check to see if this case is the one we're looking for. const CaseStmt *CS = cast(Case); // Don't handle case ranges yet. if (CS->getRHS()) return false; // If we found our case, remember it as 'case'. if (CS->getLHS()->EvaluateKnownConstInt(C) == ConstantCondValue) break; } // If we didn't find a matching case, we use a default if it exists, or we // elide the whole switch body! if (Case == 0) { // It is safe to elide the body of the switch if it doesn't contain labels // etc. If it is safe, return successfully with an empty ResultStmts list. if (DefaultCase == 0) return !CodeGenFunction::ContainsLabel(&S); Case = DefaultCase; } // Ok, we know which case is being jumped to, try to collect all the // statements that follow it. This can fail for a variety of reasons. Also, // check to see that the recursive walk actually found our case statement. // Insane cases like this can fail to find it in the recursive walk since we // don't handle every stmt kind: // switch (4) { // while (1) { // case 4: ... bool FoundCase = false; ResultCase = Case; return CollectStatementsForCase(S.getBody(), Case, FoundCase, ResultStmts) != CSFC_Failure && FoundCase; } void CodeGenFunction::EmitSwitchStmt(const SwitchStmt &S) { JumpDest SwitchExit = getJumpDestInCurrentScope("sw.epilog"); RunCleanupsScope ConditionScope(*this); if (S.getConditionVariable()) EmitAutoVarDecl(*S.getConditionVariable()); // Handle nested switch statements. llvm::SwitchInst *SavedSwitchInsn = SwitchInsn; SmallVector *SavedSwitchWeights = SwitchWeights; llvm::BasicBlock *SavedCRBlock = CaseRangeBlock; // See if we can constant fold the condition of the switch and therefore only // emit the live case statement (if any) of the switch. llvm::APSInt ConstantCondValue; if (ConstantFoldsToSimpleInteger(S.getCond(), ConstantCondValue)) { SmallVector CaseStmts; const SwitchCase *Case = 0; if (FindCaseStatementsForValue(S, ConstantCondValue, CaseStmts, getContext(), Case)) { if (Case) { RegionCounter CaseCnt = getPGORegionCounter(Case); CaseCnt.beginRegion(Builder); } RunCleanupsScope ExecutedScope(*this); // At this point, we are no longer "within" a switch instance, so // we can temporarily enforce this to ensure that any embedded case // statements are not emitted. SwitchInsn = 0; // Okay, we can dead code eliminate everything except this case. Emit the // specified series of statements and we're good. for (unsigned i = 0, e = CaseStmts.size(); i != e; ++i) EmitStmt(CaseStmts[i]); RegionCounter ExitCnt = getPGORegionCounter(&S); ExitCnt.beginRegion(Builder); // Now we want to restore the saved switch instance so that nested // switches continue to function properly SwitchInsn = SavedSwitchInsn; return; } } llvm::Value *CondV = EmitScalarExpr(S.getCond()); // Create basic block to hold stuff that comes after switch // statement. We also need to create a default block now so that // explicit case ranges tests can have a place to jump to on // failure. llvm::BasicBlock *DefaultBlock = createBasicBlock("sw.default"); SwitchInsn = Builder.CreateSwitch(CondV, DefaultBlock); if (PGO.haveRegionCounts()) { // Walk the SwitchCase list to find how many there are. uint64_t DefaultCount = 0; unsigned NumCases = 0; for (const SwitchCase *Case = S.getSwitchCaseList(); Case; Case = Case->getNextSwitchCase()) { if (isa(Case)) DefaultCount = getPGORegionCounter(Case).getCount(); NumCases += 1; } SwitchWeights = new SmallVector(); SwitchWeights->reserve(NumCases); // The default needs to be first. We store the edge count, so we already // know the right weight. SwitchWeights->push_back(DefaultCount); } CaseRangeBlock = DefaultBlock; // Clear the insertion point to indicate we are in unreachable code. Builder.ClearInsertionPoint(); // All break statements jump to NextBlock. If BreakContinueStack is non-empty // then reuse last ContinueBlock. JumpDest OuterContinue; if (!BreakContinueStack.empty()) OuterContinue = BreakContinueStack.back().ContinueBlock; BreakContinueStack.push_back(BreakContinue(SwitchExit, OuterContinue)); // Emit switch body. EmitStmt(S.getBody()); BreakContinueStack.pop_back(); // Update the default block in case explicit case range tests have // been chained on top. SwitchInsn->setDefaultDest(CaseRangeBlock); // If a default was never emitted: if (!DefaultBlock->getParent()) { // If we have cleanups, emit the default block so that there's a // place to jump through the cleanups from. if (ConditionScope.requiresCleanups()) { EmitBlock(DefaultBlock); // Otherwise, just forward the default block to the switch end. } else { DefaultBlock->replaceAllUsesWith(SwitchExit.getBlock()); delete DefaultBlock; } } ConditionScope.ForceCleanup(); // Emit continuation. EmitBlock(SwitchExit.getBlock(), true); RegionCounter ExitCnt = getPGORegionCounter(&S); ExitCnt.beginRegion(Builder); if (SwitchWeights) { assert(SwitchWeights->size() == 1 + SwitchInsn->getNumCases() && "switch weights do not match switch cases"); // If there's only one jump destination there's no sense weighting it. if (SwitchWeights->size() > 1) SwitchInsn->setMetadata(llvm::LLVMContext::MD_prof, PGO.createBranchWeights(*SwitchWeights)); delete SwitchWeights; } SwitchInsn = SavedSwitchInsn; SwitchWeights = SavedSwitchWeights; CaseRangeBlock = SavedCRBlock; } static std::string SimplifyConstraint(const char *Constraint, const TargetInfo &Target, SmallVectorImpl *OutCons=0) { std::string Result; while (*Constraint) { switch (*Constraint) { default: Result += Target.convertConstraint(Constraint); break; // Ignore these case '*': case '?': case '!': case '=': // Will see this and the following in mult-alt constraints. case '+': break; case '#': // Ignore the rest of the constraint alternative. while (Constraint[1] && Constraint[1] != ',') Constraint++; break; case ',': Result += "|"; break; case 'g': Result += "imr"; break; case '[': { assert(OutCons && "Must pass output names to constraints with a symbolic name"); unsigned Index; bool result = Target.resolveSymbolicName(Constraint, &(*OutCons)[0], OutCons->size(), Index); assert(result && "Could not resolve symbolic name"); (void)result; Result += llvm::utostr(Index); break; } } Constraint++; } return Result; } /// AddVariableConstraints - Look at AsmExpr and if it is a variable declared /// as using a particular register add that as a constraint that will be used /// in this asm stmt. static std::string AddVariableConstraints(const std::string &Constraint, const Expr &AsmExpr, const TargetInfo &Target, CodeGenModule &CGM, const AsmStmt &Stmt) { const DeclRefExpr *AsmDeclRef = dyn_cast(&AsmExpr); if (!AsmDeclRef) return Constraint; const ValueDecl &Value = *AsmDeclRef->getDecl(); const VarDecl *Variable = dyn_cast(&Value); if (!Variable) return Constraint; if (Variable->getStorageClass() != SC_Register) return Constraint; AsmLabelAttr *Attr = Variable->getAttr(); if (!Attr) return Constraint; StringRef Register = Attr->getLabel(); assert(Target.isValidGCCRegisterName(Register)); // We're using validateOutputConstraint here because we only care if // this is a register constraint. TargetInfo::ConstraintInfo Info(Constraint, ""); if (Target.validateOutputConstraint(Info) && !Info.allowsRegister()) { CGM.ErrorUnsupported(&Stmt, "__asm__"); return Constraint; } // Canonicalize the register here before returning it. Register = Target.getNormalizedGCCRegisterName(Register); return "{" + Register.str() + "}"; } llvm::Value* CodeGenFunction::EmitAsmInputLValue(const TargetInfo::ConstraintInfo &Info, LValue InputValue, QualType InputType, std::string &ConstraintStr, SourceLocation Loc) { llvm::Value *Arg; if (Info.allowsRegister() || !Info.allowsMemory()) { if (CodeGenFunction::hasScalarEvaluationKind(InputType)) { Arg = EmitLoadOfLValue(InputValue, Loc).getScalarVal(); } else { llvm::Type *Ty = ConvertType(InputType); uint64_t Size = CGM.getDataLayout().getTypeSizeInBits(Ty); if (Size <= 64 && llvm::isPowerOf2_64(Size)) { Ty = llvm::IntegerType::get(getLLVMContext(), Size); Ty = llvm::PointerType::getUnqual(Ty); Arg = Builder.CreateLoad(Builder.CreateBitCast(InputValue.getAddress(), Ty)); } else { Arg = InputValue.getAddress(); ConstraintStr += '*'; } } } else { Arg = InputValue.getAddress(); ConstraintStr += '*'; } return Arg; } llvm::Value* CodeGenFunction::EmitAsmInput( const TargetInfo::ConstraintInfo &Info, const Expr *InputExpr, std::string &ConstraintStr) { if (Info.allowsRegister() || !Info.allowsMemory()) if (CodeGenFunction::hasScalarEvaluationKind(InputExpr->getType())) return EmitScalarExpr(InputExpr); InputExpr = InputExpr->IgnoreParenNoopCasts(getContext()); LValue Dest = EmitLValue(InputExpr); return EmitAsmInputLValue(Info, Dest, InputExpr->getType(), ConstraintStr, InputExpr->getExprLoc()); } /// getAsmSrcLocInfo - Return the !srcloc metadata node to attach to an inline /// asm call instruction. The !srcloc MDNode contains a list of constant /// integers which are the source locations of the start of each line in the /// asm. static llvm::MDNode *getAsmSrcLocInfo(const StringLiteral *Str, CodeGenFunction &CGF) { SmallVector Locs; // Add the location of the first line to the MDNode. Locs.push_back(llvm::ConstantInt::get(CGF.Int32Ty, Str->getLocStart().getRawEncoding())); StringRef StrVal = Str->getString(); if (!StrVal.empty()) { const SourceManager &SM = CGF.CGM.getContext().getSourceManager(); const LangOptions &LangOpts = CGF.CGM.getLangOpts(); // Add the location of the start of each subsequent line of the asm to the // MDNode. for (unsigned i = 0, e = StrVal.size()-1; i != e; ++i) { if (StrVal[i] != '\n') continue; SourceLocation LineLoc = Str->getLocationOfByte(i+1, SM, LangOpts, CGF.getTarget()); Locs.push_back(llvm::ConstantInt::get(CGF.Int32Ty, LineLoc.getRawEncoding())); } } return llvm::MDNode::get(CGF.getLLVMContext(), Locs); } void CodeGenFunction::EmitAsmStmt(const AsmStmt &S) { // Assemble the final asm string. std::string AsmString = S.generateAsmString(getContext()); // Get all the output and input constraints together. SmallVector OutputConstraintInfos; SmallVector InputConstraintInfos; for (unsigned i = 0, e = S.getNumOutputs(); i != e; i++) { StringRef Name; if (const GCCAsmStmt *GAS = dyn_cast(&S)) Name = GAS->getOutputName(i); TargetInfo::ConstraintInfo Info(S.getOutputConstraint(i), Name); bool IsValid = getTarget().validateOutputConstraint(Info); (void)IsValid; assert(IsValid && "Failed to parse output constraint"); OutputConstraintInfos.push_back(Info); } for (unsigned i = 0, e = S.getNumInputs(); i != e; i++) { StringRef Name; if (const GCCAsmStmt *GAS = dyn_cast(&S)) Name = GAS->getInputName(i); TargetInfo::ConstraintInfo Info(S.getInputConstraint(i), Name); bool IsValid = getTarget().validateInputConstraint(OutputConstraintInfos.data(), S.getNumOutputs(), Info); assert(IsValid && "Failed to parse input constraint"); (void)IsValid; InputConstraintInfos.push_back(Info); } std::string Constraints; std::vector ResultRegDests; std::vector ResultRegQualTys; std::vector ResultRegTypes; std::vector ResultTruncRegTypes; std::vector ArgTypes; std::vector Args; // Keep track of inout constraints. std::string InOutConstraints; std::vector InOutArgs; std::vector InOutArgTypes; for (unsigned i = 0, e = S.getNumOutputs(); i != e; i++) { TargetInfo::ConstraintInfo &Info = OutputConstraintInfos[i]; // Simplify the output constraint. std::string OutputConstraint(S.getOutputConstraint(i)); OutputConstraint = SimplifyConstraint(OutputConstraint.c_str() + 1, getTarget()); const Expr *OutExpr = S.getOutputExpr(i); OutExpr = OutExpr->IgnoreParenNoopCasts(getContext()); OutputConstraint = AddVariableConstraints(OutputConstraint, *OutExpr, getTarget(), CGM, S); LValue Dest = EmitLValue(OutExpr); if (!Constraints.empty()) Constraints += ','; // If this is a register output, then make the inline asm return it // by-value. If this is a memory result, return the value by-reference. if (!Info.allowsMemory() && hasScalarEvaluationKind(OutExpr->getType())) { Constraints += "=" + OutputConstraint; ResultRegQualTys.push_back(OutExpr->getType()); ResultRegDests.push_back(Dest); ResultRegTypes.push_back(ConvertTypeForMem(OutExpr->getType())); ResultTruncRegTypes.push_back(ResultRegTypes.back()); // If this output is tied to an input, and if the input is larger, then // we need to set the actual result type of the inline asm node to be the // same as the input type. if (Info.hasMatchingInput()) { unsigned InputNo; for (InputNo = 0; InputNo != S.getNumInputs(); ++InputNo) { TargetInfo::ConstraintInfo &Input = InputConstraintInfos[InputNo]; if (Input.hasTiedOperand() && Input.getTiedOperand() == i) break; } assert(InputNo != S.getNumInputs() && "Didn't find matching input!"); QualType InputTy = S.getInputExpr(InputNo)->getType(); QualType OutputType = OutExpr->getType(); uint64_t InputSize = getContext().getTypeSize(InputTy); if (getContext().getTypeSize(OutputType) < InputSize) { // Form the asm to return the value as a larger integer or fp type. ResultRegTypes.back() = ConvertType(InputTy); } } if (llvm::Type* AdjTy = getTargetHooks().adjustInlineAsmType(*this, OutputConstraint, ResultRegTypes.back())) ResultRegTypes.back() = AdjTy; else { CGM.getDiags().Report(S.getAsmLoc(), diag::err_asm_invalid_type_in_input) << OutExpr->getType() << OutputConstraint; } } else { ArgTypes.push_back(Dest.getAddress()->getType()); Args.push_back(Dest.getAddress()); Constraints += "=*"; Constraints += OutputConstraint; } if (Info.isReadWrite()) { InOutConstraints += ','; const Expr *InputExpr = S.getOutputExpr(i); llvm::Value *Arg = EmitAsmInputLValue(Info, Dest, InputExpr->getType(), InOutConstraints, InputExpr->getExprLoc()); if (llvm::Type* AdjTy = getTargetHooks().adjustInlineAsmType(*this, OutputConstraint, Arg->getType())) Arg = Builder.CreateBitCast(Arg, AdjTy); if (Info.allowsRegister()) InOutConstraints += llvm::utostr(i); else InOutConstraints += OutputConstraint; InOutArgTypes.push_back(Arg->getType()); InOutArgs.push_back(Arg); } } unsigned NumConstraints = S.getNumOutputs() + S.getNumInputs(); for (unsigned i = 0, e = S.getNumInputs(); i != e; i++) { const Expr *InputExpr = S.getInputExpr(i); TargetInfo::ConstraintInfo &Info = InputConstraintInfos[i]; if (!Constraints.empty()) Constraints += ','; // Simplify the input constraint. std::string InputConstraint(S.getInputConstraint(i)); InputConstraint = SimplifyConstraint(InputConstraint.c_str(), getTarget(), &OutputConstraintInfos); InputConstraint = AddVariableConstraints(InputConstraint, *InputExpr->IgnoreParenNoopCasts(getContext()), getTarget(), CGM, S); llvm::Value *Arg = EmitAsmInput(Info, InputExpr, Constraints); // If this input argument is tied to a larger output result, extend the // input to be the same size as the output. The LLVM backend wants to see // the input and output of a matching constraint be the same size. Note // that GCC does not define what the top bits are here. We use zext because // that is usually cheaper, but LLVM IR should really get an anyext someday. if (Info.hasTiedOperand()) { unsigned Output = Info.getTiedOperand(); QualType OutputType = S.getOutputExpr(Output)->getType(); QualType InputTy = InputExpr->getType(); if (getContext().getTypeSize(OutputType) > getContext().getTypeSize(InputTy)) { // Use ptrtoint as appropriate so that we can do our extension. if (isa(Arg->getType())) Arg = Builder.CreatePtrToInt(Arg, IntPtrTy); llvm::Type *OutputTy = ConvertType(OutputType); if (isa(OutputTy)) Arg = Builder.CreateZExt(Arg, OutputTy); else if (isa(OutputTy)) Arg = Builder.CreateZExt(Arg, IntPtrTy); else { assert(OutputTy->isFloatingPointTy() && "Unexpected output type"); Arg = Builder.CreateFPExt(Arg, OutputTy); } } } if (llvm::Type* AdjTy = getTargetHooks().adjustInlineAsmType(*this, InputConstraint, Arg->getType())) Arg = Builder.CreateBitCast(Arg, AdjTy); else CGM.getDiags().Report(S.getAsmLoc(), diag::err_asm_invalid_type_in_input) << InputExpr->getType() << InputConstraint; ArgTypes.push_back(Arg->getType()); Args.push_back(Arg); Constraints += InputConstraint; } // Append the "input" part of inout constraints last. for (unsigned i = 0, e = InOutArgs.size(); i != e; i++) { ArgTypes.push_back(InOutArgTypes[i]); Args.push_back(InOutArgs[i]); } Constraints += InOutConstraints; // Clobbers for (unsigned i = 0, e = S.getNumClobbers(); i != e; i++) { StringRef Clobber = S.getClobber(i); if (Clobber != "memory" && Clobber != "cc") Clobber = getTarget().getNormalizedGCCRegisterName(Clobber); if (i != 0 || NumConstraints != 0) Constraints += ','; Constraints += "~{"; Constraints += Clobber; Constraints += '}'; } // Add machine specific clobbers std::string MachineClobbers = getTarget().getClobbers(); if (!MachineClobbers.empty()) { if (!Constraints.empty()) Constraints += ','; Constraints += MachineClobbers; } llvm::Type *ResultType; if (ResultRegTypes.empty()) ResultType = VoidTy; else if (ResultRegTypes.size() == 1) ResultType = ResultRegTypes[0]; else ResultType = llvm::StructType::get(getLLVMContext(), ResultRegTypes); llvm::FunctionType *FTy = llvm::FunctionType::get(ResultType, ArgTypes, false); bool HasSideEffect = S.isVolatile() || S.getNumOutputs() == 0; llvm::InlineAsm::AsmDialect AsmDialect = isa(&S) ? llvm::InlineAsm::AD_Intel : llvm::InlineAsm::AD_ATT; llvm::InlineAsm *IA = llvm::InlineAsm::get(FTy, AsmString, Constraints, HasSideEffect, /* IsAlignStack */ false, AsmDialect); llvm::CallInst *Result = Builder.CreateCall(IA, Args); Result->addAttribute(llvm::AttributeSet::FunctionIndex, llvm::Attribute::NoUnwind); // Slap the source location of the inline asm into a !srcloc metadata on the // call. FIXME: Handle metadata for MS-style inline asms. if (const GCCAsmStmt *gccAsmStmt = dyn_cast(&S)) Result->setMetadata("srcloc", getAsmSrcLocInfo(gccAsmStmt->getAsmString(), *this)); // Extract all of the register value results from the asm. std::vector RegResults; if (ResultRegTypes.size() == 1) { RegResults.push_back(Result); } else { for (unsigned i = 0, e = ResultRegTypes.size(); i != e; ++i) { llvm::Value *Tmp = Builder.CreateExtractValue(Result, i, "asmresult"); RegResults.push_back(Tmp); } } for (unsigned i = 0, e = RegResults.size(); i != e; ++i) { llvm::Value *Tmp = RegResults[i]; // If the result type of the LLVM IR asm doesn't match the result type of // the expression, do the conversion. if (ResultRegTypes[i] != ResultTruncRegTypes[i]) { llvm::Type *TruncTy = ResultTruncRegTypes[i]; // Truncate the integer result to the right size, note that TruncTy can be // a pointer. if (TruncTy->isFloatingPointTy()) Tmp = Builder.CreateFPTrunc(Tmp, TruncTy); else if (TruncTy->isPointerTy() && Tmp->getType()->isIntegerTy()) { uint64_t ResSize = CGM.getDataLayout().getTypeSizeInBits(TruncTy); Tmp = Builder.CreateTrunc(Tmp, llvm::IntegerType::get(getLLVMContext(), (unsigned)ResSize)); Tmp = Builder.CreateIntToPtr(Tmp, TruncTy); } else if (Tmp->getType()->isPointerTy() && TruncTy->isIntegerTy()) { uint64_t TmpSize =CGM.getDataLayout().getTypeSizeInBits(Tmp->getType()); Tmp = Builder.CreatePtrToInt(Tmp, llvm::IntegerType::get(getLLVMContext(), (unsigned)TmpSize)); Tmp = Builder.CreateTrunc(Tmp, TruncTy); } else if (TruncTy->isIntegerTy()) { Tmp = Builder.CreateTrunc(Tmp, TruncTy); } else if (TruncTy->isVectorTy()) { Tmp = Builder.CreateBitCast(Tmp, TruncTy); } } EmitStoreThroughLValue(RValue::get(Tmp), ResultRegDests[i]); } } static LValue InitCapturedStruct(CodeGenFunction &CGF, const CapturedStmt &S) { const RecordDecl *RD = S.getCapturedRecordDecl(); QualType RecordTy = CGF.getContext().getRecordType(RD); // Initialize the captured struct. LValue SlotLV = CGF.MakeNaturalAlignAddrLValue( CGF.CreateMemTemp(RecordTy, "agg.captured"), RecordTy); RecordDecl::field_iterator CurField = RD->field_begin(); for (CapturedStmt::capture_init_iterator I = S.capture_init_begin(), E = S.capture_init_end(); I != E; ++I, ++CurField) { LValue LV = CGF.EmitLValueForFieldInitialization(SlotLV, *CurField); CGF.EmitInitializerForField(*CurField, LV, *I, ArrayRef()); } return SlotLV; } /// Generate an outlined function for the body of a CapturedStmt, store any /// captured variables into the captured struct, and call the outlined function. llvm::Function * CodeGenFunction::EmitCapturedStmt(const CapturedStmt &S, CapturedRegionKind K) { const CapturedDecl *CD = S.getCapturedDecl(); const RecordDecl *RD = S.getCapturedRecordDecl(); assert(CD->hasBody() && "missing CapturedDecl body"); LValue CapStruct = InitCapturedStruct(*this, S); // Emit the CapturedDecl CodeGenFunction CGF(CGM, true); CGF.CapturedStmtInfo = new CGCapturedStmtInfo(S, K); llvm::Function *F = CGF.GenerateCapturedStmtFunction(CD, RD, S.getLocStart()); delete CGF.CapturedStmtInfo; // Emit call to the helper function. EmitCallOrInvoke(F, CapStruct.getAddress()); return F; } /// Creates the outlined function for a CapturedStmt. llvm::Function * CodeGenFunction::GenerateCapturedStmtFunction(const CapturedDecl *CD, const RecordDecl *RD, SourceLocation Loc) { assert(CapturedStmtInfo && "CapturedStmtInfo should be set when generating the captured function"); // Build the argument list. ASTContext &Ctx = CGM.getContext(); FunctionArgList Args; Args.append(CD->param_begin(), CD->param_end()); // Create the function declaration. FunctionType::ExtInfo ExtInfo; const CGFunctionInfo &FuncInfo = CGM.getTypes().arrangeFreeFunctionDeclaration(Ctx.VoidTy, Args, ExtInfo, /*IsVariadic=*/false); llvm::FunctionType *FuncLLVMTy = CGM.getTypes().GetFunctionType(FuncInfo); llvm::Function *F = llvm::Function::Create(FuncLLVMTy, llvm::GlobalValue::InternalLinkage, CapturedStmtInfo->getHelperName(), &CGM.getModule()); CGM.SetInternalFunctionAttributes(CD, F, FuncInfo); // Generate the function. StartFunction(CD, Ctx.VoidTy, F, FuncInfo, Args, CD->getBody()->getLocStart()); // Set the context parameter in CapturedStmtInfo. llvm::Value *DeclPtr = LocalDeclMap[CD->getContextParam()]; assert(DeclPtr && "missing context parameter for CapturedStmt"); CapturedStmtInfo->setContextValue(Builder.CreateLoad(DeclPtr)); // If 'this' is captured, load it into CXXThisValue. if (CapturedStmtInfo->isCXXThisExprCaptured()) { FieldDecl *FD = CapturedStmtInfo->getThisFieldDecl(); LValue LV = MakeNaturalAlignAddrLValue(CapturedStmtInfo->getContextValue(), Ctx.getTagDeclType(RD)); LValue ThisLValue = EmitLValueForField(LV, FD); CXXThisValue = EmitLoadOfLValue(ThisLValue, Loc).getScalarVal(); } CapturedStmtInfo->EmitBody(*this, CD->getBody()); FinishFunction(CD->getBodyRBrace()); return F; } @