CGStmt.cpp revision 263508
1//===--- CGStmt.cpp - Emit LLVM Code from Statements ----------------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This contains code to emit Stmt nodes as LLVM code. 11// 12//===----------------------------------------------------------------------===// 13 14#include "CodeGenFunction.h" 15#include "CGDebugInfo.h" 16#include "CodeGenModule.h" 17#include "TargetInfo.h" 18#include "clang/AST/StmtVisitor.h" 19#include "clang/Sema/SemaDiagnostic.h" 20#include "clang/Basic/PrettyStackTrace.h" 21#include "clang/Basic/TargetInfo.h" 22#include "llvm/ADT/StringExtras.h" 23#include "llvm/IR/DataLayout.h" 24#include "llvm/IR/InlineAsm.h" 25#include "llvm/IR/Intrinsics.h" 26#include "llvm/Support/CallSite.h" 27using namespace clang; 28using namespace CodeGen; 29 30//===----------------------------------------------------------------------===// 31// Statement Emission 32//===----------------------------------------------------------------------===// 33 34void CodeGenFunction::EmitStopPoint(const Stmt *S) { 35 if (CGDebugInfo *DI = getDebugInfo()) { 36 SourceLocation Loc; 37 Loc = S->getLocStart(); 38 DI->EmitLocation(Builder, Loc); 39 40 LastStopPoint = Loc; 41 } 42} 43 44void CodeGenFunction::EmitStmt(const Stmt *S) { 45 assert(S && "Null statement?"); 46 47 // These statements have their own debug info handling. 48 if (EmitSimpleStmt(S)) 49 return; 50 51 // Check if we are generating unreachable code. 52 if (!HaveInsertPoint()) { 53 // If so, and the statement doesn't contain a label, then we do not need to 54 // generate actual code. This is safe because (1) the current point is 55 // unreachable, so we don't need to execute the code, and (2) we've already 56 // handled the statements which update internal data structures (like the 57 // local variable map) which could be used by subsequent statements. 58 if (!ContainsLabel(S)) { 59 // Verify that any decl statements were handled as simple, they may be in 60 // scope of subsequent reachable statements. 61 assert(!isa<DeclStmt>(*S) && "Unexpected DeclStmt!"); 62 return; 63 } 64 65 // Otherwise, make a new block to hold the code. 66 EnsureInsertPoint(); 67 } 68 69 // Generate a stoppoint if we are emitting debug info. 70 EmitStopPoint(S); 71 72 switch (S->getStmtClass()) { 73 case Stmt::NoStmtClass: 74 case Stmt::CXXCatchStmtClass: 75 case Stmt::SEHExceptStmtClass: 76 case Stmt::SEHFinallyStmtClass: 77 case Stmt::MSDependentExistsStmtClass: 78 case Stmt::OMPParallelDirectiveClass: 79 llvm_unreachable("invalid statement class to emit generically"); 80 case Stmt::NullStmtClass: 81 case Stmt::CompoundStmtClass: 82 case Stmt::DeclStmtClass: 83 case Stmt::LabelStmtClass: 84 case Stmt::AttributedStmtClass: 85 case Stmt::GotoStmtClass: 86 case Stmt::BreakStmtClass: 87 case Stmt::ContinueStmtClass: 88 case Stmt::DefaultStmtClass: 89 case Stmt::CaseStmtClass: 90 llvm_unreachable("should have emitted these statements as simple"); 91 92#define STMT(Type, Base) 93#define ABSTRACT_STMT(Op) 94#define EXPR(Type, Base) \ 95 case Stmt::Type##Class: 96#include "clang/AST/StmtNodes.inc" 97 { 98 // Remember the block we came in on. 99 llvm::BasicBlock *incoming = Builder.GetInsertBlock(); 100 assert(incoming && "expression emission must have an insertion point"); 101 102 EmitIgnoredExpr(cast<Expr>(S)); 103 104 llvm::BasicBlock *outgoing = Builder.GetInsertBlock(); 105 assert(outgoing && "expression emission cleared block!"); 106 107 // The expression emitters assume (reasonably!) that the insertion 108 // point is always set. To maintain that, the call-emission code 109 // for noreturn functions has to enter a new block with no 110 // predecessors. We want to kill that block and mark the current 111 // insertion point unreachable in the common case of a call like 112 // "exit();". Since expression emission doesn't otherwise create 113 // blocks with no predecessors, we can just test for that. 114 // However, we must be careful not to do this to our incoming 115 // block, because *statement* emission does sometimes create 116 // reachable blocks which will have no predecessors until later in 117 // the function. This occurs with, e.g., labels that are not 118 // reachable by fallthrough. 119 if (incoming != outgoing && outgoing->use_empty()) { 120 outgoing->eraseFromParent(); 121 Builder.ClearInsertionPoint(); 122 } 123 break; 124 } 125 126 case Stmt::IndirectGotoStmtClass: 127 EmitIndirectGotoStmt(cast<IndirectGotoStmt>(*S)); break; 128 129 case Stmt::IfStmtClass: EmitIfStmt(cast<IfStmt>(*S)); break; 130 case Stmt::WhileStmtClass: EmitWhileStmt(cast<WhileStmt>(*S)); break; 131 case Stmt::DoStmtClass: EmitDoStmt(cast<DoStmt>(*S)); break; 132 case Stmt::ForStmtClass: EmitForStmt(cast<ForStmt>(*S)); break; 133 134 case Stmt::ReturnStmtClass: EmitReturnStmt(cast<ReturnStmt>(*S)); break; 135 136 case Stmt::SwitchStmtClass: EmitSwitchStmt(cast<SwitchStmt>(*S)); break; 137 case Stmt::GCCAsmStmtClass: // Intentional fall-through. 138 case Stmt::MSAsmStmtClass: EmitAsmStmt(cast<AsmStmt>(*S)); break; 139 case Stmt::CapturedStmtClass: { 140 const CapturedStmt *CS = cast<CapturedStmt>(S); 141 EmitCapturedStmt(*CS, CS->getCapturedRegionKind()); 142 } 143 break; 144 case Stmt::ObjCAtTryStmtClass: 145 EmitObjCAtTryStmt(cast<ObjCAtTryStmt>(*S)); 146 break; 147 case Stmt::ObjCAtCatchStmtClass: 148 llvm_unreachable( 149 "@catch statements should be handled by EmitObjCAtTryStmt"); 150 case Stmt::ObjCAtFinallyStmtClass: 151 llvm_unreachable( 152 "@finally statements should be handled by EmitObjCAtTryStmt"); 153 case Stmt::ObjCAtThrowStmtClass: 154 EmitObjCAtThrowStmt(cast<ObjCAtThrowStmt>(*S)); 155 break; 156 case Stmt::ObjCAtSynchronizedStmtClass: 157 EmitObjCAtSynchronizedStmt(cast<ObjCAtSynchronizedStmt>(*S)); 158 break; 159 case Stmt::ObjCForCollectionStmtClass: 160 EmitObjCForCollectionStmt(cast<ObjCForCollectionStmt>(*S)); 161 break; 162 case Stmt::ObjCAutoreleasePoolStmtClass: 163 EmitObjCAutoreleasePoolStmt(cast<ObjCAutoreleasePoolStmt>(*S)); 164 break; 165 166 case Stmt::CXXTryStmtClass: 167 EmitCXXTryStmt(cast<CXXTryStmt>(*S)); 168 break; 169 case Stmt::CXXForRangeStmtClass: 170 EmitCXXForRangeStmt(cast<CXXForRangeStmt>(*S)); 171 break; 172 case Stmt::SEHTryStmtClass: 173 EmitSEHTryStmt(cast<SEHTryStmt>(*S)); 174 break; 175 } 176} 177 178bool CodeGenFunction::EmitSimpleStmt(const Stmt *S) { 179 switch (S->getStmtClass()) { 180 default: return false; 181 case Stmt::NullStmtClass: break; 182 case Stmt::CompoundStmtClass: EmitCompoundStmt(cast<CompoundStmt>(*S)); break; 183 case Stmt::DeclStmtClass: EmitDeclStmt(cast<DeclStmt>(*S)); break; 184 case Stmt::LabelStmtClass: EmitLabelStmt(cast<LabelStmt>(*S)); break; 185 case Stmt::AttributedStmtClass: 186 EmitAttributedStmt(cast<AttributedStmt>(*S)); break; 187 case Stmt::GotoStmtClass: EmitGotoStmt(cast<GotoStmt>(*S)); break; 188 case Stmt::BreakStmtClass: EmitBreakStmt(cast<BreakStmt>(*S)); break; 189 case Stmt::ContinueStmtClass: EmitContinueStmt(cast<ContinueStmt>(*S)); break; 190 case Stmt::DefaultStmtClass: EmitDefaultStmt(cast<DefaultStmt>(*S)); break; 191 case Stmt::CaseStmtClass: EmitCaseStmt(cast<CaseStmt>(*S)); break; 192 } 193 194 return true; 195} 196 197/// EmitCompoundStmt - Emit a compound statement {..} node. If GetLast is true, 198/// this captures the expression result of the last sub-statement and returns it 199/// (for use by the statement expression extension). 200llvm::Value* CodeGenFunction::EmitCompoundStmt(const CompoundStmt &S, bool GetLast, 201 AggValueSlot AggSlot) { 202 PrettyStackTraceLoc CrashInfo(getContext().getSourceManager(),S.getLBracLoc(), 203 "LLVM IR generation of compound statement ('{}')"); 204 205 // Keep track of the current cleanup stack depth, including debug scopes. 206 LexicalScope Scope(*this, S.getSourceRange()); 207 208 return EmitCompoundStmtWithoutScope(S, GetLast, AggSlot); 209} 210 211llvm::Value* 212CodeGenFunction::EmitCompoundStmtWithoutScope(const CompoundStmt &S, 213 bool GetLast, 214 AggValueSlot AggSlot) { 215 216 for (CompoundStmt::const_body_iterator I = S.body_begin(), 217 E = S.body_end()-GetLast; I != E; ++I) 218 EmitStmt(*I); 219 220 llvm::Value *RetAlloca = 0; 221 if (GetLast) { 222 // We have to special case labels here. They are statements, but when put 223 // at the end of a statement expression, they yield the value of their 224 // subexpression. Handle this by walking through all labels we encounter, 225 // emitting them before we evaluate the subexpr. 226 const Stmt *LastStmt = S.body_back(); 227 while (const LabelStmt *LS = dyn_cast<LabelStmt>(LastStmt)) { 228 EmitLabel(LS->getDecl()); 229 LastStmt = LS->getSubStmt(); 230 } 231 232 EnsureInsertPoint(); 233 234 QualType ExprTy = cast<Expr>(LastStmt)->getType(); 235 if (hasAggregateEvaluationKind(ExprTy)) { 236 EmitAggExpr(cast<Expr>(LastStmt), AggSlot); 237 } else { 238 // We can't return an RValue here because there might be cleanups at 239 // the end of the StmtExpr. Because of that, we have to emit the result 240 // here into a temporary alloca. 241 RetAlloca = CreateMemTemp(ExprTy); 242 EmitAnyExprToMem(cast<Expr>(LastStmt), RetAlloca, Qualifiers(), 243 /*IsInit*/false); 244 } 245 246 } 247 248 return RetAlloca; 249} 250 251void CodeGenFunction::SimplifyForwardingBlocks(llvm::BasicBlock *BB) { 252 llvm::BranchInst *BI = dyn_cast<llvm::BranchInst>(BB->getTerminator()); 253 254 // If there is a cleanup stack, then we it isn't worth trying to 255 // simplify this block (we would need to remove it from the scope map 256 // and cleanup entry). 257 if (!EHStack.empty()) 258 return; 259 260 // Can only simplify direct branches. 261 if (!BI || !BI->isUnconditional()) 262 return; 263 264 // Can only simplify empty blocks. 265 if (BI != BB->begin()) 266 return; 267 268 BB->replaceAllUsesWith(BI->getSuccessor(0)); 269 BI->eraseFromParent(); 270 BB->eraseFromParent(); 271} 272 273void CodeGenFunction::EmitBlock(llvm::BasicBlock *BB, bool IsFinished) { 274 llvm::BasicBlock *CurBB = Builder.GetInsertBlock(); 275 276 // Fall out of the current block (if necessary). 277 EmitBranch(BB); 278 279 if (IsFinished && BB->use_empty()) { 280 delete BB; 281 return; 282 } 283 284 // Place the block after the current block, if possible, or else at 285 // the end of the function. 286 if (CurBB && CurBB->getParent()) 287 CurFn->getBasicBlockList().insertAfter(CurBB, BB); 288 else 289 CurFn->getBasicBlockList().push_back(BB); 290 Builder.SetInsertPoint(BB); 291} 292 293void CodeGenFunction::EmitBranch(llvm::BasicBlock *Target) { 294 // Emit a branch from the current block to the target one if this 295 // was a real block. If this was just a fall-through block after a 296 // terminator, don't emit it. 297 llvm::BasicBlock *CurBB = Builder.GetInsertBlock(); 298 299 if (!CurBB || CurBB->getTerminator()) { 300 // If there is no insert point or the previous block is already 301 // terminated, don't touch it. 302 } else { 303 // Otherwise, create a fall-through branch. 304 Builder.CreateBr(Target); 305 } 306 307 Builder.ClearInsertionPoint(); 308} 309 310void CodeGenFunction::EmitBlockAfterUses(llvm::BasicBlock *block) { 311 bool inserted = false; 312 for (llvm::BasicBlock::use_iterator 313 i = block->use_begin(), e = block->use_end(); i != e; ++i) { 314 if (llvm::Instruction *insn = dyn_cast<llvm::Instruction>(*i)) { 315 CurFn->getBasicBlockList().insertAfter(insn->getParent(), block); 316 inserted = true; 317 break; 318 } 319 } 320 321 if (!inserted) 322 CurFn->getBasicBlockList().push_back(block); 323 324 Builder.SetInsertPoint(block); 325} 326 327CodeGenFunction::JumpDest 328CodeGenFunction::getJumpDestForLabel(const LabelDecl *D) { 329 JumpDest &Dest = LabelMap[D]; 330 if (Dest.isValid()) return Dest; 331 332 // Create, but don't insert, the new block. 333 Dest = JumpDest(createBasicBlock(D->getName()), 334 EHScopeStack::stable_iterator::invalid(), 335 NextCleanupDestIndex++); 336 return Dest; 337} 338 339void CodeGenFunction::EmitLabel(const LabelDecl *D) { 340 // Add this label to the current lexical scope if we're within any 341 // normal cleanups. Jumps "in" to this label --- when permitted by 342 // the language --- may need to be routed around such cleanups. 343 if (EHStack.hasNormalCleanups() && CurLexicalScope) 344 CurLexicalScope->addLabel(D); 345 346 JumpDest &Dest = LabelMap[D]; 347 348 // If we didn't need a forward reference to this label, just go 349 // ahead and create a destination at the current scope. 350 if (!Dest.isValid()) { 351 Dest = getJumpDestInCurrentScope(D->getName()); 352 353 // Otherwise, we need to give this label a target depth and remove 354 // it from the branch-fixups list. 355 } else { 356 assert(!Dest.getScopeDepth().isValid() && "already emitted label!"); 357 Dest.setScopeDepth(EHStack.stable_begin()); 358 ResolveBranchFixups(Dest.getBlock()); 359 } 360 361 EmitBlock(Dest.getBlock()); 362} 363 364/// Change the cleanup scope of the labels in this lexical scope to 365/// match the scope of the enclosing context. 366void CodeGenFunction::LexicalScope::rescopeLabels() { 367 assert(!Labels.empty()); 368 EHScopeStack::stable_iterator innermostScope 369 = CGF.EHStack.getInnermostNormalCleanup(); 370 371 // Change the scope depth of all the labels. 372 for (SmallVectorImpl<const LabelDecl*>::const_iterator 373 i = Labels.begin(), e = Labels.end(); i != e; ++i) { 374 assert(CGF.LabelMap.count(*i)); 375 JumpDest &dest = CGF.LabelMap.find(*i)->second; 376 assert(dest.getScopeDepth().isValid()); 377 assert(innermostScope.encloses(dest.getScopeDepth())); 378 dest.setScopeDepth(innermostScope); 379 } 380 381 // Reparent the labels if the new scope also has cleanups. 382 if (innermostScope != EHScopeStack::stable_end() && ParentScope) { 383 ParentScope->Labels.append(Labels.begin(), Labels.end()); 384 } 385} 386 387 388void CodeGenFunction::EmitLabelStmt(const LabelStmt &S) { 389 EmitLabel(S.getDecl()); 390 EmitStmt(S.getSubStmt()); 391} 392 393void CodeGenFunction::EmitAttributedStmt(const AttributedStmt &S) { 394 EmitStmt(S.getSubStmt()); 395} 396 397void CodeGenFunction::EmitGotoStmt(const GotoStmt &S) { 398 // If this code is reachable then emit a stop point (if generating 399 // debug info). We have to do this ourselves because we are on the 400 // "simple" statement path. 401 if (HaveInsertPoint()) 402 EmitStopPoint(&S); 403 404 EmitBranchThroughCleanup(getJumpDestForLabel(S.getLabel())); 405} 406 407 408void CodeGenFunction::EmitIndirectGotoStmt(const IndirectGotoStmt &S) { 409 if (const LabelDecl *Target = S.getConstantTarget()) { 410 EmitBranchThroughCleanup(getJumpDestForLabel(Target)); 411 return; 412 } 413 414 // Ensure that we have an i8* for our PHI node. 415 llvm::Value *V = Builder.CreateBitCast(EmitScalarExpr(S.getTarget()), 416 Int8PtrTy, "addr"); 417 llvm::BasicBlock *CurBB = Builder.GetInsertBlock(); 418 419 // Get the basic block for the indirect goto. 420 llvm::BasicBlock *IndGotoBB = GetIndirectGotoBlock(); 421 422 // The first instruction in the block has to be the PHI for the switch dest, 423 // add an entry for this branch. 424 cast<llvm::PHINode>(IndGotoBB->begin())->addIncoming(V, CurBB); 425 426 EmitBranch(IndGotoBB); 427} 428 429void CodeGenFunction::EmitIfStmt(const IfStmt &S) { 430 // C99 6.8.4.1: The first substatement is executed if the expression compares 431 // unequal to 0. The condition must be a scalar type. 432 LexicalScope ConditionScope(*this, S.getSourceRange()); 433 434 if (S.getConditionVariable()) 435 EmitAutoVarDecl(*S.getConditionVariable()); 436 437 // If the condition constant folds and can be elided, try to avoid emitting 438 // the condition and the dead arm of the if/else. 439 bool CondConstant; 440 if (ConstantFoldsToSimpleInteger(S.getCond(), CondConstant)) { 441 // Figure out which block (then or else) is executed. 442 const Stmt *Executed = S.getThen(); 443 const Stmt *Skipped = S.getElse(); 444 if (!CondConstant) // Condition false? 445 std::swap(Executed, Skipped); 446 447 // If the skipped block has no labels in it, just emit the executed block. 448 // This avoids emitting dead code and simplifies the CFG substantially. 449 if (!ContainsLabel(Skipped)) { 450 if (Executed) { 451 RunCleanupsScope ExecutedScope(*this); 452 EmitStmt(Executed); 453 } 454 return; 455 } 456 } 457 458 // Otherwise, the condition did not fold, or we couldn't elide it. Just emit 459 // the conditional branch. 460 llvm::BasicBlock *ThenBlock = createBasicBlock("if.then"); 461 llvm::BasicBlock *ContBlock = createBasicBlock("if.end"); 462 llvm::BasicBlock *ElseBlock = ContBlock; 463 if (S.getElse()) 464 ElseBlock = createBasicBlock("if.else"); 465 EmitBranchOnBoolExpr(S.getCond(), ThenBlock, ElseBlock); 466 467 // Emit the 'then' code. 468 EmitBlock(ThenBlock); 469 { 470 RunCleanupsScope ThenScope(*this); 471 EmitStmt(S.getThen()); 472 } 473 EmitBranch(ContBlock); 474 475 // Emit the 'else' code if present. 476 if (const Stmt *Else = S.getElse()) { 477 // There is no need to emit line number for unconditional branch. 478 if (getDebugInfo()) 479 Builder.SetCurrentDebugLocation(llvm::DebugLoc()); 480 EmitBlock(ElseBlock); 481 { 482 RunCleanupsScope ElseScope(*this); 483 EmitStmt(Else); 484 } 485 // There is no need to emit line number for unconditional branch. 486 if (getDebugInfo()) 487 Builder.SetCurrentDebugLocation(llvm::DebugLoc()); 488 EmitBranch(ContBlock); 489 } 490 491 // Emit the continuation block for code after the if. 492 EmitBlock(ContBlock, true); 493} 494 495void CodeGenFunction::EmitWhileStmt(const WhileStmt &S) { 496 // Emit the header for the loop, which will also become 497 // the continue target. 498 JumpDest LoopHeader = getJumpDestInCurrentScope("while.cond"); 499 EmitBlock(LoopHeader.getBlock()); 500 501 // Create an exit block for when the condition fails, which will 502 // also become the break target. 503 JumpDest LoopExit = getJumpDestInCurrentScope("while.end"); 504 505 // Store the blocks to use for break and continue. 506 BreakContinueStack.push_back(BreakContinue(LoopExit, LoopHeader)); 507 508 // C++ [stmt.while]p2: 509 // When the condition of a while statement is a declaration, the 510 // scope of the variable that is declared extends from its point 511 // of declaration (3.3.2) to the end of the while statement. 512 // [...] 513 // The object created in a condition is destroyed and created 514 // with each iteration of the loop. 515 RunCleanupsScope ConditionScope(*this); 516 517 if (S.getConditionVariable()) 518 EmitAutoVarDecl(*S.getConditionVariable()); 519 520 // Evaluate the conditional in the while header. C99 6.8.5.1: The 521 // evaluation of the controlling expression takes place before each 522 // execution of the loop body. 523 llvm::Value *BoolCondVal = EvaluateExprAsBool(S.getCond()); 524 525 // while(1) is common, avoid extra exit blocks. Be sure 526 // to correctly handle break/continue though. 527 bool EmitBoolCondBranch = true; 528 if (llvm::ConstantInt *C = dyn_cast<llvm::ConstantInt>(BoolCondVal)) 529 if (C->isOne()) 530 EmitBoolCondBranch = false; 531 532 // As long as the condition is true, go to the loop body. 533 llvm::BasicBlock *LoopBody = createBasicBlock("while.body"); 534 if (EmitBoolCondBranch) { 535 llvm::BasicBlock *ExitBlock = LoopExit.getBlock(); 536 if (ConditionScope.requiresCleanups()) 537 ExitBlock = createBasicBlock("while.exit"); 538 539 Builder.CreateCondBr(BoolCondVal, LoopBody, ExitBlock); 540 541 if (ExitBlock != LoopExit.getBlock()) { 542 EmitBlock(ExitBlock); 543 EmitBranchThroughCleanup(LoopExit); 544 } 545 } 546 547 // Emit the loop body. We have to emit this in a cleanup scope 548 // because it might be a singleton DeclStmt. 549 { 550 RunCleanupsScope BodyScope(*this); 551 EmitBlock(LoopBody); 552 EmitStmt(S.getBody()); 553 } 554 555 BreakContinueStack.pop_back(); 556 557 // Immediately force cleanup. 558 ConditionScope.ForceCleanup(); 559 560 // Branch to the loop header again. 561 EmitBranch(LoopHeader.getBlock()); 562 563 // Emit the exit block. 564 EmitBlock(LoopExit.getBlock(), true); 565 566 // The LoopHeader typically is just a branch if we skipped emitting 567 // a branch, try to erase it. 568 if (!EmitBoolCondBranch) 569 SimplifyForwardingBlocks(LoopHeader.getBlock()); 570} 571 572void CodeGenFunction::EmitDoStmt(const DoStmt &S) { 573 JumpDest LoopExit = getJumpDestInCurrentScope("do.end"); 574 JumpDest LoopCond = getJumpDestInCurrentScope("do.cond"); 575 576 // Store the blocks to use for break and continue. 577 BreakContinueStack.push_back(BreakContinue(LoopExit, LoopCond)); 578 579 // Emit the body of the loop. 580 llvm::BasicBlock *LoopBody = createBasicBlock("do.body"); 581 EmitBlock(LoopBody); 582 { 583 RunCleanupsScope BodyScope(*this); 584 EmitStmt(S.getBody()); 585 } 586 587 BreakContinueStack.pop_back(); 588 589 EmitBlock(LoopCond.getBlock()); 590 591 // C99 6.8.5.2: "The evaluation of the controlling expression takes place 592 // after each execution of the loop body." 593 594 // Evaluate the conditional in the while header. 595 // C99 6.8.5p2/p4: The first substatement is executed if the expression 596 // compares unequal to 0. The condition must be a scalar type. 597 llvm::Value *BoolCondVal = EvaluateExprAsBool(S.getCond()); 598 599 // "do {} while (0)" is common in macros, avoid extra blocks. Be sure 600 // to correctly handle break/continue though. 601 bool EmitBoolCondBranch = true; 602 if (llvm::ConstantInt *C = dyn_cast<llvm::ConstantInt>(BoolCondVal)) 603 if (C->isZero()) 604 EmitBoolCondBranch = false; 605 606 // As long as the condition is true, iterate the loop. 607 if (EmitBoolCondBranch) 608 Builder.CreateCondBr(BoolCondVal, LoopBody, LoopExit.getBlock()); 609 610 // Emit the exit block. 611 EmitBlock(LoopExit.getBlock()); 612 613 // The DoCond block typically is just a branch if we skipped 614 // emitting a branch, try to erase it. 615 if (!EmitBoolCondBranch) 616 SimplifyForwardingBlocks(LoopCond.getBlock()); 617} 618 619void CodeGenFunction::EmitForStmt(const ForStmt &S) { 620 JumpDest LoopExit = getJumpDestInCurrentScope("for.end"); 621 622 RunCleanupsScope ForScope(*this); 623 624 CGDebugInfo *DI = getDebugInfo(); 625 if (DI) 626 DI->EmitLexicalBlockStart(Builder, S.getSourceRange().getBegin()); 627 628 // Evaluate the first part before the loop. 629 if (S.getInit()) 630 EmitStmt(S.getInit()); 631 632 // Start the loop with a block that tests the condition. 633 // If there's an increment, the continue scope will be overwritten 634 // later. 635 JumpDest Continue = getJumpDestInCurrentScope("for.cond"); 636 llvm::BasicBlock *CondBlock = Continue.getBlock(); 637 EmitBlock(CondBlock); 638 639 // Create a cleanup scope for the condition variable cleanups. 640 RunCleanupsScope ConditionScope(*this); 641 642 if (S.getCond()) { 643 // If the for statement has a condition scope, emit the local variable 644 // declaration. 645 if (S.getConditionVariable()) { 646 EmitAutoVarDecl(*S.getConditionVariable()); 647 } 648 649 llvm::BasicBlock *ExitBlock = LoopExit.getBlock(); 650 // If there are any cleanups between here and the loop-exit scope, 651 // create a block to stage a loop exit along. 652 if (ForScope.requiresCleanups()) 653 ExitBlock = createBasicBlock("for.cond.cleanup"); 654 655 // As long as the condition is true, iterate the loop. 656 llvm::BasicBlock *ForBody = createBasicBlock("for.body"); 657 658 // C99 6.8.5p2/p4: The first substatement is executed if the expression 659 // compares unequal to 0. The condition must be a scalar type. 660 EmitBranchOnBoolExpr(S.getCond(), ForBody, ExitBlock); 661 662 if (ExitBlock != LoopExit.getBlock()) { 663 EmitBlock(ExitBlock); 664 EmitBranchThroughCleanup(LoopExit); 665 } 666 667 EmitBlock(ForBody); 668 } else { 669 // Treat it as a non-zero constant. Don't even create a new block for the 670 // body, just fall into it. 671 } 672 673 // If the for loop doesn't have an increment we can just use the 674 // condition as the continue block. Otherwise we'll need to create 675 // a block for it (in the current scope, i.e. in the scope of the 676 // condition), and that we will become our continue block. 677 if (S.getInc()) 678 Continue = getJumpDestInCurrentScope("for.inc"); 679 680 // Store the blocks to use for break and continue. 681 BreakContinueStack.push_back(BreakContinue(LoopExit, Continue)); 682 683 { 684 // Create a separate cleanup scope for the body, in case it is not 685 // a compound statement. 686 RunCleanupsScope BodyScope(*this); 687 EmitStmt(S.getBody()); 688 } 689 690 // If there is an increment, emit it next. 691 if (S.getInc()) { 692 EmitBlock(Continue.getBlock()); 693 EmitStmt(S.getInc()); 694 } 695 696 BreakContinueStack.pop_back(); 697 698 ConditionScope.ForceCleanup(); 699 EmitBranch(CondBlock); 700 701 ForScope.ForceCleanup(); 702 703 if (DI) 704 DI->EmitLexicalBlockEnd(Builder, S.getSourceRange().getEnd()); 705 706 // Emit the fall-through block. 707 EmitBlock(LoopExit.getBlock(), true); 708} 709 710void CodeGenFunction::EmitCXXForRangeStmt(const CXXForRangeStmt &S) { 711 JumpDest LoopExit = getJumpDestInCurrentScope("for.end"); 712 713 RunCleanupsScope ForScope(*this); 714 715 CGDebugInfo *DI = getDebugInfo(); 716 if (DI) 717 DI->EmitLexicalBlockStart(Builder, S.getSourceRange().getBegin()); 718 719 // Evaluate the first pieces before the loop. 720 EmitStmt(S.getRangeStmt()); 721 EmitStmt(S.getBeginEndStmt()); 722 723 // Start the loop with a block that tests the condition. 724 // If there's an increment, the continue scope will be overwritten 725 // later. 726 llvm::BasicBlock *CondBlock = createBasicBlock("for.cond"); 727 EmitBlock(CondBlock); 728 729 // If there are any cleanups between here and the loop-exit scope, 730 // create a block to stage a loop exit along. 731 llvm::BasicBlock *ExitBlock = LoopExit.getBlock(); 732 if (ForScope.requiresCleanups()) 733 ExitBlock = createBasicBlock("for.cond.cleanup"); 734 735 // The loop body, consisting of the specified body and the loop variable. 736 llvm::BasicBlock *ForBody = createBasicBlock("for.body"); 737 738 // The body is executed if the expression, contextually converted 739 // to bool, is true. 740 EmitBranchOnBoolExpr(S.getCond(), ForBody, ExitBlock); 741 742 if (ExitBlock != LoopExit.getBlock()) { 743 EmitBlock(ExitBlock); 744 EmitBranchThroughCleanup(LoopExit); 745 } 746 747 EmitBlock(ForBody); 748 749 // Create a block for the increment. In case of a 'continue', we jump there. 750 JumpDest Continue = getJumpDestInCurrentScope("for.inc"); 751 752 // Store the blocks to use for break and continue. 753 BreakContinueStack.push_back(BreakContinue(LoopExit, Continue)); 754 755 { 756 // Create a separate cleanup scope for the loop variable and body. 757 RunCleanupsScope BodyScope(*this); 758 EmitStmt(S.getLoopVarStmt()); 759 EmitStmt(S.getBody()); 760 } 761 762 // If there is an increment, emit it next. 763 EmitBlock(Continue.getBlock()); 764 EmitStmt(S.getInc()); 765 766 BreakContinueStack.pop_back(); 767 768 EmitBranch(CondBlock); 769 770 ForScope.ForceCleanup(); 771 772 if (DI) 773 DI->EmitLexicalBlockEnd(Builder, S.getSourceRange().getEnd()); 774 775 // Emit the fall-through block. 776 EmitBlock(LoopExit.getBlock(), true); 777} 778 779void CodeGenFunction::EmitReturnOfRValue(RValue RV, QualType Ty) { 780 if (RV.isScalar()) { 781 Builder.CreateStore(RV.getScalarVal(), ReturnValue); 782 } else if (RV.isAggregate()) { 783 EmitAggregateCopy(ReturnValue, RV.getAggregateAddr(), Ty); 784 } else { 785 EmitStoreOfComplex(RV.getComplexVal(), 786 MakeNaturalAlignAddrLValue(ReturnValue, Ty), 787 /*init*/ true); 788 } 789 EmitBranchThroughCleanup(ReturnBlock); 790} 791 792/// EmitReturnStmt - Note that due to GCC extensions, this can have an operand 793/// if the function returns void, or may be missing one if the function returns 794/// non-void. Fun stuff :). 795void CodeGenFunction::EmitReturnStmt(const ReturnStmt &S) { 796 // Emit the result value, even if unused, to evalute the side effects. 797 const Expr *RV = S.getRetValue(); 798 799 // Treat block literals in a return expression as if they appeared 800 // in their own scope. This permits a small, easily-implemented 801 // exception to our over-conservative rules about not jumping to 802 // statements following block literals with non-trivial cleanups. 803 RunCleanupsScope cleanupScope(*this); 804 if (const ExprWithCleanups *cleanups = 805 dyn_cast_or_null<ExprWithCleanups>(RV)) { 806 enterFullExpression(cleanups); 807 RV = cleanups->getSubExpr(); 808 } 809 810 // FIXME: Clean this up by using an LValue for ReturnTemp, 811 // EmitStoreThroughLValue, and EmitAnyExpr. 812 if (S.getNRVOCandidate() && S.getNRVOCandidate()->isNRVOVariable()) { 813 // Apply the named return value optimization for this return statement, 814 // which means doing nothing: the appropriate result has already been 815 // constructed into the NRVO variable. 816 817 // If there is an NRVO flag for this variable, set it to 1 into indicate 818 // that the cleanup code should not destroy the variable. 819 if (llvm::Value *NRVOFlag = NRVOFlags[S.getNRVOCandidate()]) 820 Builder.CreateStore(Builder.getTrue(), NRVOFlag); 821 } else if (!ReturnValue) { 822 // Make sure not to return anything, but evaluate the expression 823 // for side effects. 824 if (RV) 825 EmitAnyExpr(RV); 826 } else if (RV == 0) { 827 // Do nothing (return value is left uninitialized) 828 } else if (FnRetTy->isReferenceType()) { 829 // If this function returns a reference, take the address of the expression 830 // rather than the value. 831 RValue Result = EmitReferenceBindingToExpr(RV); 832 Builder.CreateStore(Result.getScalarVal(), ReturnValue); 833 } else { 834 switch (getEvaluationKind(RV->getType())) { 835 case TEK_Scalar: 836 Builder.CreateStore(EmitScalarExpr(RV), ReturnValue); 837 break; 838 case TEK_Complex: 839 EmitComplexExprIntoLValue(RV, 840 MakeNaturalAlignAddrLValue(ReturnValue, RV->getType()), 841 /*isInit*/ true); 842 break; 843 case TEK_Aggregate: { 844 CharUnits Alignment = getContext().getTypeAlignInChars(RV->getType()); 845 EmitAggExpr(RV, AggValueSlot::forAddr(ReturnValue, Alignment, 846 Qualifiers(), 847 AggValueSlot::IsDestructed, 848 AggValueSlot::DoesNotNeedGCBarriers, 849 AggValueSlot::IsNotAliased)); 850 break; 851 } 852 } 853 } 854 855 ++NumReturnExprs; 856 if (RV == 0 || RV->isEvaluatable(getContext())) 857 ++NumSimpleReturnExprs; 858 859 cleanupScope.ForceCleanup(); 860 EmitBranchThroughCleanup(ReturnBlock); 861} 862 863void CodeGenFunction::EmitDeclStmt(const DeclStmt &S) { 864 // As long as debug info is modeled with instructions, we have to ensure we 865 // have a place to insert here and write the stop point here. 866 if (HaveInsertPoint()) 867 EmitStopPoint(&S); 868 869 for (DeclStmt::const_decl_iterator I = S.decl_begin(), E = S.decl_end(); 870 I != E; ++I) 871 EmitDecl(**I); 872} 873 874void CodeGenFunction::EmitBreakStmt(const BreakStmt &S) { 875 assert(!BreakContinueStack.empty() && "break stmt not in a loop or switch!"); 876 877 // If this code is reachable then emit a stop point (if generating 878 // debug info). We have to do this ourselves because we are on the 879 // "simple" statement path. 880 if (HaveInsertPoint()) 881 EmitStopPoint(&S); 882 883 JumpDest Block = BreakContinueStack.back().BreakBlock; 884 EmitBranchThroughCleanup(Block); 885} 886 887void CodeGenFunction::EmitContinueStmt(const ContinueStmt &S) { 888 assert(!BreakContinueStack.empty() && "continue stmt not in a loop!"); 889 890 // If this code is reachable then emit a stop point (if generating 891 // debug info). We have to do this ourselves because we are on the 892 // "simple" statement path. 893 if (HaveInsertPoint()) 894 EmitStopPoint(&S); 895 896 JumpDest Block = BreakContinueStack.back().ContinueBlock; 897 EmitBranchThroughCleanup(Block); 898} 899 900/// EmitCaseStmtRange - If case statement range is not too big then 901/// add multiple cases to switch instruction, one for each value within 902/// the range. If range is too big then emit "if" condition check. 903void CodeGenFunction::EmitCaseStmtRange(const CaseStmt &S) { 904 assert(S.getRHS() && "Expected RHS value in CaseStmt"); 905 906 llvm::APSInt LHS = S.getLHS()->EvaluateKnownConstInt(getContext()); 907 llvm::APSInt RHS = S.getRHS()->EvaluateKnownConstInt(getContext()); 908 909 // Emit the code for this case. We do this first to make sure it is 910 // properly chained from our predecessor before generating the 911 // switch machinery to enter this block. 912 EmitBlock(createBasicBlock("sw.bb")); 913 llvm::BasicBlock *CaseDest = Builder.GetInsertBlock(); 914 EmitStmt(S.getSubStmt()); 915 916 // If range is empty, do nothing. 917 if (LHS.isSigned() ? RHS.slt(LHS) : RHS.ult(LHS)) 918 return; 919 920 llvm::APInt Range = RHS - LHS; 921 // FIXME: parameters such as this should not be hardcoded. 922 if (Range.ult(llvm::APInt(Range.getBitWidth(), 64))) { 923 // Range is small enough to add multiple switch instruction cases. 924 for (unsigned i = 0, e = Range.getZExtValue() + 1; i != e; ++i) { 925 SwitchInsn->addCase(Builder.getInt(LHS), CaseDest); 926 LHS++; 927 } 928 return; 929 } 930 931 // The range is too big. Emit "if" condition into a new block, 932 // making sure to save and restore the current insertion point. 933 llvm::BasicBlock *RestoreBB = Builder.GetInsertBlock(); 934 935 // Push this test onto the chain of range checks (which terminates 936 // in the default basic block). The switch's default will be changed 937 // to the top of this chain after switch emission is complete. 938 llvm::BasicBlock *FalseDest = CaseRangeBlock; 939 CaseRangeBlock = createBasicBlock("sw.caserange"); 940 941 CurFn->getBasicBlockList().push_back(CaseRangeBlock); 942 Builder.SetInsertPoint(CaseRangeBlock); 943 944 // Emit range check. 945 llvm::Value *Diff = 946 Builder.CreateSub(SwitchInsn->getCondition(), Builder.getInt(LHS)); 947 llvm::Value *Cond = 948 Builder.CreateICmpULE(Diff, Builder.getInt(Range), "inbounds"); 949 Builder.CreateCondBr(Cond, CaseDest, FalseDest); 950 951 // Restore the appropriate insertion point. 952 if (RestoreBB) 953 Builder.SetInsertPoint(RestoreBB); 954 else 955 Builder.ClearInsertionPoint(); 956} 957 958void CodeGenFunction::EmitCaseStmt(const CaseStmt &S) { 959 // If there is no enclosing switch instance that we're aware of, then this 960 // case statement and its block can be elided. This situation only happens 961 // when we've constant-folded the switch, are emitting the constant case, 962 // and part of the constant case includes another case statement. For 963 // instance: switch (4) { case 4: do { case 5: } while (1); } 964 if (!SwitchInsn) { 965 EmitStmt(S.getSubStmt()); 966 return; 967 } 968 969 // Handle case ranges. 970 if (S.getRHS()) { 971 EmitCaseStmtRange(S); 972 return; 973 } 974 975 llvm::ConstantInt *CaseVal = 976 Builder.getInt(S.getLHS()->EvaluateKnownConstInt(getContext())); 977 978 // If the body of the case is just a 'break', and if there was no fallthrough, 979 // try to not emit an empty block. 980 if ((CGM.getCodeGenOpts().OptimizationLevel > 0) && 981 isa<BreakStmt>(S.getSubStmt())) { 982 JumpDest Block = BreakContinueStack.back().BreakBlock; 983 984 // Only do this optimization if there are no cleanups that need emitting. 985 if (isObviouslyBranchWithoutCleanups(Block)) { 986 SwitchInsn->addCase(CaseVal, Block.getBlock()); 987 988 // If there was a fallthrough into this case, make sure to redirect it to 989 // the end of the switch as well. 990 if (Builder.GetInsertBlock()) { 991 Builder.CreateBr(Block.getBlock()); 992 Builder.ClearInsertionPoint(); 993 } 994 return; 995 } 996 } 997 998 EmitBlock(createBasicBlock("sw.bb")); 999 llvm::BasicBlock *CaseDest = Builder.GetInsertBlock(); 1000 SwitchInsn->addCase(CaseVal, CaseDest); 1001 1002 // Recursively emitting the statement is acceptable, but is not wonderful for 1003 // code where we have many case statements nested together, i.e.: 1004 // case 1: 1005 // case 2: 1006 // case 3: etc. 1007 // Handling this recursively will create a new block for each case statement 1008 // that falls through to the next case which is IR intensive. It also causes 1009 // deep recursion which can run into stack depth limitations. Handle 1010 // sequential non-range case statements specially. 1011 const CaseStmt *CurCase = &S; 1012 const CaseStmt *NextCase = dyn_cast<CaseStmt>(S.getSubStmt()); 1013 1014 // Otherwise, iteratively add consecutive cases to this switch stmt. 1015 while (NextCase && NextCase->getRHS() == 0) { 1016 CurCase = NextCase; 1017 llvm::ConstantInt *CaseVal = 1018 Builder.getInt(CurCase->getLHS()->EvaluateKnownConstInt(getContext())); 1019 SwitchInsn->addCase(CaseVal, CaseDest); 1020 NextCase = dyn_cast<CaseStmt>(CurCase->getSubStmt()); 1021 } 1022 1023 // Normal default recursion for non-cases. 1024 EmitStmt(CurCase->getSubStmt()); 1025} 1026 1027void CodeGenFunction::EmitDefaultStmt(const DefaultStmt &S) { 1028 llvm::BasicBlock *DefaultBlock = SwitchInsn->getDefaultDest(); 1029 assert(DefaultBlock->empty() && 1030 "EmitDefaultStmt: Default block already defined?"); 1031 EmitBlock(DefaultBlock); 1032 EmitStmt(S.getSubStmt()); 1033} 1034 1035/// CollectStatementsForCase - Given the body of a 'switch' statement and a 1036/// constant value that is being switched on, see if we can dead code eliminate 1037/// the body of the switch to a simple series of statements to emit. Basically, 1038/// on a switch (5) we want to find these statements: 1039/// case 5: 1040/// printf(...); <-- 1041/// ++i; <-- 1042/// break; 1043/// 1044/// and add them to the ResultStmts vector. If it is unsafe to do this 1045/// transformation (for example, one of the elided statements contains a label 1046/// that might be jumped to), return CSFC_Failure. If we handled it and 'S' 1047/// should include statements after it (e.g. the printf() line is a substmt of 1048/// the case) then return CSFC_FallThrough. If we handled it and found a break 1049/// statement, then return CSFC_Success. 1050/// 1051/// If Case is non-null, then we are looking for the specified case, checking 1052/// that nothing we jump over contains labels. If Case is null, then we found 1053/// the case and are looking for the break. 1054/// 1055/// If the recursive walk actually finds our Case, then we set FoundCase to 1056/// true. 1057/// 1058enum CSFC_Result { CSFC_Failure, CSFC_FallThrough, CSFC_Success }; 1059static CSFC_Result CollectStatementsForCase(const Stmt *S, 1060 const SwitchCase *Case, 1061 bool &FoundCase, 1062 SmallVectorImpl<const Stmt*> &ResultStmts) { 1063 // If this is a null statement, just succeed. 1064 if (S == 0) 1065 return Case ? CSFC_Success : CSFC_FallThrough; 1066 1067 // If this is the switchcase (case 4: or default) that we're looking for, then 1068 // we're in business. Just add the substatement. 1069 if (const SwitchCase *SC = dyn_cast<SwitchCase>(S)) { 1070 if (S == Case) { 1071 FoundCase = true; 1072 return CollectStatementsForCase(SC->getSubStmt(), 0, FoundCase, 1073 ResultStmts); 1074 } 1075 1076 // Otherwise, this is some other case or default statement, just ignore it. 1077 return CollectStatementsForCase(SC->getSubStmt(), Case, FoundCase, 1078 ResultStmts); 1079 } 1080 1081 // If we are in the live part of the code and we found our break statement, 1082 // return a success! 1083 if (Case == 0 && isa<BreakStmt>(S)) 1084 return CSFC_Success; 1085 1086 // If this is a switch statement, then it might contain the SwitchCase, the 1087 // break, or neither. 1088 if (const CompoundStmt *CS = dyn_cast<CompoundStmt>(S)) { 1089 // Handle this as two cases: we might be looking for the SwitchCase (if so 1090 // the skipped statements must be skippable) or we might already have it. 1091 CompoundStmt::const_body_iterator I = CS->body_begin(), E = CS->body_end(); 1092 if (Case) { 1093 // Keep track of whether we see a skipped declaration. The code could be 1094 // using the declaration even if it is skipped, so we can't optimize out 1095 // the decl if the kept statements might refer to it. 1096 bool HadSkippedDecl = false; 1097 1098 // If we're looking for the case, just see if we can skip each of the 1099 // substatements. 1100 for (; Case && I != E; ++I) { 1101 HadSkippedDecl |= isa<DeclStmt>(*I); 1102 1103 switch (CollectStatementsForCase(*I, Case, FoundCase, ResultStmts)) { 1104 case CSFC_Failure: return CSFC_Failure; 1105 case CSFC_Success: 1106 // A successful result means that either 1) that the statement doesn't 1107 // have the case and is skippable, or 2) does contain the case value 1108 // and also contains the break to exit the switch. In the later case, 1109 // we just verify the rest of the statements are elidable. 1110 if (FoundCase) { 1111 // If we found the case and skipped declarations, we can't do the 1112 // optimization. 1113 if (HadSkippedDecl) 1114 return CSFC_Failure; 1115 1116 for (++I; I != E; ++I) 1117 if (CodeGenFunction::ContainsLabel(*I, true)) 1118 return CSFC_Failure; 1119 return CSFC_Success; 1120 } 1121 break; 1122 case CSFC_FallThrough: 1123 // If we have a fallthrough condition, then we must have found the 1124 // case started to include statements. Consider the rest of the 1125 // statements in the compound statement as candidates for inclusion. 1126 assert(FoundCase && "Didn't find case but returned fallthrough?"); 1127 // We recursively found Case, so we're not looking for it anymore. 1128 Case = 0; 1129 1130 // If we found the case and skipped declarations, we can't do the 1131 // optimization. 1132 if (HadSkippedDecl) 1133 return CSFC_Failure; 1134 break; 1135 } 1136 } 1137 } 1138 1139 // If we have statements in our range, then we know that the statements are 1140 // live and need to be added to the set of statements we're tracking. 1141 for (; I != E; ++I) { 1142 switch (CollectStatementsForCase(*I, 0, FoundCase, ResultStmts)) { 1143 case CSFC_Failure: return CSFC_Failure; 1144 case CSFC_FallThrough: 1145 // A fallthrough result means that the statement was simple and just 1146 // included in ResultStmt, keep adding them afterwards. 1147 break; 1148 case CSFC_Success: 1149 // A successful result means that we found the break statement and 1150 // stopped statement inclusion. We just ensure that any leftover stmts 1151 // are skippable and return success ourselves. 1152 for (++I; I != E; ++I) 1153 if (CodeGenFunction::ContainsLabel(*I, true)) 1154 return CSFC_Failure; 1155 return CSFC_Success; 1156 } 1157 } 1158 1159 return Case ? CSFC_Success : CSFC_FallThrough; 1160 } 1161 1162 // Okay, this is some other statement that we don't handle explicitly, like a 1163 // for statement or increment etc. If we are skipping over this statement, 1164 // just verify it doesn't have labels, which would make it invalid to elide. 1165 if (Case) { 1166 if (CodeGenFunction::ContainsLabel(S, true)) 1167 return CSFC_Failure; 1168 return CSFC_Success; 1169 } 1170 1171 // Otherwise, we want to include this statement. Everything is cool with that 1172 // so long as it doesn't contain a break out of the switch we're in. 1173 if (CodeGenFunction::containsBreak(S)) return CSFC_Failure; 1174 1175 // Otherwise, everything is great. Include the statement and tell the caller 1176 // that we fall through and include the next statement as well. 1177 ResultStmts.push_back(S); 1178 return CSFC_FallThrough; 1179} 1180 1181/// FindCaseStatementsForValue - Find the case statement being jumped to and 1182/// then invoke CollectStatementsForCase to find the list of statements to emit 1183/// for a switch on constant. See the comment above CollectStatementsForCase 1184/// for more details. 1185static bool FindCaseStatementsForValue(const SwitchStmt &S, 1186 const llvm::APSInt &ConstantCondValue, 1187 SmallVectorImpl<const Stmt*> &ResultStmts, 1188 ASTContext &C) { 1189 // First step, find the switch case that is being branched to. We can do this 1190 // efficiently by scanning the SwitchCase list. 1191 const SwitchCase *Case = S.getSwitchCaseList(); 1192 const DefaultStmt *DefaultCase = 0; 1193 1194 for (; Case; Case = Case->getNextSwitchCase()) { 1195 // It's either a default or case. Just remember the default statement in 1196 // case we're not jumping to any numbered cases. 1197 if (const DefaultStmt *DS = dyn_cast<DefaultStmt>(Case)) { 1198 DefaultCase = DS; 1199 continue; 1200 } 1201 1202 // Check to see if this case is the one we're looking for. 1203 const CaseStmt *CS = cast<CaseStmt>(Case); 1204 // Don't handle case ranges yet. 1205 if (CS->getRHS()) return false; 1206 1207 // If we found our case, remember it as 'case'. 1208 if (CS->getLHS()->EvaluateKnownConstInt(C) == ConstantCondValue) 1209 break; 1210 } 1211 1212 // If we didn't find a matching case, we use a default if it exists, or we 1213 // elide the whole switch body! 1214 if (Case == 0) { 1215 // It is safe to elide the body of the switch if it doesn't contain labels 1216 // etc. If it is safe, return successfully with an empty ResultStmts list. 1217 if (DefaultCase == 0) 1218 return !CodeGenFunction::ContainsLabel(&S); 1219 Case = DefaultCase; 1220 } 1221 1222 // Ok, we know which case is being jumped to, try to collect all the 1223 // statements that follow it. This can fail for a variety of reasons. Also, 1224 // check to see that the recursive walk actually found our case statement. 1225 // Insane cases like this can fail to find it in the recursive walk since we 1226 // don't handle every stmt kind: 1227 // switch (4) { 1228 // while (1) { 1229 // case 4: ... 1230 bool FoundCase = false; 1231 return CollectStatementsForCase(S.getBody(), Case, FoundCase, 1232 ResultStmts) != CSFC_Failure && 1233 FoundCase; 1234} 1235 1236void CodeGenFunction::EmitSwitchStmt(const SwitchStmt &S) { 1237 JumpDest SwitchExit = getJumpDestInCurrentScope("sw.epilog"); 1238 1239 RunCleanupsScope ConditionScope(*this); 1240 1241 if (S.getConditionVariable()) 1242 EmitAutoVarDecl(*S.getConditionVariable()); 1243 1244 // Handle nested switch statements. 1245 llvm::SwitchInst *SavedSwitchInsn = SwitchInsn; 1246 llvm::BasicBlock *SavedCRBlock = CaseRangeBlock; 1247 1248 // See if we can constant fold the condition of the switch and therefore only 1249 // emit the live case statement (if any) of the switch. 1250 llvm::APSInt ConstantCondValue; 1251 if (ConstantFoldsToSimpleInteger(S.getCond(), ConstantCondValue)) { 1252 SmallVector<const Stmt*, 4> CaseStmts; 1253 if (FindCaseStatementsForValue(S, ConstantCondValue, CaseStmts, 1254 getContext())) { 1255 RunCleanupsScope ExecutedScope(*this); 1256 1257 // At this point, we are no longer "within" a switch instance, so 1258 // we can temporarily enforce this to ensure that any embedded case 1259 // statements are not emitted. 1260 SwitchInsn = 0; 1261 1262 // Okay, we can dead code eliminate everything except this case. Emit the 1263 // specified series of statements and we're good. 1264 for (unsigned i = 0, e = CaseStmts.size(); i != e; ++i) 1265 EmitStmt(CaseStmts[i]); 1266 1267 // Now we want to restore the saved switch instance so that nested 1268 // switches continue to function properly 1269 SwitchInsn = SavedSwitchInsn; 1270 1271 return; 1272 } 1273 } 1274 1275 llvm::Value *CondV = EmitScalarExpr(S.getCond()); 1276 1277 // Create basic block to hold stuff that comes after switch 1278 // statement. We also need to create a default block now so that 1279 // explicit case ranges tests can have a place to jump to on 1280 // failure. 1281 llvm::BasicBlock *DefaultBlock = createBasicBlock("sw.default"); 1282 SwitchInsn = Builder.CreateSwitch(CondV, DefaultBlock); 1283 CaseRangeBlock = DefaultBlock; 1284 1285 // Clear the insertion point to indicate we are in unreachable code. 1286 Builder.ClearInsertionPoint(); 1287 1288 // All break statements jump to NextBlock. If BreakContinueStack is non empty 1289 // then reuse last ContinueBlock. 1290 JumpDest OuterContinue; 1291 if (!BreakContinueStack.empty()) 1292 OuterContinue = BreakContinueStack.back().ContinueBlock; 1293 1294 BreakContinueStack.push_back(BreakContinue(SwitchExit, OuterContinue)); 1295 1296 // Emit switch body. 1297 EmitStmt(S.getBody()); 1298 1299 BreakContinueStack.pop_back(); 1300 1301 // Update the default block in case explicit case range tests have 1302 // been chained on top. 1303 SwitchInsn->setDefaultDest(CaseRangeBlock); 1304 1305 // If a default was never emitted: 1306 if (!DefaultBlock->getParent()) { 1307 // If we have cleanups, emit the default block so that there's a 1308 // place to jump through the cleanups from. 1309 if (ConditionScope.requiresCleanups()) { 1310 EmitBlock(DefaultBlock); 1311 1312 // Otherwise, just forward the default block to the switch end. 1313 } else { 1314 DefaultBlock->replaceAllUsesWith(SwitchExit.getBlock()); 1315 delete DefaultBlock; 1316 } 1317 } 1318 1319 ConditionScope.ForceCleanup(); 1320 1321 // Emit continuation. 1322 EmitBlock(SwitchExit.getBlock(), true); 1323 1324 SwitchInsn = SavedSwitchInsn; 1325 CaseRangeBlock = SavedCRBlock; 1326} 1327 1328static std::string 1329SimplifyConstraint(const char *Constraint, const TargetInfo &Target, 1330 SmallVectorImpl<TargetInfo::ConstraintInfo> *OutCons=0) { 1331 std::string Result; 1332 1333 while (*Constraint) { 1334 switch (*Constraint) { 1335 default: 1336 Result += Target.convertConstraint(Constraint); 1337 break; 1338 // Ignore these 1339 case '*': 1340 case '?': 1341 case '!': 1342 case '=': // Will see this and the following in mult-alt constraints. 1343 case '+': 1344 break; 1345 case '#': // Ignore the rest of the constraint alternative. 1346 while (Constraint[1] && Constraint[1] != ',') 1347 Constraint++; 1348 break; 1349 case ',': 1350 Result += "|"; 1351 break; 1352 case 'g': 1353 Result += "imr"; 1354 break; 1355 case '[': { 1356 assert(OutCons && 1357 "Must pass output names to constraints with a symbolic name"); 1358 unsigned Index; 1359 bool result = Target.resolveSymbolicName(Constraint, 1360 &(*OutCons)[0], 1361 OutCons->size(), Index); 1362 assert(result && "Could not resolve symbolic name"); (void)result; 1363 Result += llvm::utostr(Index); 1364 break; 1365 } 1366 } 1367 1368 Constraint++; 1369 } 1370 1371 return Result; 1372} 1373 1374/// AddVariableConstraints - Look at AsmExpr and if it is a variable declared 1375/// as using a particular register add that as a constraint that will be used 1376/// in this asm stmt. 1377static std::string 1378AddVariableConstraints(const std::string &Constraint, const Expr &AsmExpr, 1379 const TargetInfo &Target, CodeGenModule &CGM, 1380 const AsmStmt &Stmt) { 1381 const DeclRefExpr *AsmDeclRef = dyn_cast<DeclRefExpr>(&AsmExpr); 1382 if (!AsmDeclRef) 1383 return Constraint; 1384 const ValueDecl &Value = *AsmDeclRef->getDecl(); 1385 const VarDecl *Variable = dyn_cast<VarDecl>(&Value); 1386 if (!Variable) 1387 return Constraint; 1388 if (Variable->getStorageClass() != SC_Register) 1389 return Constraint; 1390 AsmLabelAttr *Attr = Variable->getAttr<AsmLabelAttr>(); 1391 if (!Attr) 1392 return Constraint; 1393 StringRef Register = Attr->getLabel(); 1394 assert(Target.isValidGCCRegisterName(Register)); 1395 // We're using validateOutputConstraint here because we only care if 1396 // this is a register constraint. 1397 TargetInfo::ConstraintInfo Info(Constraint, ""); 1398 if (Target.validateOutputConstraint(Info) && 1399 !Info.allowsRegister()) { 1400 CGM.ErrorUnsupported(&Stmt, "__asm__"); 1401 return Constraint; 1402 } 1403 // Canonicalize the register here before returning it. 1404 Register = Target.getNormalizedGCCRegisterName(Register); 1405 return "{" + Register.str() + "}"; 1406} 1407 1408llvm::Value* 1409CodeGenFunction::EmitAsmInputLValue(const TargetInfo::ConstraintInfo &Info, 1410 LValue InputValue, QualType InputType, 1411 std::string &ConstraintStr, 1412 SourceLocation Loc) { 1413 llvm::Value *Arg; 1414 if (Info.allowsRegister() || !Info.allowsMemory()) { 1415 if (CodeGenFunction::hasScalarEvaluationKind(InputType)) { 1416 Arg = EmitLoadOfLValue(InputValue, Loc).getScalarVal(); 1417 } else { 1418 llvm::Type *Ty = ConvertType(InputType); 1419 uint64_t Size = CGM.getDataLayout().getTypeSizeInBits(Ty); 1420 if (Size <= 64 && llvm::isPowerOf2_64(Size)) { 1421 Ty = llvm::IntegerType::get(getLLVMContext(), Size); 1422 Ty = llvm::PointerType::getUnqual(Ty); 1423 1424 Arg = Builder.CreateLoad(Builder.CreateBitCast(InputValue.getAddress(), 1425 Ty)); 1426 } else { 1427 Arg = InputValue.getAddress(); 1428 ConstraintStr += '*'; 1429 } 1430 } 1431 } else { 1432 Arg = InputValue.getAddress(); 1433 ConstraintStr += '*'; 1434 } 1435 1436 return Arg; 1437} 1438 1439llvm::Value* CodeGenFunction::EmitAsmInput( 1440 const TargetInfo::ConstraintInfo &Info, 1441 const Expr *InputExpr, 1442 std::string &ConstraintStr) { 1443 if (Info.allowsRegister() || !Info.allowsMemory()) 1444 if (CodeGenFunction::hasScalarEvaluationKind(InputExpr->getType())) 1445 return EmitScalarExpr(InputExpr); 1446 1447 InputExpr = InputExpr->IgnoreParenNoopCasts(getContext()); 1448 LValue Dest = EmitLValue(InputExpr); 1449 return EmitAsmInputLValue(Info, Dest, InputExpr->getType(), ConstraintStr, 1450 InputExpr->getExprLoc()); 1451} 1452 1453/// getAsmSrcLocInfo - Return the !srcloc metadata node to attach to an inline 1454/// asm call instruction. The !srcloc MDNode contains a list of constant 1455/// integers which are the source locations of the start of each line in the 1456/// asm. 1457static llvm::MDNode *getAsmSrcLocInfo(const StringLiteral *Str, 1458 CodeGenFunction &CGF) { 1459 SmallVector<llvm::Value *, 8> Locs; 1460 // Add the location of the first line to the MDNode. 1461 Locs.push_back(llvm::ConstantInt::get(CGF.Int32Ty, 1462 Str->getLocStart().getRawEncoding())); 1463 StringRef StrVal = Str->getString(); 1464 if (!StrVal.empty()) { 1465 const SourceManager &SM = CGF.CGM.getContext().getSourceManager(); 1466 const LangOptions &LangOpts = CGF.CGM.getLangOpts(); 1467 1468 // Add the location of the start of each subsequent line of the asm to the 1469 // MDNode. 1470 for (unsigned i = 0, e = StrVal.size()-1; i != e; ++i) { 1471 if (StrVal[i] != '\n') continue; 1472 SourceLocation LineLoc = Str->getLocationOfByte(i+1, SM, LangOpts, 1473 CGF.getTarget()); 1474 Locs.push_back(llvm::ConstantInt::get(CGF.Int32Ty, 1475 LineLoc.getRawEncoding())); 1476 } 1477 } 1478 1479 return llvm::MDNode::get(CGF.getLLVMContext(), Locs); 1480} 1481 1482void CodeGenFunction::EmitAsmStmt(const AsmStmt &S) { 1483 // Assemble the final asm string. 1484 std::string AsmString = S.generateAsmString(getContext()); 1485 1486 // Get all the output and input constraints together. 1487 SmallVector<TargetInfo::ConstraintInfo, 4> OutputConstraintInfos; 1488 SmallVector<TargetInfo::ConstraintInfo, 4> InputConstraintInfos; 1489 1490 for (unsigned i = 0, e = S.getNumOutputs(); i != e; i++) { 1491 StringRef Name; 1492 if (const GCCAsmStmt *GAS = dyn_cast<GCCAsmStmt>(&S)) 1493 Name = GAS->getOutputName(i); 1494 TargetInfo::ConstraintInfo Info(S.getOutputConstraint(i), Name); 1495 bool IsValid = getTarget().validateOutputConstraint(Info); (void)IsValid; 1496 assert(IsValid && "Failed to parse output constraint"); 1497 OutputConstraintInfos.push_back(Info); 1498 } 1499 1500 for (unsigned i = 0, e = S.getNumInputs(); i != e; i++) { 1501 StringRef Name; 1502 if (const GCCAsmStmt *GAS = dyn_cast<GCCAsmStmt>(&S)) 1503 Name = GAS->getInputName(i); 1504 TargetInfo::ConstraintInfo Info(S.getInputConstraint(i), Name); 1505 bool IsValid = 1506 getTarget().validateInputConstraint(OutputConstraintInfos.data(), 1507 S.getNumOutputs(), Info); 1508 assert(IsValid && "Failed to parse input constraint"); (void)IsValid; 1509 InputConstraintInfos.push_back(Info); 1510 } 1511 1512 std::string Constraints; 1513 1514 std::vector<LValue> ResultRegDests; 1515 std::vector<QualType> ResultRegQualTys; 1516 std::vector<llvm::Type *> ResultRegTypes; 1517 std::vector<llvm::Type *> ResultTruncRegTypes; 1518 std::vector<llvm::Type *> ArgTypes; 1519 std::vector<llvm::Value*> Args; 1520 1521 // Keep track of inout constraints. 1522 std::string InOutConstraints; 1523 std::vector<llvm::Value*> InOutArgs; 1524 std::vector<llvm::Type*> InOutArgTypes; 1525 1526 for (unsigned i = 0, e = S.getNumOutputs(); i != e; i++) { 1527 TargetInfo::ConstraintInfo &Info = OutputConstraintInfos[i]; 1528 1529 // Simplify the output constraint. 1530 std::string OutputConstraint(S.getOutputConstraint(i)); 1531 OutputConstraint = SimplifyConstraint(OutputConstraint.c_str() + 1, 1532 getTarget()); 1533 1534 const Expr *OutExpr = S.getOutputExpr(i); 1535 OutExpr = OutExpr->IgnoreParenNoopCasts(getContext()); 1536 1537 OutputConstraint = AddVariableConstraints(OutputConstraint, *OutExpr, 1538 getTarget(), CGM, S); 1539 1540 LValue Dest = EmitLValue(OutExpr); 1541 if (!Constraints.empty()) 1542 Constraints += ','; 1543 1544 // If this is a register output, then make the inline asm return it 1545 // by-value. If this is a memory result, return the value by-reference. 1546 if (!Info.allowsMemory() && hasScalarEvaluationKind(OutExpr->getType())) { 1547 Constraints += "=" + OutputConstraint; 1548 ResultRegQualTys.push_back(OutExpr->getType()); 1549 ResultRegDests.push_back(Dest); 1550 ResultRegTypes.push_back(ConvertTypeForMem(OutExpr->getType())); 1551 ResultTruncRegTypes.push_back(ResultRegTypes.back()); 1552 1553 // If this output is tied to an input, and if the input is larger, then 1554 // we need to set the actual result type of the inline asm node to be the 1555 // same as the input type. 1556 if (Info.hasMatchingInput()) { 1557 unsigned InputNo; 1558 for (InputNo = 0; InputNo != S.getNumInputs(); ++InputNo) { 1559 TargetInfo::ConstraintInfo &Input = InputConstraintInfos[InputNo]; 1560 if (Input.hasTiedOperand() && Input.getTiedOperand() == i) 1561 break; 1562 } 1563 assert(InputNo != S.getNumInputs() && "Didn't find matching input!"); 1564 1565 QualType InputTy = S.getInputExpr(InputNo)->getType(); 1566 QualType OutputType = OutExpr->getType(); 1567 1568 uint64_t InputSize = getContext().getTypeSize(InputTy); 1569 if (getContext().getTypeSize(OutputType) < InputSize) { 1570 // Form the asm to return the value as a larger integer or fp type. 1571 ResultRegTypes.back() = ConvertType(InputTy); 1572 } 1573 } 1574 if (llvm::Type* AdjTy = 1575 getTargetHooks().adjustInlineAsmType(*this, OutputConstraint, 1576 ResultRegTypes.back())) 1577 ResultRegTypes.back() = AdjTy; 1578 else { 1579 CGM.getDiags().Report(S.getAsmLoc(), 1580 diag::err_asm_invalid_type_in_input) 1581 << OutExpr->getType() << OutputConstraint; 1582 } 1583 } else { 1584 ArgTypes.push_back(Dest.getAddress()->getType()); 1585 Args.push_back(Dest.getAddress()); 1586 Constraints += "=*"; 1587 Constraints += OutputConstraint; 1588 } 1589 1590 if (Info.isReadWrite()) { 1591 InOutConstraints += ','; 1592 1593 const Expr *InputExpr = S.getOutputExpr(i); 1594 llvm::Value *Arg = EmitAsmInputLValue(Info, Dest, InputExpr->getType(), 1595 InOutConstraints, 1596 InputExpr->getExprLoc()); 1597 1598 if (llvm::Type* AdjTy = 1599 getTargetHooks().adjustInlineAsmType(*this, OutputConstraint, 1600 Arg->getType())) 1601 Arg = Builder.CreateBitCast(Arg, AdjTy); 1602 1603 if (Info.allowsRegister()) 1604 InOutConstraints += llvm::utostr(i); 1605 else 1606 InOutConstraints += OutputConstraint; 1607 1608 InOutArgTypes.push_back(Arg->getType()); 1609 InOutArgs.push_back(Arg); 1610 } 1611 } 1612 1613 unsigned NumConstraints = S.getNumOutputs() + S.getNumInputs(); 1614 1615 for (unsigned i = 0, e = S.getNumInputs(); i != e; i++) { 1616 const Expr *InputExpr = S.getInputExpr(i); 1617 1618 TargetInfo::ConstraintInfo &Info = InputConstraintInfos[i]; 1619 1620 if (!Constraints.empty()) 1621 Constraints += ','; 1622 1623 // Simplify the input constraint. 1624 std::string InputConstraint(S.getInputConstraint(i)); 1625 InputConstraint = SimplifyConstraint(InputConstraint.c_str(), getTarget(), 1626 &OutputConstraintInfos); 1627 1628 InputConstraint = 1629 AddVariableConstraints(InputConstraint, 1630 *InputExpr->IgnoreParenNoopCasts(getContext()), 1631 getTarget(), CGM, S); 1632 1633 llvm::Value *Arg = EmitAsmInput(Info, InputExpr, Constraints); 1634 1635 // If this input argument is tied to a larger output result, extend the 1636 // input to be the same size as the output. The LLVM backend wants to see 1637 // the input and output of a matching constraint be the same size. Note 1638 // that GCC does not define what the top bits are here. We use zext because 1639 // that is usually cheaper, but LLVM IR should really get an anyext someday. 1640 if (Info.hasTiedOperand()) { 1641 unsigned Output = Info.getTiedOperand(); 1642 QualType OutputType = S.getOutputExpr(Output)->getType(); 1643 QualType InputTy = InputExpr->getType(); 1644 1645 if (getContext().getTypeSize(OutputType) > 1646 getContext().getTypeSize(InputTy)) { 1647 // Use ptrtoint as appropriate so that we can do our extension. 1648 if (isa<llvm::PointerType>(Arg->getType())) 1649 Arg = Builder.CreatePtrToInt(Arg, IntPtrTy); 1650 llvm::Type *OutputTy = ConvertType(OutputType); 1651 if (isa<llvm::IntegerType>(OutputTy)) 1652 Arg = Builder.CreateZExt(Arg, OutputTy); 1653 else if (isa<llvm::PointerType>(OutputTy)) 1654 Arg = Builder.CreateZExt(Arg, IntPtrTy); 1655 else { 1656 assert(OutputTy->isFloatingPointTy() && "Unexpected output type"); 1657 Arg = Builder.CreateFPExt(Arg, OutputTy); 1658 } 1659 } 1660 } 1661 if (llvm::Type* AdjTy = 1662 getTargetHooks().adjustInlineAsmType(*this, InputConstraint, 1663 Arg->getType())) 1664 Arg = Builder.CreateBitCast(Arg, AdjTy); 1665 else 1666 CGM.getDiags().Report(S.getAsmLoc(), diag::err_asm_invalid_type_in_input) 1667 << InputExpr->getType() << InputConstraint; 1668 1669 ArgTypes.push_back(Arg->getType()); 1670 Args.push_back(Arg); 1671 Constraints += InputConstraint; 1672 } 1673 1674 // Append the "input" part of inout constraints last. 1675 for (unsigned i = 0, e = InOutArgs.size(); i != e; i++) { 1676 ArgTypes.push_back(InOutArgTypes[i]); 1677 Args.push_back(InOutArgs[i]); 1678 } 1679 Constraints += InOutConstraints; 1680 1681 // Clobbers 1682 for (unsigned i = 0, e = S.getNumClobbers(); i != e; i++) { 1683 StringRef Clobber = S.getClobber(i); 1684 1685 if (Clobber != "memory" && Clobber != "cc") 1686 Clobber = getTarget().getNormalizedGCCRegisterName(Clobber); 1687 1688 if (i != 0 || NumConstraints != 0) 1689 Constraints += ','; 1690 1691 Constraints += "~{"; 1692 Constraints += Clobber; 1693 Constraints += '}'; 1694 } 1695 1696 // Add machine specific clobbers 1697 std::string MachineClobbers = getTarget().getClobbers(); 1698 if (!MachineClobbers.empty()) { 1699 if (!Constraints.empty()) 1700 Constraints += ','; 1701 Constraints += MachineClobbers; 1702 } 1703 1704 llvm::Type *ResultType; 1705 if (ResultRegTypes.empty()) 1706 ResultType = VoidTy; 1707 else if (ResultRegTypes.size() == 1) 1708 ResultType = ResultRegTypes[0]; 1709 else 1710 ResultType = llvm::StructType::get(getLLVMContext(), ResultRegTypes); 1711 1712 llvm::FunctionType *FTy = 1713 llvm::FunctionType::get(ResultType, ArgTypes, false); 1714 1715 bool HasSideEffect = S.isVolatile() || S.getNumOutputs() == 0; 1716 llvm::InlineAsm::AsmDialect AsmDialect = isa<MSAsmStmt>(&S) ? 1717 llvm::InlineAsm::AD_Intel : llvm::InlineAsm::AD_ATT; 1718 llvm::InlineAsm *IA = 1719 llvm::InlineAsm::get(FTy, AsmString, Constraints, HasSideEffect, 1720 /* IsAlignStack */ false, AsmDialect); 1721 llvm::CallInst *Result = Builder.CreateCall(IA, Args); 1722 Result->addAttribute(llvm::AttributeSet::FunctionIndex, 1723 llvm::Attribute::NoUnwind); 1724 1725 // Slap the source location of the inline asm into a !srcloc metadata on the 1726 // call. FIXME: Handle metadata for MS-style inline asms. 1727 if (const GCCAsmStmt *gccAsmStmt = dyn_cast<GCCAsmStmt>(&S)) 1728 Result->setMetadata("srcloc", getAsmSrcLocInfo(gccAsmStmt->getAsmString(), 1729 *this)); 1730 1731 // Extract all of the register value results from the asm. 1732 std::vector<llvm::Value*> RegResults; 1733 if (ResultRegTypes.size() == 1) { 1734 RegResults.push_back(Result); 1735 } else { 1736 for (unsigned i = 0, e = ResultRegTypes.size(); i != e; ++i) { 1737 llvm::Value *Tmp = Builder.CreateExtractValue(Result, i, "asmresult"); 1738 RegResults.push_back(Tmp); 1739 } 1740 } 1741 1742 for (unsigned i = 0, e = RegResults.size(); i != e; ++i) { 1743 llvm::Value *Tmp = RegResults[i]; 1744 1745 // If the result type of the LLVM IR asm doesn't match the result type of 1746 // the expression, do the conversion. 1747 if (ResultRegTypes[i] != ResultTruncRegTypes[i]) { 1748 llvm::Type *TruncTy = ResultTruncRegTypes[i]; 1749 1750 // Truncate the integer result to the right size, note that TruncTy can be 1751 // a pointer. 1752 if (TruncTy->isFloatingPointTy()) 1753 Tmp = Builder.CreateFPTrunc(Tmp, TruncTy); 1754 else if (TruncTy->isPointerTy() && Tmp->getType()->isIntegerTy()) { 1755 uint64_t ResSize = CGM.getDataLayout().getTypeSizeInBits(TruncTy); 1756 Tmp = Builder.CreateTrunc(Tmp, 1757 llvm::IntegerType::get(getLLVMContext(), (unsigned)ResSize)); 1758 Tmp = Builder.CreateIntToPtr(Tmp, TruncTy); 1759 } else if (Tmp->getType()->isPointerTy() && TruncTy->isIntegerTy()) { 1760 uint64_t TmpSize =CGM.getDataLayout().getTypeSizeInBits(Tmp->getType()); 1761 Tmp = Builder.CreatePtrToInt(Tmp, 1762 llvm::IntegerType::get(getLLVMContext(), (unsigned)TmpSize)); 1763 Tmp = Builder.CreateTrunc(Tmp, TruncTy); 1764 } else if (TruncTy->isIntegerTy()) { 1765 Tmp = Builder.CreateTrunc(Tmp, TruncTy); 1766 } else if (TruncTy->isVectorTy()) { 1767 Tmp = Builder.CreateBitCast(Tmp, TruncTy); 1768 } 1769 } 1770 1771 EmitStoreThroughLValue(RValue::get(Tmp), ResultRegDests[i]); 1772 } 1773} 1774 1775static LValue InitCapturedStruct(CodeGenFunction &CGF, const CapturedStmt &S) { 1776 const RecordDecl *RD = S.getCapturedRecordDecl(); 1777 QualType RecordTy = CGF.getContext().getRecordType(RD); 1778 1779 // Initialize the captured struct. 1780 LValue SlotLV = CGF.MakeNaturalAlignAddrLValue( 1781 CGF.CreateMemTemp(RecordTy, "agg.captured"), RecordTy); 1782 1783 RecordDecl::field_iterator CurField = RD->field_begin(); 1784 for (CapturedStmt::capture_init_iterator I = S.capture_init_begin(), 1785 E = S.capture_init_end(); 1786 I != E; ++I, ++CurField) { 1787 LValue LV = CGF.EmitLValueForFieldInitialization(SlotLV, *CurField); 1788 CGF.EmitInitializerForField(*CurField, LV, *I, ArrayRef<VarDecl *>()); 1789 } 1790 1791 return SlotLV; 1792} 1793 1794/// Generate an outlined function for the body of a CapturedStmt, store any 1795/// captured variables into the captured struct, and call the outlined function. 1796llvm::Function * 1797CodeGenFunction::EmitCapturedStmt(const CapturedStmt &S, CapturedRegionKind K) { 1798 const CapturedDecl *CD = S.getCapturedDecl(); 1799 const RecordDecl *RD = S.getCapturedRecordDecl(); 1800 assert(CD->hasBody() && "missing CapturedDecl body"); 1801 1802 LValue CapStruct = InitCapturedStruct(*this, S); 1803 1804 // Emit the CapturedDecl 1805 CodeGenFunction CGF(CGM, true); 1806 CGF.CapturedStmtInfo = new CGCapturedStmtInfo(S, K); 1807 llvm::Function *F = CGF.GenerateCapturedStmtFunction(CD, RD, S.getLocStart()); 1808 delete CGF.CapturedStmtInfo; 1809 1810 // Emit call to the helper function. 1811 EmitCallOrInvoke(F, CapStruct.getAddress()); 1812 1813 return F; 1814} 1815 1816/// Creates the outlined function for a CapturedStmt. 1817llvm::Function * 1818CodeGenFunction::GenerateCapturedStmtFunction(const CapturedDecl *CD, 1819 const RecordDecl *RD, 1820 SourceLocation Loc) { 1821 assert(CapturedStmtInfo && 1822 "CapturedStmtInfo should be set when generating the captured function"); 1823 1824 // Build the argument list. 1825 ASTContext &Ctx = CGM.getContext(); 1826 FunctionArgList Args; 1827 Args.append(CD->param_begin(), CD->param_end()); 1828 1829 // Create the function declaration. 1830 FunctionType::ExtInfo ExtInfo; 1831 const CGFunctionInfo &FuncInfo = 1832 CGM.getTypes().arrangeFunctionDeclaration(Ctx.VoidTy, Args, ExtInfo, 1833 /*IsVariadic=*/false); 1834 llvm::FunctionType *FuncLLVMTy = CGM.getTypes().GetFunctionType(FuncInfo); 1835 1836 llvm::Function *F = 1837 llvm::Function::Create(FuncLLVMTy, llvm::GlobalValue::InternalLinkage, 1838 CapturedStmtInfo->getHelperName(), &CGM.getModule()); 1839 CGM.SetInternalFunctionAttributes(CD, F, FuncInfo); 1840 1841 // Generate the function. 1842 StartFunction(CD, Ctx.VoidTy, F, FuncInfo, Args, CD->getBody()->getLocStart()); 1843 1844 // Set the context parameter in CapturedStmtInfo. 1845 llvm::Value *DeclPtr = LocalDeclMap[CD->getContextParam()]; 1846 assert(DeclPtr && "missing context parameter for CapturedStmt"); 1847 CapturedStmtInfo->setContextValue(Builder.CreateLoad(DeclPtr)); 1848 1849 // If 'this' is captured, load it into CXXThisValue. 1850 if (CapturedStmtInfo->isCXXThisExprCaptured()) { 1851 FieldDecl *FD = CapturedStmtInfo->getThisFieldDecl(); 1852 LValue LV = MakeNaturalAlignAddrLValue(CapturedStmtInfo->getContextValue(), 1853 Ctx.getTagDeclType(RD)); 1854 LValue ThisLValue = EmitLValueForField(LV, FD); 1855 CXXThisValue = EmitLoadOfLValue(ThisLValue, Loc).getScalarVal(); 1856 } 1857 1858 CapturedStmtInfo->EmitBody(*this, CD->getBody()); 1859 FinishFunction(CD->getBodyRBrace()); 1860 1861 return F; 1862} 1863