CGStmt.cpp revision 72cac2ccce8058833f56358e3391e28a8ddeeaa4
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 "CGDebugInfo.h" 15#include "CodeGenModule.h" 16#include "CodeGenFunction.h" 17#include "clang/AST/StmtVisitor.h" 18#include "clang/Basic/TargetInfo.h" 19#include "llvm/ADT/StringExtras.h" 20#include "llvm/InlineAsm.h" 21#include "llvm/Intrinsics.h" 22#include "llvm/Target/TargetData.h" 23using namespace clang; 24using namespace CodeGen; 25 26//===----------------------------------------------------------------------===// 27// Statement Emission 28//===----------------------------------------------------------------------===// 29 30void CodeGenFunction::EmitStopPoint(const Stmt *S) { 31 if (CGDebugInfo *DI = CGM.getDebugInfo()) { 32 DI->setLocation(S->getLocStart()); 33 DI->EmitStopPoint(CurFn, Builder); 34 } 35} 36 37void CodeGenFunction::EmitStmt(const Stmt *S) { 38 assert(S && "Null statement?"); 39 40 // Check if we can handle this without bothering to generate an 41 // insert point or debug info. 42 if (EmitSimpleStmt(S)) 43 return; 44 45 // If we happen to be at an unreachable point just create a dummy 46 // basic block to hold the code. We could change parts of irgen to 47 // simply not generate this code, but this situation is rare and 48 // probably not worth the effort. 49 // FIXME: Verify previous performance/effort claim. 50 EnsureInsertPoint(); 51 52 // Generate a stoppoint if we are emitting debug info. 53 EmitStopPoint(S); 54 55 switch (S->getStmtClass()) { 56 default: 57 // Must be an expression in a stmt context. Emit the value (to get 58 // side-effects) and ignore the result. 59 if (const Expr *E = dyn_cast<Expr>(S)) { 60 if (!hasAggregateLLVMType(E->getType())) 61 EmitScalarExpr(E); 62 else if (E->getType()->isAnyComplexType()) 63 EmitComplexExpr(E); 64 else 65 EmitAggExpr(E, 0, false); 66 } else { 67 ErrorUnsupported(S, "statement"); 68 } 69 break; 70 case Stmt::IndirectGotoStmtClass: 71 EmitIndirectGotoStmt(cast<IndirectGotoStmt>(*S)); break; 72 73 case Stmt::IfStmtClass: EmitIfStmt(cast<IfStmt>(*S)); break; 74 case Stmt::WhileStmtClass: EmitWhileStmt(cast<WhileStmt>(*S)); break; 75 case Stmt::DoStmtClass: EmitDoStmt(cast<DoStmt>(*S)); break; 76 case Stmt::ForStmtClass: EmitForStmt(cast<ForStmt>(*S)); break; 77 78 case Stmt::ReturnStmtClass: EmitReturnStmt(cast<ReturnStmt>(*S)); break; 79 case Stmt::DeclStmtClass: EmitDeclStmt(cast<DeclStmt>(*S)); break; 80 81 case Stmt::SwitchStmtClass: EmitSwitchStmt(cast<SwitchStmt>(*S)); break; 82 case Stmt::AsmStmtClass: EmitAsmStmt(cast<AsmStmt>(*S)); break; 83 84 case Stmt::ObjCAtTryStmtClass: 85 EmitObjCAtTryStmt(cast<ObjCAtTryStmt>(*S)); 86 break; 87 case Stmt::ObjCAtCatchStmtClass: 88 assert(0 && "@catch statements should be handled by EmitObjCAtTryStmt"); 89 break; 90 case Stmt::ObjCAtFinallyStmtClass: 91 assert(0 && "@finally statements should be handled by EmitObjCAtTryStmt"); 92 break; 93 case Stmt::ObjCAtThrowStmtClass: 94 EmitObjCAtThrowStmt(cast<ObjCAtThrowStmt>(*S)); 95 break; 96 case Stmt::ObjCAtSynchronizedStmtClass: 97 EmitObjCAtSynchronizedStmt(cast<ObjCAtSynchronizedStmt>(*S)); 98 break; 99 case Stmt::ObjCForCollectionStmtClass: 100 EmitObjCForCollectionStmt(cast<ObjCForCollectionStmt>(*S)); 101 break; 102 } 103} 104 105bool CodeGenFunction::EmitSimpleStmt(const Stmt *S) { 106 switch (S->getStmtClass()) { 107 default: return false; 108 case Stmt::NullStmtClass: break; 109 case Stmt::CompoundStmtClass: EmitCompoundStmt(cast<CompoundStmt>(*S)); break; 110 case Stmt::LabelStmtClass: EmitLabelStmt(cast<LabelStmt>(*S)); break; 111 case Stmt::GotoStmtClass: EmitGotoStmt(cast<GotoStmt>(*S)); break; 112 case Stmt::BreakStmtClass: EmitBreakStmt(cast<BreakStmt>(*S)); break; 113 case Stmt::ContinueStmtClass: EmitContinueStmt(cast<ContinueStmt>(*S)); break; 114 case Stmt::DefaultStmtClass: EmitDefaultStmt(cast<DefaultStmt>(*S)); break; 115 case Stmt::CaseStmtClass: EmitCaseStmt(cast<CaseStmt>(*S)); break; 116 } 117 118 return true; 119} 120 121/// EmitCompoundStmt - Emit a compound statement {..} node. If GetLast is true, 122/// this captures the expression result of the last sub-statement and returns it 123/// (for use by the statement expression extension). 124RValue CodeGenFunction::EmitCompoundStmt(const CompoundStmt &S, bool GetLast, 125 llvm::Value *AggLoc, bool isAggVol) { 126 // FIXME: handle vla's etc. 127 CGDebugInfo *DI = CGM.getDebugInfo(); 128 if (DI) { 129 EnsureInsertPoint(); 130 DI->setLocation(S.getLBracLoc()); 131 DI->EmitRegionStart(CurFn, Builder); 132 } 133 134 // Push a null stack save value. 135 StackSaveValues.push_back(0); 136 137 for (CompoundStmt::const_body_iterator I = S.body_begin(), 138 E = S.body_end()-GetLast; I != E; ++I) 139 EmitStmt(*I); 140 141 if (DI) { 142 EnsureInsertPoint(); 143 DI->setLocation(S.getRBracLoc()); 144 DI->EmitRegionEnd(CurFn, Builder); 145 } 146 147 RValue RV; 148 if (!GetLast) 149 RV = RValue::get(0); 150 else { 151 // We have to special case labels here. They are statements, but when put 152 // at the end of a statement expression, they yield the value of their 153 // subexpression. Handle this by walking through all labels we encounter, 154 // emitting them before we evaluate the subexpr. 155 const Stmt *LastStmt = S.body_back(); 156 while (const LabelStmt *LS = dyn_cast<LabelStmt>(LastStmt)) { 157 EmitLabel(*LS); 158 LastStmt = LS->getSubStmt(); 159 } 160 161 EnsureInsertPoint(); 162 163 RV = EmitAnyExpr(cast<Expr>(LastStmt), AggLoc); 164 } 165 166 if (llvm::Value *V = StackSaveValues.pop_back_val()) { 167 StackDepth = V; 168 V = Builder.CreateLoad(V, "tmp"); 169 170 llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::stackrestore); 171 Builder.CreateCall(F, V); 172 } 173 174 return RV; 175} 176 177void CodeGenFunction::EmitBlock(llvm::BasicBlock *BB, bool IsFinished) { 178 // Fall out of the current block (if necessary). 179 EmitBranch(BB); 180 181 if (IsFinished && BB->use_empty()) { 182 delete BB; 183 return; 184 } 185 186 CurFn->getBasicBlockList().push_back(BB); 187 Builder.SetInsertPoint(BB); 188} 189 190void CodeGenFunction::EmitStackUpdate(const LabelStmt &S) { 191 if (StackDepthMap.find(&S) == StackDepthMap.end()) { 192 // If we can't find it, just remember the depth now, 193 // so we can validate it later. 194 // FIXME: We need to save a place to insert the adjustment, 195 // if needed, here, sa that later in EmitLabel, we can 196 // backpatch the adjustment into that place, instead of 197 // saying unsupported. 198 StackDepthMap[&S] = StackDepth; 199 return; 200 } 201 202 // Find applicable stack depth, if any... 203 llvm::Value *V = StackDepthMap[&S]; 204 // V can be 0 here, if it is, be sure to start searching from the 205 // top of the function, as we want the next save after that point. 206 for (unsigned int i = 0; i < StackSaveValues.size(); ++i) 207 if (StackSaveValues[i] == V) { 208 // The actual depth is actually in the next used slot, if any. 209 while (++i < StackSaveValues.size() 210 && (V = StackSaveValues[i]) == 0) ; 211 // If there were no other depth changes, we don't need any 212 // adjustments. 213 if (V) { 214 V = Builder.CreateLoad(V, "tmp"); 215 // and restore it. 216 llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::stackrestore); 217 Builder.CreateCall(F, V); 218 } 219 } else 220 // FIXME: Move to semq and assert here, codegen isn't the right 221 // time to be checking. 222 CGM.ErrorUnsupported(&S, "invalid goto to VLA scope that has finished"); 223} 224 225void CodeGenFunction::EmitBranch(llvm::BasicBlock *Target) { 226 // Emit a branch from the current block to the target one if this 227 // was a real block. If this was just a fall-through block after a 228 // terminator, don't emit it. 229 llvm::BasicBlock *CurBB = Builder.GetInsertBlock(); 230 231 if (!CurBB || CurBB->getTerminator()) { 232 // If there is no insert point or the previous block is already 233 // terminated, don't touch it. 234 } else { 235 // Otherwise, create a fall-through branch. 236 Builder.CreateBr(Target); 237 } 238 239 Builder.ClearInsertionPoint(); 240} 241 242void CodeGenFunction::EmitLabel(const LabelStmt &S) { 243 llvm::BasicBlock *NextBB = getBasicBlockForLabel(&S); 244 if (StackDepthMap.find(&S) == StackDepthMap.end()) { 245 // We need to remember the stack depth so that we can readjust the 246 // stack back to the right depth for this label if we want to 247 // transfer here from a different depth. 248 StackDepthMap[&S] = StackDepth; 249 } else { 250 if (StackDepthMap[&S] != StackDepth) { 251 // FIXME: Sema needs to ckeck for jumps that cross decls with 252 // initializations for C++, and all VLAs, not just the first in 253 // a block that does a stacksave. 254 // FIXME: We need to save a place to insert the adjustment 255 // when we do a EmitStackUpdate on a forward jump, and then 256 // backpatch the adjustment into that place. 257 CGM.ErrorUnsupported(&S, "forward goto inside scope with VLA"); 258 } 259 } 260 EmitBlock(NextBB); 261} 262 263 264void CodeGenFunction::EmitLabelStmt(const LabelStmt &S) { 265 EmitLabel(S); 266 EmitStmt(S.getSubStmt()); 267} 268 269void CodeGenFunction::EmitGotoStmt(const GotoStmt &S) { 270 // FIXME: Implement goto out in @try or @catch blocks. 271 if (!ObjCEHStack.empty()) { 272 CGM.ErrorUnsupported(&S, "goto inside an Obj-C exception block"); 273 return; 274 } 275 276 // If this code is reachable then emit a stop point (if generating 277 // debug info). We have to do this ourselves because we are on the 278 // "simple" statement path. 279 if (HaveInsertPoint()) 280 EmitStopPoint(&S); 281 282 // We need to adjust the stack, if the destination was (will be) at 283 // a different depth. 284 EmitStackUpdate(*S.getLabel()); 285 286 EmitBranch(getBasicBlockForLabel(S.getLabel())); 287} 288 289void CodeGenFunction::EmitIndirectGotoStmt(const IndirectGotoStmt &S) { 290 // FIXME: Implement indirect goto in @try or @catch blocks. 291 if (!ObjCEHStack.empty()) { 292 CGM.ErrorUnsupported(&S, "goto inside an Obj-C exception block"); 293 return; 294 } 295 296 // Emit initial switch which will be patched up later by 297 // EmitIndirectSwitches(). We need a default dest, so we use the 298 // current BB, but this is overwritten. 299 llvm::Value *V = Builder.CreatePtrToInt(EmitScalarExpr(S.getTarget()), 300 llvm::Type::Int32Ty, 301 "addr"); 302 llvm::SwitchInst *I = Builder.CreateSwitch(V, Builder.GetInsertBlock()); 303 IndirectSwitches.push_back(I); 304 305 // Clear the insertion point to indicate we are in unreachable code. 306 Builder.ClearInsertionPoint(); 307} 308 309void CodeGenFunction::EmitIfStmt(const IfStmt &S) { 310 // C99 6.8.4.1: The first substatement is executed if the expression compares 311 // unequal to 0. The condition must be a scalar type. 312 313 // If the condition constant folds and can be elided, try to avoid emitting 314 // the condition and the dead arm of the if/else. 315 if (int Cond = ConstantFoldsToSimpleInteger(S.getCond())) { 316 // Figure out which block (then or else) is executed. 317 const Stmt *Executed = S.getThen(), *Skipped = S.getElse(); 318 if (Cond == -1) // Condition false? 319 std::swap(Executed, Skipped); 320 321 // If the skipped block has no labels in it, just emit the executed block. 322 // This avoids emitting dead code and simplifies the CFG substantially. 323 if (!ContainsLabel(Skipped)) { 324 if (Executed) 325 EmitStmt(Executed); 326 return; 327 } 328 } 329 330 // Otherwise, the condition did not fold, or we couldn't elide it. Just emit 331 // the conditional branch. 332 llvm::BasicBlock *ThenBlock = createBasicBlock("if.then"); 333 llvm::BasicBlock *ContBlock = createBasicBlock("if.end"); 334 llvm::BasicBlock *ElseBlock = ContBlock; 335 if (S.getElse()) 336 ElseBlock = createBasicBlock("if.else"); 337 EmitBranchOnBoolExpr(S.getCond(), ThenBlock, ElseBlock); 338 339 // Emit the 'then' code. 340 EmitBlock(ThenBlock); 341 EmitStmt(S.getThen()); 342 EmitBranch(ContBlock); 343 344 // Emit the 'else' code if present. 345 if (const Stmt *Else = S.getElse()) { 346 EmitBlock(ElseBlock); 347 EmitStmt(Else); 348 EmitBranch(ContBlock); 349 } 350 351 // Emit the continuation block for code after the if. 352 EmitBlock(ContBlock, true); 353} 354 355void CodeGenFunction::EmitWhileStmt(const WhileStmt &S) { 356 // Emit the header for the loop, insert it, which will create an uncond br to 357 // it. 358 llvm::BasicBlock *LoopHeader = createBasicBlock("while.cond"); 359 EmitBlock(LoopHeader); 360 361 // Create an exit block for when the condition fails, create a block for the 362 // body of the loop. 363 llvm::BasicBlock *ExitBlock = createBasicBlock("while.end"); 364 llvm::BasicBlock *LoopBody = createBasicBlock("while.body"); 365 366 // Store the blocks to use for break and continue. 367 BreakContinuePush(ExitBlock, LoopHeader); 368 369 // Evaluate the conditional in the while header. C99 6.8.5.1: The 370 // evaluation of the controlling expression takes place before each 371 // execution of the loop body. 372 llvm::Value *BoolCondVal = EvaluateExprAsBool(S.getCond()); 373 374 // while(1) is common, avoid extra exit blocks. Be sure 375 // to correctly handle break/continue though. 376 bool EmitBoolCondBranch = true; 377 if (llvm::ConstantInt *C = dyn_cast<llvm::ConstantInt>(BoolCondVal)) 378 if (C->isOne()) 379 EmitBoolCondBranch = false; 380 381 // As long as the condition is true, go to the loop body. 382 if (EmitBoolCondBranch) 383 Builder.CreateCondBr(BoolCondVal, LoopBody, ExitBlock); 384 385 // Emit the loop body. 386 EmitBlock(LoopBody); 387 EmitStmt(S.getBody()); 388 389 BreakContinuePop(); 390 391 // Cycle to the condition. 392 EmitBranch(LoopHeader); 393 394 // Emit the exit block. 395 EmitBlock(ExitBlock, true); 396 397 // If LoopHeader is a simple forwarding block then eliminate it. 398 if (!EmitBoolCondBranch 399 && &LoopHeader->front() == LoopHeader->getTerminator()) { 400 LoopHeader->replaceAllUsesWith(LoopBody); 401 LoopHeader->getTerminator()->eraseFromParent(); 402 LoopHeader->eraseFromParent(); 403 } 404} 405 406void CodeGenFunction::EmitDoStmt(const DoStmt &S) { 407 // Emit the body for the loop, insert it, which will create an uncond br to 408 // it. 409 llvm::BasicBlock *LoopBody = createBasicBlock("do.body"); 410 llvm::BasicBlock *AfterDo = createBasicBlock("do.end"); 411 EmitBlock(LoopBody); 412 413 llvm::BasicBlock *DoCond = createBasicBlock("do.cond"); 414 415 // Store the blocks to use for break and continue. 416 BreakContinuePush(AfterDo, DoCond); 417 418 // Emit the body of the loop into the block. 419 EmitStmt(S.getBody()); 420 421 BreakContinuePop(); 422 423 EmitBlock(DoCond); 424 425 // C99 6.8.5.2: "The evaluation of the controlling expression takes place 426 // after each execution of the loop body." 427 428 // Evaluate the conditional in the while header. 429 // C99 6.8.5p2/p4: The first substatement is executed if the expression 430 // compares unequal to 0. The condition must be a scalar type. 431 llvm::Value *BoolCondVal = EvaluateExprAsBool(S.getCond()); 432 433 // "do {} while (0)" is common in macros, avoid extra blocks. Be sure 434 // to correctly handle break/continue though. 435 bool EmitBoolCondBranch = true; 436 if (llvm::ConstantInt *C = dyn_cast<llvm::ConstantInt>(BoolCondVal)) 437 if (C->isZero()) 438 EmitBoolCondBranch = false; 439 440 // As long as the condition is true, iterate the loop. 441 if (EmitBoolCondBranch) 442 Builder.CreateCondBr(BoolCondVal, LoopBody, AfterDo); 443 444 // Emit the exit block. 445 EmitBlock(AfterDo, true); 446 447 // If DoCond is a simple forwarding block then eliminate it. 448 if (!EmitBoolCondBranch && &DoCond->front() == DoCond->getTerminator()) { 449 DoCond->replaceAllUsesWith(AfterDo); 450 DoCond->getTerminator()->eraseFromParent(); 451 DoCond->eraseFromParent(); 452 } 453} 454 455void CodeGenFunction::EmitForStmt(const ForStmt &S) { 456 // FIXME: What do we do if the increment (f.e.) contains a stmt expression, 457 // which contains a continue/break? 458 459 // Evaluate the first part before the loop. 460 if (S.getInit()) 461 EmitStmt(S.getInit()); 462 463 // Start the loop with a block that tests the condition. 464 llvm::BasicBlock *CondBlock = createBasicBlock("for.cond"); 465 llvm::BasicBlock *AfterFor = createBasicBlock("for.end"); 466 467 EmitBlock(CondBlock); 468 469 // Evaluate the condition if present. If not, treat it as a non-zero-constant 470 // according to 6.8.5.3p2, aka, true. 471 if (S.getCond()) { 472 // As long as the condition is true, iterate the loop. 473 llvm::BasicBlock *ForBody = createBasicBlock("for.body"); 474 475 // C99 6.8.5p2/p4: The first substatement is executed if the expression 476 // compares unequal to 0. The condition must be a scalar type. 477 EmitBranchOnBoolExpr(S.getCond(), ForBody, AfterFor); 478 479 EmitBlock(ForBody); 480 } else { 481 // Treat it as a non-zero constant. Don't even create a new block for the 482 // body, just fall into it. 483 } 484 485 // If the for loop doesn't have an increment we can just use the 486 // condition as the continue block. 487 llvm::BasicBlock *ContinueBlock; 488 if (S.getInc()) 489 ContinueBlock = createBasicBlock("for.inc"); 490 else 491 ContinueBlock = CondBlock; 492 493 // Store the blocks to use for break and continue. 494 BreakContinuePush(AfterFor, ContinueBlock); 495 496 // If the condition is true, execute the body of the for stmt. 497 EmitStmt(S.getBody()); 498 499 BreakContinuePop(); 500 501 // If there is an increment, emit it next. 502 if (S.getInc()) { 503 EmitBlock(ContinueBlock); 504 EmitStmt(S.getInc()); 505 } 506 507 // Finally, branch back up to the condition for the next iteration. 508 EmitBranch(CondBlock); 509 510 // Emit the fall-through block. 511 EmitBlock(AfterFor, true); 512} 513 514void CodeGenFunction::EmitReturnOfRValue(RValue RV, QualType Ty) { 515 if (RV.isScalar()) { 516 Builder.CreateStore(RV.getScalarVal(), ReturnValue); 517 } else if (RV.isAggregate()) { 518 EmitAggregateCopy(ReturnValue, RV.getAggregateAddr(), Ty); 519 } else { 520 StoreComplexToAddr(RV.getComplexVal(), ReturnValue, false); 521 } 522 EmitBranch(ReturnBlock); 523} 524 525/// EmitReturnStmt - Note that due to GCC extensions, this can have an operand 526/// if the function returns void, or may be missing one if the function returns 527/// non-void. Fun stuff :). 528void CodeGenFunction::EmitReturnStmt(const ReturnStmt &S) { 529 for (unsigned i = 0; i < StackSaveValues.size(); i++) { 530 if (StackSaveValues[i]) { 531 CGM.ErrorUnsupported(&S, "return inside scope with VLA"); 532 return; 533 } 534 } 535 536 // Emit the result value, even if unused, to evalute the side effects. 537 const Expr *RV = S.getRetValue(); 538 539 // FIXME: Clean this up by using an LValue for ReturnTemp, 540 // EmitStoreThroughLValue, and EmitAnyExpr. 541 if (!ReturnValue) { 542 // Make sure not to return anything, but evaluate the expression 543 // for side effects. 544 if (RV) 545 EmitAnyExpr(RV); 546 } else if (RV == 0) { 547 // Do nothing (return value is left uninitialized) 548 } else if (!hasAggregateLLVMType(RV->getType())) { 549 Builder.CreateStore(EmitScalarExpr(RV), ReturnValue); 550 } else if (RV->getType()->isAnyComplexType()) { 551 EmitComplexExprIntoAddr(RV, ReturnValue, false); 552 } else { 553 EmitAggExpr(RV, ReturnValue, false); 554 } 555 556 if (!ObjCEHStack.empty()) { 557 for (ObjCEHStackType::reverse_iterator i = ObjCEHStack.rbegin(), 558 e = ObjCEHStack.rend(); i != e; ++i) { 559 llvm::BasicBlock *ReturnPad = createBasicBlock("return.pad"); 560 EmitJumpThroughFinally(*i, ReturnPad); 561 EmitBlock(ReturnPad); 562 } 563 } 564 565 EmitBranch(ReturnBlock); 566} 567 568void CodeGenFunction::EmitDeclStmt(const DeclStmt &S) { 569 for (DeclStmt::const_decl_iterator I = S.decl_begin(), E = S.decl_end(); 570 I != E; ++I) 571 EmitDecl(**I); 572} 573 574void CodeGenFunction::EmitBreakStmt(const BreakStmt &S) { 575 assert(!BreakContinueStack.empty() && "break stmt not in a loop or switch!"); 576 577 // FIXME: Implement break in @try or @catch blocks. 578 if (ObjCEHStack.size() != BreakContinueStack.back().EHStackSize) { 579 CGM.ErrorUnsupported(&S, "break inside an Obj-C exception block"); 580 return; 581 } 582 583 for (unsigned i = 0; i < StackSaveValues.size(); i++) { 584 if (StackSaveValues[i]) { 585 CGM.ErrorUnsupported(&S, "break inside scope with VLA"); 586 return; 587 } 588 } 589 590 // If this code is reachable then emit a stop point (if generating 591 // debug info). We have to do this ourselves because we are on the 592 // "simple" statement path. 593 if (HaveInsertPoint()) 594 EmitStopPoint(&S); 595 llvm::BasicBlock *Block = BreakContinueStack.back().BreakBlock; 596 EmitBranch(Block); 597} 598 599void CodeGenFunction::EmitContinueStmt(const ContinueStmt &S) { 600 assert(!BreakContinueStack.empty() && "continue stmt not in a loop!"); 601 602 // FIXME: Implement continue in @try or @catch blocks. 603 if (ObjCEHStack.size() != BreakContinueStack.back().EHStackSize) { 604 CGM.ErrorUnsupported(&S, "continue inside an Obj-C exception block"); 605 return; 606 } 607 608 for (unsigned i = 0; i < StackSaveValues.size(); i++) { 609 if (StackSaveValues[i]) { 610 CGM.ErrorUnsupported(&S, "continue inside scope with VLA"); 611 return; 612 } 613 } 614 615 // If this code is reachable then emit a stop point (if generating 616 // debug info). We have to do this ourselves because we are on the 617 // "simple" statement path. 618 if (HaveInsertPoint()) 619 EmitStopPoint(&S); 620 llvm::BasicBlock *Block = BreakContinueStack.back().ContinueBlock; 621 EmitBranch(Block); 622} 623 624/// EmitCaseStmtRange - If case statement range is not too big then 625/// add multiple cases to switch instruction, one for each value within 626/// the range. If range is too big then emit "if" condition check. 627void CodeGenFunction::EmitCaseStmtRange(const CaseStmt &S) { 628 assert(S.getRHS() && "Expected RHS value in CaseStmt"); 629 630 llvm::APSInt LHS = S.getLHS()->EvaluateAsInt(getContext()); 631 llvm::APSInt RHS = S.getRHS()->EvaluateAsInt(getContext()); 632 633 // Emit the code for this case. We do this first to make sure it is 634 // properly chained from our predecessor before generating the 635 // switch machinery to enter this block. 636 EmitBlock(createBasicBlock("sw.bb")); 637 llvm::BasicBlock *CaseDest = Builder.GetInsertBlock(); 638 EmitStmt(S.getSubStmt()); 639 640 // If range is empty, do nothing. 641 if (LHS.isSigned() ? RHS.slt(LHS) : RHS.ult(LHS)) 642 return; 643 644 llvm::APInt Range = RHS - LHS; 645 // FIXME: parameters such as this should not be hardcoded. 646 if (Range.ult(llvm::APInt(Range.getBitWidth(), 64))) { 647 // Range is small enough to add multiple switch instruction cases. 648 for (unsigned i = 0, e = Range.getZExtValue() + 1; i != e; ++i) { 649 SwitchInsn->addCase(llvm::ConstantInt::get(LHS), CaseDest); 650 LHS++; 651 } 652 return; 653 } 654 655 // The range is too big. Emit "if" condition into a new block, 656 // making sure to save and restore the current insertion point. 657 llvm::BasicBlock *RestoreBB = Builder.GetInsertBlock(); 658 659 // Push this test onto the chain of range checks (which terminates 660 // in the default basic block). The switch's default will be changed 661 // to the top of this chain after switch emission is complete. 662 llvm::BasicBlock *FalseDest = CaseRangeBlock; 663 CaseRangeBlock = createBasicBlock("sw.caserange"); 664 665 CurFn->getBasicBlockList().push_back(CaseRangeBlock); 666 Builder.SetInsertPoint(CaseRangeBlock); 667 668 // Emit range check. 669 llvm::Value *Diff = 670 Builder.CreateSub(SwitchInsn->getCondition(), llvm::ConstantInt::get(LHS), 671 "tmp"); 672 llvm::Value *Cond = 673 Builder.CreateICmpULE(Diff, llvm::ConstantInt::get(Range), "tmp"); 674 Builder.CreateCondBr(Cond, CaseDest, FalseDest); 675 676 // Restore the appropriate insertion point. 677 if (RestoreBB) 678 Builder.SetInsertPoint(RestoreBB); 679 else 680 Builder.ClearInsertionPoint(); 681} 682 683void CodeGenFunction::EmitCaseStmt(const CaseStmt &S) { 684 if (S.getRHS()) { 685 EmitCaseStmtRange(S); 686 return; 687 } 688 689 EmitBlock(createBasicBlock("sw.bb")); 690 llvm::BasicBlock *CaseDest = Builder.GetInsertBlock(); 691 llvm::APSInt CaseVal = S.getLHS()->EvaluateAsInt(getContext()); 692 SwitchInsn->addCase(llvm::ConstantInt::get(CaseVal), CaseDest); 693 EmitStmt(S.getSubStmt()); 694} 695 696void CodeGenFunction::EmitDefaultStmt(const DefaultStmt &S) { 697 llvm::BasicBlock *DefaultBlock = SwitchInsn->getDefaultDest(); 698 assert(DefaultBlock->empty() && 699 "EmitDefaultStmt: Default block already defined?"); 700 EmitBlock(DefaultBlock); 701 EmitStmt(S.getSubStmt()); 702} 703 704void CodeGenFunction::EmitSwitchStmt(const SwitchStmt &S) { 705 llvm::Value *CondV = EmitScalarExpr(S.getCond()); 706 707 // Handle nested switch statements. 708 llvm::SwitchInst *SavedSwitchInsn = SwitchInsn; 709 llvm::BasicBlock *SavedCRBlock = CaseRangeBlock; 710 711 // Create basic block to hold stuff that comes after switch 712 // statement. We also need to create a default block now so that 713 // explicit case ranges tests can have a place to jump to on 714 // failure. 715 llvm::BasicBlock *NextBlock = createBasicBlock("sw.epilog"); 716 llvm::BasicBlock *DefaultBlock = createBasicBlock("sw.default"); 717 SwitchInsn = Builder.CreateSwitch(CondV, DefaultBlock); 718 CaseRangeBlock = DefaultBlock; 719 720 // Clear the insertion point to indicate we are in unreachable code. 721 Builder.ClearInsertionPoint(); 722 723 // All break statements jump to NextBlock. If BreakContinueStack is non empty 724 // then reuse last ContinueBlock. 725 llvm::BasicBlock *ContinueBlock = NULL; 726 if (!BreakContinueStack.empty()) 727 ContinueBlock = BreakContinueStack.back().ContinueBlock; 728 BreakContinuePush(NextBlock, ContinueBlock); 729 730 // Emit switch body. 731 EmitStmt(S.getBody()); 732 BreakContinuePop(); 733 734 // Update the default block in case explicit case range tests have 735 // been chained on top. 736 SwitchInsn->setSuccessor(0, CaseRangeBlock); 737 738 // If a default was never emitted then reroute any jumps to it and 739 // discard. 740 if (!DefaultBlock->getParent()) { 741 DefaultBlock->replaceAllUsesWith(NextBlock); 742 delete DefaultBlock; 743 } 744 745 // Emit continuation. 746 EmitBlock(NextBlock, true); 747 748 SwitchInsn = SavedSwitchInsn; 749 CaseRangeBlock = SavedCRBlock; 750} 751 752static std::string ConvertAsmString(const AsmStmt& S, bool &Failed) 753{ 754 // FIXME: No need to create new std::string here, we could just make sure 755 // that we don't read past the end of the string data. 756 std::string str(S.getAsmString()->getStrData(), 757 S.getAsmString()->getByteLength()); 758 const char *Start = str.c_str(); 759 760 unsigned NumOperands = S.getNumOutputs() + S.getNumInputs(); 761 bool IsSimple = S.isSimple(); 762 Failed = false; 763 764 static unsigned AsmCounter = 0; 765 AsmCounter++; 766 std::string Result; 767 if (IsSimple) { 768 while (*Start) { 769 switch (*Start) { 770 default: 771 Result += *Start; 772 break; 773 case '$': 774 Result += "$$"; 775 break; 776 } 777 Start++; 778 } 779 780 return Result; 781 } 782 783 while (*Start) { 784 switch (*Start) { 785 default: 786 Result += *Start; 787 break; 788 case '$': 789 Result += "$$"; 790 break; 791 case '%': 792 // Escaped character 793 Start++; 794 if (!*Start) { 795 // FIXME: This should be caught during Sema. 796 assert(0 && "Trailing '%' in asm string."); 797 } 798 799 char EscapedChar = *Start; 800 if (EscapedChar == '%') { 801 // Escaped percentage sign. 802 Result += '%'; 803 } else if (EscapedChar == '=') { 804 // Generate an unique ID. 805 Result += llvm::utostr(AsmCounter); 806 } else if (isdigit(EscapedChar)) { 807 // %n - Assembler operand n 808 char *End; 809 unsigned long n = strtoul(Start, &End, 10); 810 if (Start == End) { 811 // FIXME: This should be caught during Sema. 812 assert(0 && "Missing operand!"); 813 } else if (n >= NumOperands) { 814 // FIXME: This should be caught during Sema. 815 assert(0 && "Operand number out of range!"); 816 } 817 818 Result += '$' + llvm::utostr(n); 819 Start = End - 1; 820 } else if (isalpha(EscapedChar)) { 821 char *End; 822 823 unsigned long n = strtoul(Start + 1, &End, 10); 824 if (Start == End) { 825 // FIXME: This should be caught during Sema. 826 assert(0 && "Missing operand!"); 827 } else if (n >= NumOperands) { 828 // FIXME: This should be caught during Sema. 829 assert(0 && "Operand number out of range!"); 830 } 831 832 Result += "${" + llvm::utostr(n) + ':' + EscapedChar + '}'; 833 Start = End - 1; 834 } else if (EscapedChar == '[') { 835 std::string SymbolicName; 836 837 Start++; 838 839 while (*Start && *Start != ']') { 840 SymbolicName += *Start; 841 842 Start++; 843 } 844 845 if (!Start) { 846 // FIXME: Should be caught by sema. 847 assert(0 && "Could not parse symbolic name"); 848 } 849 850 assert(*Start == ']' && "Error parsing symbolic name"); 851 852 int Index = -1; 853 854 // Check if this is an output operand. 855 for (unsigned i = 0; i < S.getNumOutputs(); i++) { 856 if (S.getOutputName(i) == SymbolicName) { 857 Index = i; 858 break; 859 } 860 } 861 862 if (Index == -1) { 863 for (unsigned i = 0; i < S.getNumInputs(); i++) { 864 if (S.getInputName(i) == SymbolicName) { 865 Index = S.getNumOutputs() + i; 866 } 867 } 868 } 869 870 assert(Index != -1 && "Did not find right operand!"); 871 872 Result += '$' + llvm::utostr(Index); 873 874 } else { 875 Failed = true; 876 return ""; 877 } 878 } 879 Start++; 880 } 881 882 return Result; 883} 884 885static std::string SimplifyConstraint(const char* Constraint, 886 TargetInfo &Target, 887 const std::string *OutputNamesBegin = 0, 888 const std::string *OutputNamesEnd = 0) 889{ 890 std::string Result; 891 892 while (*Constraint) { 893 switch (*Constraint) { 894 default: 895 Result += Target.convertConstraint(*Constraint); 896 break; 897 // Ignore these 898 case '*': 899 case '?': 900 case '!': 901 break; 902 case 'g': 903 Result += "imr"; 904 break; 905 case '[': { 906 assert(OutputNamesBegin && OutputNamesEnd && 907 "Must pass output names to constraints with a symbolic name"); 908 unsigned Index; 909 bool result = Target.resolveSymbolicName(Constraint, 910 OutputNamesBegin, 911 OutputNamesEnd, Index); 912 assert(result && "Could not resolve symbolic name"); result=result; 913 Result += llvm::utostr(Index); 914 break; 915 } 916 } 917 918 Constraint++; 919 } 920 921 return Result; 922} 923 924llvm::Value* CodeGenFunction::EmitAsmInput(const AsmStmt &S, 925 TargetInfo::ConstraintInfo Info, 926 const Expr *InputExpr, 927 std::string &ConstraintStr) 928{ 929 llvm::Value *Arg; 930 if ((Info & TargetInfo::CI_AllowsRegister) || 931 !(Info & TargetInfo::CI_AllowsMemory)) { 932 const llvm::Type *Ty = ConvertType(InputExpr->getType()); 933 934 if (Ty->isSingleValueType()) { 935 Arg = EmitScalarExpr(InputExpr); 936 } else { 937 LValue Dest = EmitLValue(InputExpr); 938 939 uint64_t Size = CGM.getTargetData().getTypeSizeInBits(Ty); 940 if (Size <= 64 && llvm::isPowerOf2_64(Size)) { 941 Ty = llvm::IntegerType::get(Size); 942 Ty = llvm::PointerType::getUnqual(Ty); 943 944 Arg = Builder.CreateLoad(Builder.CreateBitCast(Dest.getAddress(), Ty)); 945 } else { 946 Arg = Dest.getAddress(); 947 ConstraintStr += '*'; 948 } 949 } 950 } else { 951 LValue Dest = EmitLValue(InputExpr); 952 Arg = Dest.getAddress(); 953 ConstraintStr += '*'; 954 } 955 956 return Arg; 957} 958 959void CodeGenFunction::EmitAsmStmt(const AsmStmt &S) { 960 bool Failed; 961 std::string AsmString = 962 ConvertAsmString(S, Failed); 963 964 if (Failed) { 965 ErrorUnsupported(&S, "asm string"); 966 return; 967 } 968 969 std::string Constraints; 970 971 llvm::Value *ResultAddr = 0; 972 const llvm::Type *ResultType = llvm::Type::VoidTy; 973 974 std::vector<const llvm::Type*> ArgTypes; 975 std::vector<llvm::Value*> Args; 976 977 // Keep track of inout constraints. 978 std::string InOutConstraints; 979 std::vector<llvm::Value*> InOutArgs; 980 std::vector<const llvm::Type*> InOutArgTypes; 981 982 llvm::SmallVector<TargetInfo::ConstraintInfo, 4> OutputConstraintInfos; 983 984 for (unsigned i = 0, e = S.getNumOutputs(); i != e; i++) { 985 std::string OutputConstraint(S.getOutputConstraint(i)->getStrData(), 986 S.getOutputConstraint(i)->getByteLength()); 987 988 TargetInfo::ConstraintInfo Info; 989 bool result = Target.validateOutputConstraint(OutputConstraint.c_str(), 990 Info); 991 assert(result && "Failed to parse output constraint"); result=result; 992 993 OutputConstraintInfos.push_back(Info); 994 995 // Simplify the output constraint. 996 OutputConstraint = SimplifyConstraint(OutputConstraint.c_str() + 1, Target); 997 998 LValue Dest = EmitLValue(S.getOutputExpr(i)); 999 const llvm::Type *DestValueType = 1000 cast<llvm::PointerType>(Dest.getAddress()->getType())->getElementType(); 1001 1002 // If the first output operand is not a memory dest, we'll 1003 // make it the return value. 1004 if (i == 0 && !(Info & TargetInfo::CI_AllowsMemory) && 1005 DestValueType->isSingleValueType()) { 1006 ResultAddr = Dest.getAddress(); 1007 ResultType = DestValueType; 1008 Constraints += "=" + OutputConstraint; 1009 } else { 1010 ArgTypes.push_back(Dest.getAddress()->getType()); 1011 Args.push_back(Dest.getAddress()); 1012 if (i != 0) 1013 Constraints += ','; 1014 Constraints += "=*"; 1015 Constraints += OutputConstraint; 1016 } 1017 1018 if (Info & TargetInfo::CI_ReadWrite) { 1019 InOutConstraints += ','; 1020 1021 const Expr *InputExpr = S.getOutputExpr(i); 1022 llvm::Value *Arg = EmitAsmInput(S, Info, InputExpr, InOutConstraints); 1023 1024 if (Info & TargetInfo::CI_AllowsRegister) 1025 InOutConstraints += llvm::utostr(i); 1026 else 1027 InOutConstraints += OutputConstraint; 1028 1029 InOutArgTypes.push_back(Arg->getType()); 1030 InOutArgs.push_back(Arg); 1031 } 1032 } 1033 1034 unsigned NumConstraints = S.getNumOutputs() + S.getNumInputs(); 1035 1036 for (unsigned i = 0, e = S.getNumInputs(); i != e; i++) { 1037 const Expr *InputExpr = S.getInputExpr(i); 1038 1039 std::string InputConstraint(S.getInputConstraint(i)->getStrData(), 1040 S.getInputConstraint(i)->getByteLength()); 1041 1042 TargetInfo::ConstraintInfo Info; 1043 bool result = Target.validateInputConstraint(InputConstraint.c_str(), 1044 S.begin_output_names(), 1045 S.end_output_names(), 1046 &OutputConstraintInfos[0], 1047 Info); result=result; 1048 assert(result && "Failed to parse input constraint"); 1049 1050 if (i != 0 || S.getNumOutputs() > 0) 1051 Constraints += ','; 1052 1053 // Simplify the input constraint. 1054 InputConstraint = SimplifyConstraint(InputConstraint.c_str(), Target, 1055 S.begin_output_names(), 1056 S.end_output_names()); 1057 1058 llvm::Value *Arg = EmitAsmInput(S, Info, InputExpr, Constraints); 1059 1060 ArgTypes.push_back(Arg->getType()); 1061 Args.push_back(Arg); 1062 Constraints += InputConstraint; 1063 } 1064 1065 // Append the "input" part of inout constraints last. 1066 for (unsigned i = 0, e = InOutArgs.size(); i != e; i++) { 1067 ArgTypes.push_back(InOutArgTypes[i]); 1068 Args.push_back(InOutArgs[i]); 1069 } 1070 Constraints += InOutConstraints; 1071 1072 // Clobbers 1073 for (unsigned i = 0, e = S.getNumClobbers(); i != e; i++) { 1074 std::string Clobber(S.getClobber(i)->getStrData(), 1075 S.getClobber(i)->getByteLength()); 1076 1077 Clobber = Target.getNormalizedGCCRegisterName(Clobber.c_str()); 1078 1079 if (i != 0 || NumConstraints != 0) 1080 Constraints += ','; 1081 1082 Constraints += "~{"; 1083 Constraints += Clobber; 1084 Constraints += '}'; 1085 } 1086 1087 // Add machine specific clobbers 1088 std::string MachineClobbers = Target.getClobbers(); 1089 if (!MachineClobbers.empty()) { 1090 if (!Constraints.empty()) 1091 Constraints += ','; 1092 Constraints += MachineClobbers; 1093 } 1094 1095 const llvm::FunctionType *FTy = 1096 llvm::FunctionType::get(ResultType, ArgTypes, false); 1097 1098 llvm::InlineAsm *IA = 1099 llvm::InlineAsm::get(FTy, AsmString, Constraints, 1100 S.isVolatile() || S.getNumOutputs() == 0); 1101 llvm::Value *Result = Builder.CreateCall(IA, Args.begin(), Args.end(), ""); 1102 if (ResultAddr) // FIXME: volatility 1103 Builder.CreateStore(Result, ResultAddr); 1104} 1105