CGStmt.cpp revision 488e993a135ce700b982bf099c3d6b856301d642
15f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===--- CGStmt.cpp - Emit LLVM Code from Statements ----------------------===// 25f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 35f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// The LLVM Compiler Infrastructure 45f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 50bc735ffcfb223c0186419547abaa5c84482663eChris Lattner// This file is distributed under the University of Illinois Open Source 60bc735ffcfb223c0186419547abaa5c84482663eChris Lattner// License. See LICENSE.TXT for details. 75f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 85f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 95f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// This contains code to emit Stmt nodes as LLVM code. 115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 14e8b9f5b8ea60983c4a74cb8b63879616b914b65aSanjiv Gupta#include "CGDebugInfo.h" 15e8b9f5b8ea60983c4a74cb8b63879616b914b65aSanjiv Gupta#include "CodeGenModule.h" 165f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "CodeGenFunction.h" 17de7fb8413b13651fd85b7125d08b3c9ac2816d9dDaniel Dunbar#include "clang/AST/StmtVisitor.h" 18fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson#include "clang/Basic/TargetInfo.h" 19fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson#include "llvm/InlineAsm.h" 20fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson#include "llvm/ADT/StringExtras.h" 215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerusing namespace clang; 225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerusing namespace CodeGen; 235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 255f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// Statement Emission 265f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 275f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 285f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencervoid CodeGenFunction::EmitStmt(const Stmt *S) { 295f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer assert(S && "Null statement?"); 305f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 31e8b9f5b8ea60983c4a74cb8b63879616b914b65aSanjiv Gupta // Generate stoppoints if we are emitting debug info. 32e8b9f5b8ea60983c4a74cb8b63879616b914b65aSanjiv Gupta // Beginning of a Compound Statement (e.g. an opening '{') does not produce 33e8b9f5b8ea60983c4a74cb8b63879616b914b65aSanjiv Gupta // executable code. So do not generate a stoppoint for that. 34e8b9f5b8ea60983c4a74cb8b63879616b914b65aSanjiv Gupta CGDebugInfo *DI = CGM.getDebugInfo(); 35e8b9f5b8ea60983c4a74cb8b63879616b914b65aSanjiv Gupta if (DI && S->getStmtClass() != Stmt::CompoundStmtClass) { 36e8b9f5b8ea60983c4a74cb8b63879616b914b65aSanjiv Gupta if (S->getLocStart().isValid()) { 37e8b9f5b8ea60983c4a74cb8b63879616b914b65aSanjiv Gupta DI->setLocation(S->getLocStart()); 38e8b9f5b8ea60983c4a74cb8b63879616b914b65aSanjiv Gupta } 39e8b9f5b8ea60983c4a74cb8b63879616b914b65aSanjiv Gupta 40e8b9f5b8ea60983c4a74cb8b63879616b914b65aSanjiv Gupta DI->EmitStopPoint(CurFn, Builder); 41e8b9f5b8ea60983c4a74cb8b63879616b914b65aSanjiv Gupta } 42e8b9f5b8ea60983c4a74cb8b63879616b914b65aSanjiv Gupta 435f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (S->getStmtClass()) { 445f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: 451e4d21ea5849637c49fd4222b09c4b5dedff7765Chris Lattner // Must be an expression in a stmt context. Emit the value (to get 461e4d21ea5849637c49fd4222b09c4b5dedff7765Chris Lattner // side-effects) and ignore the result. 475f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (const Expr *E = dyn_cast<Expr>(S)) { 481e4d21ea5849637c49fd4222b09c4b5dedff7765Chris Lattner if (!hasAggregateLLVMType(E->getType())) 491e4d21ea5849637c49fd4222b09c4b5dedff7765Chris Lattner EmitScalarExpr(E); 509b2dc287177394a8f73833e2ad4f7ca8cd6f22bbChris Lattner else if (E->getType()->isAnyComplexType()) 511e4d21ea5849637c49fd4222b09c4b5dedff7765Chris Lattner EmitComplexExpr(E); 521e4d21ea5849637c49fd4222b09c4b5dedff7765Chris Lattner else 531e4d21ea5849637c49fd4222b09c4b5dedff7765Chris Lattner EmitAggExpr(E, 0, false); 545f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } else { 55488e993a135ce700b982bf099c3d6b856301d642Daniel Dunbar ErrorUnsupported(S, "statement"); 565f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 575f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 585f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Stmt::NullStmtClass: break; 595f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Stmt::CompoundStmtClass: EmitCompoundStmt(cast<CompoundStmt>(*S)); break; 605f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Stmt::LabelStmtClass: EmitLabelStmt(cast<LabelStmt>(*S)); break; 615f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Stmt::GotoStmtClass: EmitGotoStmt(cast<GotoStmt>(*S)); break; 620ffb125996336fc7602b162c0a9e392f1a93060fDaniel Dunbar case Stmt::IndirectGotoStmtClass: 630ffb125996336fc7602b162c0a9e392f1a93060fDaniel Dunbar EmitIndirectGotoStmt(cast<IndirectGotoStmt>(*S)); break; 645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Stmt::IfStmtClass: EmitIfStmt(cast<IfStmt>(*S)); break; 665f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Stmt::WhileStmtClass: EmitWhileStmt(cast<WhileStmt>(*S)); break; 675f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Stmt::DoStmtClass: EmitDoStmt(cast<DoStmt>(*S)); break; 685f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Stmt::ForStmtClass: EmitForStmt(cast<ForStmt>(*S)); break; 695f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 705f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Stmt::ReturnStmtClass: EmitReturnStmt(cast<ReturnStmt>(*S)); break; 715f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Stmt::DeclStmtClass: EmitDeclStmt(cast<DeclStmt>(*S)); break; 72da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner 73da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner case Stmt::BreakStmtClass: EmitBreakStmt(); break; 74da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner case Stmt::ContinueStmtClass: EmitContinueStmt(); break; 7551b09f2c528c8460b5465c676173324e44176d62Devang Patel case Stmt::SwitchStmtClass: EmitSwitchStmt(cast<SwitchStmt>(*S)); break; 7651b09f2c528c8460b5465c676173324e44176d62Devang Patel case Stmt::DefaultStmtClass: EmitDefaultStmt(cast<DefaultStmt>(*S)); break; 7751b09f2c528c8460b5465c676173324e44176d62Devang Patel case Stmt::CaseStmtClass: EmitCaseStmt(cast<CaseStmt>(*S)); break; 78fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson case Stmt::AsmStmtClass: EmitAsmStmt(cast<AsmStmt>(*S)); break; 795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 823379320c10001d7e1ee5d7e7142c417f797cfe82Chris Lattner/// EmitCompoundStmt - Emit a compound statement {..} node. If GetLast is true, 833379320c10001d7e1ee5d7e7142c417f797cfe82Chris Lattner/// this captures the expression result of the last sub-statement and returns it 843379320c10001d7e1ee5d7e7142c417f797cfe82Chris Lattner/// (for use by the statement expression extension). 859b65551d0b387a7597fb39356a4d8ef10046445eChris LattnerRValue CodeGenFunction::EmitCompoundStmt(const CompoundStmt &S, bool GetLast, 869b65551d0b387a7597fb39356a4d8ef10046445eChris Lattner llvm::Value *AggLoc, bool isAggVol) { 875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // FIXME: handle vla's etc. 881c6a38bcea17801e9a4738753aee845381af2b6cSanjiv Gupta CGDebugInfo *DI = CGM.getDebugInfo(); 891c6a38bcea17801e9a4738753aee845381af2b6cSanjiv Gupta if (DI) { 90345f7209692b116ca433a3196c1e3c998e0ffcdeChris Lattner if (S.getLBracLoc().isValid()) 911c6a38bcea17801e9a4738753aee845381af2b6cSanjiv Gupta DI->setLocation(S.getLBracLoc()); 921c6a38bcea17801e9a4738753aee845381af2b6cSanjiv Gupta DI->EmitRegionStart(CurFn, Builder); 931c6a38bcea17801e9a4738753aee845381af2b6cSanjiv Gupta } 941c6a38bcea17801e9a4738753aee845381af2b6cSanjiv Gupta 953379320c10001d7e1ee5d7e7142c417f797cfe82Chris Lattner for (CompoundStmt::const_body_iterator I = S.body_begin(), 963379320c10001d7e1ee5d7e7142c417f797cfe82Chris Lattner E = S.body_end()-GetLast; I != E; ++I) 975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer EmitStmt(*I); 98e8b9f5b8ea60983c4a74cb8b63879616b914b65aSanjiv Gupta 991c6a38bcea17801e9a4738753aee845381af2b6cSanjiv Gupta if (DI) { 100345f7209692b116ca433a3196c1e3c998e0ffcdeChris Lattner if (S.getRBracLoc().isValid()) 1011c6a38bcea17801e9a4738753aee845381af2b6cSanjiv Gupta DI->setLocation(S.getRBracLoc()); 1021c6a38bcea17801e9a4738753aee845381af2b6cSanjiv Gupta DI->EmitRegionEnd(CurFn, Builder); 1031c6a38bcea17801e9a4738753aee845381af2b6cSanjiv Gupta } 1041c6a38bcea17801e9a4738753aee845381af2b6cSanjiv Gupta 1053379320c10001d7e1ee5d7e7142c417f797cfe82Chris Lattner if (!GetLast) 1063379320c10001d7e1ee5d7e7142c417f797cfe82Chris Lattner return RValue::get(0); 1079b65551d0b387a7597fb39356a4d8ef10046445eChris Lattner 10891d723da7b68be5245c3ac58aa2a36d04658cfb8Chris Lattner // We have to special case labels here. They are statements, but when put at 10991d723da7b68be5245c3ac58aa2a36d04658cfb8Chris Lattner // the end of a statement expression, they yield the value of their 11091d723da7b68be5245c3ac58aa2a36d04658cfb8Chris Lattner // subexpression. Handle this by walking through all labels we encounter, 11191d723da7b68be5245c3ac58aa2a36d04658cfb8Chris Lattner // emitting them before we evaluate the subexpr. 11291d723da7b68be5245c3ac58aa2a36d04658cfb8Chris Lattner const Stmt *LastStmt = S.body_back(); 11391d723da7b68be5245c3ac58aa2a36d04658cfb8Chris Lattner while (const LabelStmt *LS = dyn_cast<LabelStmt>(LastStmt)) { 11491d723da7b68be5245c3ac58aa2a36d04658cfb8Chris Lattner EmitLabel(*LS); 11591d723da7b68be5245c3ac58aa2a36d04658cfb8Chris Lattner LastStmt = LS->getSubStmt(); 11691d723da7b68be5245c3ac58aa2a36d04658cfb8Chris Lattner } 11791d723da7b68be5245c3ac58aa2a36d04658cfb8Chris Lattner 11891d723da7b68be5245c3ac58aa2a36d04658cfb8Chris Lattner return EmitAnyExpr(cast<Expr>(LastStmt), AggLoc); 1195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 1205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencervoid CodeGenFunction::EmitBlock(llvm::BasicBlock *BB) { 1225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Emit a branch from this block to the next one if this was a real block. If 1235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // this was just a fall-through block after a terminator, don't emit it. 1245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::BasicBlock *LastBB = Builder.GetInsertBlock(); 1255f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1265f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (LastBB->getTerminator()) { 1275f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If the previous block is already terminated, don't touch it. 12816f23570999cac1fa13597386938450843003840Daniel Dunbar } else if (LastBB->empty() && isDummyBlock(LastBB)) { 1295f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If the last block was an empty placeholder, remove it now. 1305f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // TODO: cache and reuse these. 13116f23570999cac1fa13597386938450843003840Daniel Dunbar LastBB->eraseFromParent(); 1325f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } else { 1335f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Otherwise, create a fall-through branch. 1345f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Builder.CreateBr(BB); 1355f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 1365f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer CurFn->getBasicBlockList().push_back(BB); 1375f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Builder.SetInsertPoint(BB); 1385f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 1395f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 14091d723da7b68be5245c3ac58aa2a36d04658cfb8Chris Lattnervoid CodeGenFunction::EmitLabel(const LabelStmt &S) { 1415f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::BasicBlock *NextBB = getBasicBlockForLabel(&S); 1425f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer EmitBlock(NextBB); 14391d723da7b68be5245c3ac58aa2a36d04658cfb8Chris Lattner} 14491d723da7b68be5245c3ac58aa2a36d04658cfb8Chris Lattner 14591d723da7b68be5245c3ac58aa2a36d04658cfb8Chris Lattner 14691d723da7b68be5245c3ac58aa2a36d04658cfb8Chris Lattnervoid CodeGenFunction::EmitLabelStmt(const LabelStmt &S) { 14791d723da7b68be5245c3ac58aa2a36d04658cfb8Chris Lattner EmitLabel(S); 1485f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer EmitStmt(S.getSubStmt()); 1495f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 1505f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1515f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencervoid CodeGenFunction::EmitGotoStmt(const GotoStmt &S) { 1525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Builder.CreateBr(getBasicBlockForLabel(S.getLabel())); 1535f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1545f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Emit a block after the branch so that dead code after a goto has some place 1555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // to go. 156984d0b414bc76d3530b9bc55a5a55834ba76c607Gabor Greif Builder.SetInsertPoint(llvm::BasicBlock::Create("", CurFn)); 1575f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 1585f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1590ffb125996336fc7602b162c0a9e392f1a93060fDaniel Dunbarvoid CodeGenFunction::EmitIndirectGotoStmt(const IndirectGotoStmt &S) { 1600ffb125996336fc7602b162c0a9e392f1a93060fDaniel Dunbar // Emit initial switch which will be patched up later by 1610ffb125996336fc7602b162c0a9e392f1a93060fDaniel Dunbar // EmitIndirectSwitches(). We need a default dest, so we use the 1620ffb125996336fc7602b162c0a9e392f1a93060fDaniel Dunbar // current BB, but this is overwritten. 1630ffb125996336fc7602b162c0a9e392f1a93060fDaniel Dunbar llvm::Value *V = Builder.CreatePtrToInt(EmitScalarExpr(S.getTarget()), 1640ffb125996336fc7602b162c0a9e392f1a93060fDaniel Dunbar llvm::Type::Int32Ty, 1650ffb125996336fc7602b162c0a9e392f1a93060fDaniel Dunbar "addr"); 1660ffb125996336fc7602b162c0a9e392f1a93060fDaniel Dunbar llvm::SwitchInst *I = Builder.CreateSwitch(V, Builder.GetInsertBlock()); 1670ffb125996336fc7602b162c0a9e392f1a93060fDaniel Dunbar IndirectSwitches.push_back(I); 1680ffb125996336fc7602b162c0a9e392f1a93060fDaniel Dunbar 1690ffb125996336fc7602b162c0a9e392f1a93060fDaniel Dunbar // Emit a block after the branch so that dead code after a goto has some place 1700ffb125996336fc7602b162c0a9e392f1a93060fDaniel Dunbar // to go. 1710ffb125996336fc7602b162c0a9e392f1a93060fDaniel Dunbar Builder.SetInsertPoint(llvm::BasicBlock::Create("", CurFn)); 1720ffb125996336fc7602b162c0a9e392f1a93060fDaniel Dunbar} 1730ffb125996336fc7602b162c0a9e392f1a93060fDaniel Dunbar 1745f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencervoid CodeGenFunction::EmitIfStmt(const IfStmt &S) { 1750ffb125996336fc7602b162c0a9e392f1a93060fDaniel Dunbar // FIXME: It would probably be nice for us to skip emission of if 1760ffb125996336fc7602b162c0a9e392f1a93060fDaniel Dunbar // (0) code here. 1770ffb125996336fc7602b162c0a9e392f1a93060fDaniel Dunbar 1785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // C99 6.8.4.1: The first substatement is executed if the expression compares 1795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // unequal to 0. The condition must be a scalar type. 1805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::Value *BoolCondVal = EvaluateExprAsBool(S.getCond()); 1815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 182984d0b414bc76d3530b9bc55a5a55834ba76c607Gabor Greif llvm::BasicBlock *ContBlock = llvm::BasicBlock::Create("ifend"); 183984d0b414bc76d3530b9bc55a5a55834ba76c607Gabor Greif llvm::BasicBlock *ThenBlock = llvm::BasicBlock::Create("ifthen"); 1845f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::BasicBlock *ElseBlock = ContBlock; 1855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (S.getElse()) 187984d0b414bc76d3530b9bc55a5a55834ba76c607Gabor Greif ElseBlock = llvm::BasicBlock::Create("ifelse"); 1885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Insert the conditional branch. 1905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Builder.CreateCondBr(BoolCondVal, ThenBlock, ElseBlock); 1915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1925f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Emit the 'then' code. 1935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer EmitBlock(ThenBlock); 1945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer EmitStmt(S.getThen()); 195d9363c3a80168283b3da518b4e17f545a6246857Devang Patel llvm::BasicBlock *BB = Builder.GetInsertBlock(); 196d9363c3a80168283b3da518b4e17f545a6246857Devang Patel if (isDummyBlock(BB)) { 197d9363c3a80168283b3da518b4e17f545a6246857Devang Patel BB->eraseFromParent(); 198d9363c3a80168283b3da518b4e17f545a6246857Devang Patel Builder.SetInsertPoint(ThenBlock); 199345f7209692b116ca433a3196c1e3c998e0ffcdeChris Lattner } else { 200d9363c3a80168283b3da518b4e17f545a6246857Devang Patel Builder.CreateBr(ContBlock); 201345f7209692b116ca433a3196c1e3c998e0ffcdeChris Lattner } 2025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Emit the 'else' code if present. 2045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (const Stmt *Else = S.getElse()) { 2055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer EmitBlock(ElseBlock); 2065f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer EmitStmt(Else); 207d9363c3a80168283b3da518b4e17f545a6246857Devang Patel llvm::BasicBlock *BB = Builder.GetInsertBlock(); 208d9363c3a80168283b3da518b4e17f545a6246857Devang Patel if (isDummyBlock(BB)) { 209d9363c3a80168283b3da518b4e17f545a6246857Devang Patel BB->eraseFromParent(); 210d9363c3a80168283b3da518b4e17f545a6246857Devang Patel Builder.SetInsertPoint(ElseBlock); 211345f7209692b116ca433a3196c1e3c998e0ffcdeChris Lattner } else { 212d9363c3a80168283b3da518b4e17f545a6246857Devang Patel Builder.CreateBr(ContBlock); 213345f7209692b116ca433a3196c1e3c998e0ffcdeChris Lattner } 2145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 2155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2165f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Emit the continuation block for code after the if. 2175f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer EmitBlock(ContBlock); 2185f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 2195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencervoid CodeGenFunction::EmitWhileStmt(const WhileStmt &S) { 2215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Emit the header for the loop, insert it, which will create an uncond br to 2225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // it. 223984d0b414bc76d3530b9bc55a5a55834ba76c607Gabor Greif llvm::BasicBlock *LoopHeader = llvm::BasicBlock::Create("whilecond"); 2245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer EmitBlock(LoopHeader); 2255f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2265f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Evaluate the conditional in the while header. C99 6.8.5.1: The evaluation 2275f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // of the controlling expression takes place before each execution of the loop 2285f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // body. 2295f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::Value *BoolCondVal = EvaluateExprAsBool(S.getCond()); 2302c30d8fee8981ca4f20a477456dae1b722b53f1dDevang Patel 2312c30d8fee8981ca4f20a477456dae1b722b53f1dDevang Patel // while(1) is common, avoid extra exit blocks. Be sure 2325f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // to correctly handle break/continue though. 2332c30d8fee8981ca4f20a477456dae1b722b53f1dDevang Patel bool EmitBoolCondBranch = true; 2342c30d8fee8981ca4f20a477456dae1b722b53f1dDevang Patel if (llvm::ConstantInt *C = dyn_cast<llvm::ConstantInt>(BoolCondVal)) 2352c30d8fee8981ca4f20a477456dae1b722b53f1dDevang Patel if (C->isOne()) 2362c30d8fee8981ca4f20a477456dae1b722b53f1dDevang Patel EmitBoolCondBranch = false; 2375f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2385f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Create an exit block for when the condition fails, create a block for the 2395f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // body of the loop. 240984d0b414bc76d3530b9bc55a5a55834ba76c607Gabor Greif llvm::BasicBlock *ExitBlock = llvm::BasicBlock::Create("whileexit"); 241984d0b414bc76d3530b9bc55a5a55834ba76c607Gabor Greif llvm::BasicBlock *LoopBody = llvm::BasicBlock::Create("whilebody"); 2425f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2435f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // As long as the condition is true, go to the loop body. 2442c30d8fee8981ca4f20a477456dae1b722b53f1dDevang Patel if (EmitBoolCondBranch) 2452c30d8fee8981ca4f20a477456dae1b722b53f1dDevang Patel Builder.CreateCondBr(BoolCondVal, LoopBody, ExitBlock); 246da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner 247da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner // Store the blocks to use for break and continue. 248da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner BreakContinueStack.push_back(BreakContinue(ExitBlock, LoopHeader)); 2495f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2505f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Emit the loop body. 2515f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer EmitBlock(LoopBody); 2525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer EmitStmt(S.getBody()); 253da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner 254da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner BreakContinueStack.pop_back(); 2555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2565f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Cycle to the condition. 2575f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Builder.CreateBr(LoopHeader); 2585f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2595f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Emit the exit block. 2605f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer EmitBlock(ExitBlock); 2612c30d8fee8981ca4f20a477456dae1b722b53f1dDevang Patel 2622c30d8fee8981ca4f20a477456dae1b722b53f1dDevang Patel // If LoopHeader is a simple forwarding block then eliminate it. 2632c30d8fee8981ca4f20a477456dae1b722b53f1dDevang Patel if (!EmitBoolCondBranch 2642c30d8fee8981ca4f20a477456dae1b722b53f1dDevang Patel && &LoopHeader->front() == LoopHeader->getTerminator()) { 2652c30d8fee8981ca4f20a477456dae1b722b53f1dDevang Patel LoopHeader->replaceAllUsesWith(LoopBody); 2662c30d8fee8981ca4f20a477456dae1b722b53f1dDevang Patel LoopHeader->getTerminator()->eraseFromParent(); 2672c30d8fee8981ca4f20a477456dae1b722b53f1dDevang Patel LoopHeader->eraseFromParent(); 2682c30d8fee8981ca4f20a477456dae1b722b53f1dDevang Patel } 2695f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 2705f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2715f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencervoid CodeGenFunction::EmitDoStmt(const DoStmt &S) { 2725f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Emit the body for the loop, insert it, which will create an uncond br to 2735f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // it. 274984d0b414bc76d3530b9bc55a5a55834ba76c607Gabor Greif llvm::BasicBlock *LoopBody = llvm::BasicBlock::Create("dobody"); 275984d0b414bc76d3530b9bc55a5a55834ba76c607Gabor Greif llvm::BasicBlock *AfterDo = llvm::BasicBlock::Create("afterdo"); 2765f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer EmitBlock(LoopBody); 277da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner 278984d0b414bc76d3530b9bc55a5a55834ba76c607Gabor Greif llvm::BasicBlock *DoCond = llvm::BasicBlock::Create("docond"); 279da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner 280da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner // Store the blocks to use for break and continue. 281da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner BreakContinueStack.push_back(BreakContinue(AfterDo, DoCond)); 2825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2835f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Emit the body of the loop into the block. 2845f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer EmitStmt(S.getBody()); 2855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 286da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner BreakContinueStack.pop_back(); 287da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner 288da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner EmitBlock(DoCond); 289da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner 2905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // C99 6.8.5.2: "The evaluation of the controlling expression takes place 2915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // after each execution of the loop body." 2925f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Evaluate the conditional in the while header. 2945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // C99 6.8.5p2/p4: The first substatement is executed if the expression 2955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // compares unequal to 0. The condition must be a scalar type. 2965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::Value *BoolCondVal = EvaluateExprAsBool(S.getCond()); 29705f6e6bb3a3e8e604c64f04f4ba7ef0e7569cf4eDevang Patel 29805f6e6bb3a3e8e604c64f04f4ba7ef0e7569cf4eDevang Patel // "do {} while (0)" is common in macros, avoid extra blocks. Be sure 29905f6e6bb3a3e8e604c64f04f4ba7ef0e7569cf4eDevang Patel // to correctly handle break/continue though. 30005f6e6bb3a3e8e604c64f04f4ba7ef0e7569cf4eDevang Patel bool EmitBoolCondBranch = true; 30105f6e6bb3a3e8e604c64f04f4ba7ef0e7569cf4eDevang Patel if (llvm::ConstantInt *C = dyn_cast<llvm::ConstantInt>(BoolCondVal)) 30205f6e6bb3a3e8e604c64f04f4ba7ef0e7569cf4eDevang Patel if (C->isZero()) 30305f6e6bb3a3e8e604c64f04f4ba7ef0e7569cf4eDevang Patel EmitBoolCondBranch = false; 30405f6e6bb3a3e8e604c64f04f4ba7ef0e7569cf4eDevang Patel 3055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // As long as the condition is true, iterate the loop. 30605f6e6bb3a3e8e604c64f04f4ba7ef0e7569cf4eDevang Patel if (EmitBoolCondBranch) 30705f6e6bb3a3e8e604c64f04f4ba7ef0e7569cf4eDevang Patel Builder.CreateCondBr(BoolCondVal, LoopBody, AfterDo); 3085f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 3095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Emit the exit block. 3105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer EmitBlock(AfterDo); 31105f6e6bb3a3e8e604c64f04f4ba7ef0e7569cf4eDevang Patel 31205f6e6bb3a3e8e604c64f04f4ba7ef0e7569cf4eDevang Patel // If DoCond is a simple forwarding block then eliminate it. 31305f6e6bb3a3e8e604c64f04f4ba7ef0e7569cf4eDevang Patel if (!EmitBoolCondBranch && &DoCond->front() == DoCond->getTerminator()) { 31405f6e6bb3a3e8e604c64f04f4ba7ef0e7569cf4eDevang Patel DoCond->replaceAllUsesWith(AfterDo); 31505f6e6bb3a3e8e604c64f04f4ba7ef0e7569cf4eDevang Patel DoCond->getTerminator()->eraseFromParent(); 31605f6e6bb3a3e8e604c64f04f4ba7ef0e7569cf4eDevang Patel DoCond->eraseFromParent(); 31705f6e6bb3a3e8e604c64f04f4ba7ef0e7569cf4eDevang Patel } 3185f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 3195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 3205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencervoid CodeGenFunction::EmitForStmt(const ForStmt &S) { 3215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // FIXME: What do we do if the increment (f.e.) contains a stmt expression, 3225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // which contains a continue/break? 323da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner // TODO: We could keep track of whether the loop body contains any 324da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner // break/continue statements and not create unnecessary blocks (like 325da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner // "afterfor" for a condless loop) if it doesn't. 326da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner 3275f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Evaluate the first part before the loop. 3285f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (S.getInit()) 3295f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer EmitStmt(S.getInit()); 3305f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 3315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Start the loop with a block that tests the condition. 332984d0b414bc76d3530b9bc55a5a55834ba76c607Gabor Greif llvm::BasicBlock *CondBlock = llvm::BasicBlock::Create("forcond"); 333984d0b414bc76d3530b9bc55a5a55834ba76c607Gabor Greif llvm::BasicBlock *AfterFor = llvm::BasicBlock::Create("afterfor"); 334da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner 3355f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer EmitBlock(CondBlock); 3365f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 3375f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Evaluate the condition if present. If not, treat it as a non-zero-constant 3385f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // according to 6.8.5.3p2, aka, true. 3395f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (S.getCond()) { 3405f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // C99 6.8.5p2/p4: The first substatement is executed if the expression 3415f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // compares unequal to 0. The condition must be a scalar type. 3425f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::Value *BoolCondVal = EvaluateExprAsBool(S.getCond()); 3435f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 3445f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // As long as the condition is true, iterate the loop. 345984d0b414bc76d3530b9bc55a5a55834ba76c607Gabor Greif llvm::BasicBlock *ForBody = llvm::BasicBlock::Create("forbody"); 3465f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Builder.CreateCondBr(BoolCondVal, ForBody, AfterFor); 3475f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer EmitBlock(ForBody); 3485f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } else { 3495f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Treat it as a non-zero constant. Don't even create a new block for the 3505f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // body, just fall into it. 3515f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 3525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 353da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner // If the for loop doesn't have an increment we can just use the 354da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner // condition as the continue block. 355da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner llvm::BasicBlock *ContinueBlock; 356da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner if (S.getInc()) 357984d0b414bc76d3530b9bc55a5a55834ba76c607Gabor Greif ContinueBlock = llvm::BasicBlock::Create("forinc"); 358da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner else 359da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner ContinueBlock = CondBlock; 360da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner 361da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner // Store the blocks to use for break and continue. 362da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner BreakContinueStack.push_back(BreakContinue(AfterFor, ContinueBlock)); 363da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner 3645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If the condition is true, execute the body of the for stmt. 3655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer EmitStmt(S.getBody()); 366da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner 367da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner BreakContinueStack.pop_back(); 368da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner 369da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner if (S.getInc()) 370da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner EmitBlock(ContinueBlock); 3715f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 3725f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If there is an increment, emit it next. 3735f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (S.getInc()) 374883f6a7cc7dccb1d675e27121a82614d63492a8dChris Lattner EmitStmt(S.getInc()); 3755f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 3765f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Finally, branch back up to the condition for the next iteration. 3775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Builder.CreateBr(CondBlock); 3785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 379da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner // Emit the fall-through block. 380da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner EmitBlock(AfterFor); 3815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 3825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 3835f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// EmitReturnStmt - Note that due to GCC extensions, this can have an operand 3845f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// if the function returns void, or may be missing one if the function returns 3855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// non-void. Fun stuff :). 3865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencervoid CodeGenFunction::EmitReturnStmt(const ReturnStmt &S) { 3875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Emit the result value, even if unused, to evalute the side effects. 3885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer const Expr *RV = S.getRetValue(); 3894b0029d5f8742760981a3bd58004f75454090a61Chris Lattner 390144ac61f9005a0da4327d4e62a4c453923b7bc0cEli Friedman llvm::Value* RetValue = 0; 3915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (FnRetTy->isVoidType()) { 392144ac61f9005a0da4327d4e62a4c453923b7bc0cEli Friedman // Make sure not to return anything 393144ac61f9005a0da4327d4e62a4c453923b7bc0cEli Friedman if (RV) { 394144ac61f9005a0da4327d4e62a4c453923b7bc0cEli Friedman // Evaluate the expression for side effects 395144ac61f9005a0da4327d4e62a4c453923b7bc0cEli Friedman EmitAnyExpr(RV); 396144ac61f9005a0da4327d4e62a4c453923b7bc0cEli Friedman } 3975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } else if (RV == 0) { 3985f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer const llvm::Type *RetTy = CurFn->getFunctionType()->getReturnType(); 399144ac61f9005a0da4327d4e62a4c453923b7bc0cEli Friedman if (RetTy != llvm::Type::VoidTy) { 400144ac61f9005a0da4327d4e62a4c453923b7bc0cEli Friedman // Handle "return;" in a function that returns a value. 401144ac61f9005a0da4327d4e62a4c453923b7bc0cEli Friedman RetValue = llvm::UndefValue::get(RetTy); 402144ac61f9005a0da4327d4e62a4c453923b7bc0cEli Friedman } 4034b0029d5f8742760981a3bd58004f75454090a61Chris Lattner } else if (!hasAggregateLLVMType(RV->getType())) { 404144ac61f9005a0da4327d4e62a4c453923b7bc0cEli Friedman RetValue = EmitScalarExpr(RV); 4059b2dc287177394a8f73833e2ad4f7ca8cd6f22bbChris Lattner } else if (RV->getType()->isAnyComplexType()) { 406345f7209692b116ca433a3196c1e3c998e0ffcdeChris Lattner EmitComplexExprIntoAddr(RV, CurFn->arg_begin(), false); 4075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } else { 408345f7209692b116ca433a3196c1e3c998e0ffcdeChris Lattner EmitAggExpr(RV, CurFn->arg_begin(), false); 4095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 410144ac61f9005a0da4327d4e62a4c453923b7bc0cEli Friedman 411144ac61f9005a0da4327d4e62a4c453923b7bc0cEli Friedman if (RetValue) { 412144ac61f9005a0da4327d4e62a4c453923b7bc0cEli Friedman Builder.CreateRet(RetValue); 413144ac61f9005a0da4327d4e62a4c453923b7bc0cEli Friedman } else { 414144ac61f9005a0da4327d4e62a4c453923b7bc0cEli Friedman Builder.CreateRetVoid(); 415144ac61f9005a0da4327d4e62a4c453923b7bc0cEli Friedman } 4165f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 4175f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Emit a block after the branch so that dead code after a return has some 4185f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // place to go. 419984d0b414bc76d3530b9bc55a5a55834ba76c607Gabor Greif EmitBlock(llvm::BasicBlock::Create()); 4205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 4215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 4225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencervoid CodeGenFunction::EmitDeclStmt(const DeclStmt &S) { 4239474504790f11617479b8d6ef8b64e32d071f251Steve Naroff for (const ScopedDecl *Decl = S.getDecl(); Decl; 4249474504790f11617479b8d6ef8b64e32d071f251Steve Naroff Decl = Decl->getNextDeclarator()) 4255f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer EmitDecl(*Decl); 4266fa5f0943a84233b2e1ec9716eae55643225bfd4Chris Lattner} 427da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner 428da13870e99fe33934b2122f06528a5063f78ae4cChris Lattnervoid CodeGenFunction::EmitBreakStmt() { 429da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner assert(!BreakContinueStack.empty() && "break stmt not in a loop or switch!"); 430da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner 431da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner llvm::BasicBlock *Block = BreakContinueStack.back().BreakBlock; 432da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner Builder.CreateBr(Block); 433984d0b414bc76d3530b9bc55a5a55834ba76c607Gabor Greif EmitBlock(llvm::BasicBlock::Create()); 434da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner} 435da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner 436da13870e99fe33934b2122f06528a5063f78ae4cChris Lattnervoid CodeGenFunction::EmitContinueStmt() { 437da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner assert(!BreakContinueStack.empty() && "continue stmt not in a loop!"); 438da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner 439da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner llvm::BasicBlock *Block = BreakContinueStack.back().ContinueBlock; 440da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner Builder.CreateBr(Block); 441984d0b414bc76d3530b9bc55a5a55834ba76c607Gabor Greif EmitBlock(llvm::BasicBlock::Create()); 442da13870e99fe33934b2122f06528a5063f78ae4cChris Lattner} 44351b09f2c528c8460b5465c676173324e44176d62Devang Patel 444c049e4f406a7f7179eba98659044a32508e53289Devang Patel/// EmitCaseStmtRange - If case statement range is not too big then 445c049e4f406a7f7179eba98659044a32508e53289Devang Patel/// add multiple cases to switch instruction, one for each value within 446c049e4f406a7f7179eba98659044a32508e53289Devang Patel/// the range. If range is too big then emit "if" condition check. 447c049e4f406a7f7179eba98659044a32508e53289Devang Patelvoid CodeGenFunction::EmitCaseStmtRange(const CaseStmt &S) { 44816f23570999cac1fa13597386938450843003840Daniel Dunbar // XXX kill me with param - ddunbar 4494efde8d2c10b091bc9588de18c2c71dca2979e49Daniel Dunbar assert(S.getRHS() && "Expected RHS value in CaseStmt"); 450c049e4f406a7f7179eba98659044a32508e53289Devang Patel 4514efde8d2c10b091bc9588de18c2c71dca2979e49Daniel Dunbar llvm::APSInt LHS = S.getLHS()->getIntegerConstantExprValue(getContext()); 4524efde8d2c10b091bc9588de18c2c71dca2979e49Daniel Dunbar llvm::APSInt RHS = S.getRHS()->getIntegerConstantExprValue(getContext()); 4534efde8d2c10b091bc9588de18c2c71dca2979e49Daniel Dunbar 45416f23570999cac1fa13597386938450843003840Daniel Dunbar // Emit the code for this case. We do this first to make sure it is 45516f23570999cac1fa13597386938450843003840Daniel Dunbar // properly chained from our predecessor before generating the 45616f23570999cac1fa13597386938450843003840Daniel Dunbar // switch machinery to enter this block. 45716f23570999cac1fa13597386938450843003840Daniel Dunbar StartBlock("sw.bb"); 45816f23570999cac1fa13597386938450843003840Daniel Dunbar llvm::BasicBlock *CaseDest = Builder.GetInsertBlock(); 45916f23570999cac1fa13597386938450843003840Daniel Dunbar EmitStmt(S.getSubStmt()); 46016f23570999cac1fa13597386938450843003840Daniel Dunbar 4614efde8d2c10b091bc9588de18c2c71dca2979e49Daniel Dunbar // If range is empty, do nothing. 4624efde8d2c10b091bc9588de18c2c71dca2979e49Daniel Dunbar if (LHS.isSigned() ? RHS.slt(LHS) : RHS.ult(LHS)) 4634efde8d2c10b091bc9588de18c2c71dca2979e49Daniel Dunbar return; 464c049e4f406a7f7179eba98659044a32508e53289Devang Patel 465c049e4f406a7f7179eba98659044a32508e53289Devang Patel llvm::APInt Range = RHS - LHS; 46616f23570999cac1fa13597386938450843003840Daniel Dunbar // FIXME: parameters such as this should not be hardcoded. 467c049e4f406a7f7179eba98659044a32508e53289Devang Patel if (Range.ult(llvm::APInt(Range.getBitWidth(), 64))) { 468c049e4f406a7f7179eba98659044a32508e53289Devang Patel // Range is small enough to add multiple switch instruction cases. 4694efde8d2c10b091bc9588de18c2c71dca2979e49Daniel Dunbar for (unsigned i = 0, e = Range.getZExtValue() + 1; i != e; ++i) { 4702d79d0f3ac0ea77b7bdfc3dd11de8cc3ccd91b8cDevang Patel SwitchInsn->addCase(llvm::ConstantInt::get(LHS), CaseDest); 4712d79d0f3ac0ea77b7bdfc3dd11de8cc3ccd91b8cDevang Patel LHS++; 4722d79d0f3ac0ea77b7bdfc3dd11de8cc3ccd91b8cDevang Patel } 473c049e4f406a7f7179eba98659044a32508e53289Devang Patel return; 474c049e4f406a7f7179eba98659044a32508e53289Devang Patel } 475c049e4f406a7f7179eba98659044a32508e53289Devang Patel 47616f23570999cac1fa13597386938450843003840Daniel Dunbar // The range is too big. Emit "if" condition into a new block, 47716f23570999cac1fa13597386938450843003840Daniel Dunbar // making sure to save and restore the current insertion point. 47816f23570999cac1fa13597386938450843003840Daniel Dunbar llvm::BasicBlock *RestoreBB = Builder.GetInsertBlock(); 47916f23570999cac1fa13597386938450843003840Daniel Dunbar 48016f23570999cac1fa13597386938450843003840Daniel Dunbar // Push this test onto the chain of range checks (which terminates 48116f23570999cac1fa13597386938450843003840Daniel Dunbar // in the default basic block). The switch's default will be changed 48216f23570999cac1fa13597386938450843003840Daniel Dunbar // to the top of this chain after switch emission is complete. 48316f23570999cac1fa13597386938450843003840Daniel Dunbar llvm::BasicBlock *FalseDest = CaseRangeBlock; 48416f23570999cac1fa13597386938450843003840Daniel Dunbar CaseRangeBlock = llvm::BasicBlock::Create("sw.caserange"); 48516f23570999cac1fa13597386938450843003840Daniel Dunbar 48616f23570999cac1fa13597386938450843003840Daniel Dunbar CurFn->getBasicBlockList().push_back(CaseRangeBlock); 48716f23570999cac1fa13597386938450843003840Daniel Dunbar Builder.SetInsertPoint(CaseRangeBlock); 488c049e4f406a7f7179eba98659044a32508e53289Devang Patel 489c049e4f406a7f7179eba98659044a32508e53289Devang Patel // Emit range check. 490c049e4f406a7f7179eba98659044a32508e53289Devang Patel llvm::Value *Diff = 4914efde8d2c10b091bc9588de18c2c71dca2979e49Daniel Dunbar Builder.CreateSub(SwitchInsn->getCondition(), llvm::ConstantInt::get(LHS), 4924efde8d2c10b091bc9588de18c2c71dca2979e49Daniel Dunbar "tmp"); 493c049e4f406a7f7179eba98659044a32508e53289Devang Patel llvm::Value *Cond = 494c049e4f406a7f7179eba98659044a32508e53289Devang Patel Builder.CreateICmpULE(Diff, llvm::ConstantInt::get(Range), "tmp"); 495c049e4f406a7f7179eba98659044a32508e53289Devang Patel Builder.CreateCondBr(Cond, CaseDest, FalseDest); 496c049e4f406a7f7179eba98659044a32508e53289Devang Patel 49716f23570999cac1fa13597386938450843003840Daniel Dunbar // Restore the appropriate insertion point. 49816f23570999cac1fa13597386938450843003840Daniel Dunbar Builder.SetInsertPoint(RestoreBB); 499c049e4f406a7f7179eba98659044a32508e53289Devang Patel} 5002d79d0f3ac0ea77b7bdfc3dd11de8cc3ccd91b8cDevang Patel 501c049e4f406a7f7179eba98659044a32508e53289Devang Patelvoid CodeGenFunction::EmitCaseStmt(const CaseStmt &S) { 502c049e4f406a7f7179eba98659044a32508e53289Devang Patel if (S.getRHS()) { 503c049e4f406a7f7179eba98659044a32508e53289Devang Patel EmitCaseStmtRange(S); 504c049e4f406a7f7179eba98659044a32508e53289Devang Patel return; 505c049e4f406a7f7179eba98659044a32508e53289Devang Patel } 506c049e4f406a7f7179eba98659044a32508e53289Devang Patel 507c049e4f406a7f7179eba98659044a32508e53289Devang Patel StartBlock("sw.bb"); 508c049e4f406a7f7179eba98659044a32508e53289Devang Patel llvm::BasicBlock *CaseDest = Builder.GetInsertBlock(); 5094efde8d2c10b091bc9588de18c2c71dca2979e49Daniel Dunbar llvm::APSInt CaseVal = S.getLHS()->getIntegerConstantExprValue(getContext()); 5104efde8d2c10b091bc9588de18c2c71dca2979e49Daniel Dunbar SwitchInsn->addCase(llvm::ConstantInt::get(CaseVal), 5114efde8d2c10b091bc9588de18c2c71dca2979e49Daniel Dunbar CaseDest); 51251b09f2c528c8460b5465c676173324e44176d62Devang Patel EmitStmt(S.getSubStmt()); 51351b09f2c528c8460b5465c676173324e44176d62Devang Patel} 51451b09f2c528c8460b5465c676173324e44176d62Devang Patel 51551b09f2c528c8460b5465c676173324e44176d62Devang Patelvoid CodeGenFunction::EmitDefaultStmt(const DefaultStmt &S) { 51616f23570999cac1fa13597386938450843003840Daniel Dunbar llvm::BasicBlock *DefaultBlock = SwitchInsn->getDefaultDest(); 51716f23570999cac1fa13597386938450843003840Daniel Dunbar assert(DefaultBlock->empty() && "EmitDefaultStmt: Default block already defined?"); 51816f23570999cac1fa13597386938450843003840Daniel Dunbar EmitBlock(DefaultBlock); 51951b09f2c528c8460b5465c676173324e44176d62Devang Patel EmitStmt(S.getSubStmt()); 52051b09f2c528c8460b5465c676173324e44176d62Devang Patel} 52151b09f2c528c8460b5465c676173324e44176d62Devang Patel 52251b09f2c528c8460b5465c676173324e44176d62Devang Patelvoid CodeGenFunction::EmitSwitchStmt(const SwitchStmt &S) { 52351b09f2c528c8460b5465c676173324e44176d62Devang Patel llvm::Value *CondV = EmitScalarExpr(S.getCond()); 52451b09f2c528c8460b5465c676173324e44176d62Devang Patel 52551b09f2c528c8460b5465c676173324e44176d62Devang Patel // Handle nested switch statements. 52651b09f2c528c8460b5465c676173324e44176d62Devang Patel llvm::SwitchInst *SavedSwitchInsn = SwitchInsn; 527c049e4f406a7f7179eba98659044a32508e53289Devang Patel llvm::BasicBlock *SavedCRBlock = CaseRangeBlock; 52851b09f2c528c8460b5465c676173324e44176d62Devang Patel 52916f23570999cac1fa13597386938450843003840Daniel Dunbar // Create basic block to hold stuff that comes after switch 53016f23570999cac1fa13597386938450843003840Daniel Dunbar // statement. We also need to create a default block now so that 53116f23570999cac1fa13597386938450843003840Daniel Dunbar // explicit case ranges tests can have a place to jump to on 53216f23570999cac1fa13597386938450843003840Daniel Dunbar // failure. 53316f23570999cac1fa13597386938450843003840Daniel Dunbar llvm::BasicBlock *NextBlock = llvm::BasicBlock::Create("sw.epilog"); 53416f23570999cac1fa13597386938450843003840Daniel Dunbar llvm::BasicBlock *DefaultBlock = llvm::BasicBlock::Create("sw.default"); 53516f23570999cac1fa13597386938450843003840Daniel Dunbar SwitchInsn = Builder.CreateSwitch(CondV, DefaultBlock); 53616f23570999cac1fa13597386938450843003840Daniel Dunbar CaseRangeBlock = DefaultBlock; 53751b09f2c528c8460b5465c676173324e44176d62Devang Patel 538d28a80d64616b66c91d28bb4c08ca2d8c594de4eEli Friedman // Create basic block for body of switch 53916f23570999cac1fa13597386938450843003840Daniel Dunbar StartBlock("sw.body"); 540d28a80d64616b66c91d28bb4c08ca2d8c594de4eEli Friedman 541e9b8c0a38549692f1b8f688c05c35442fc620865Devang Patel // All break statements jump to NextBlock. If BreakContinueStack is non empty 542e9b8c0a38549692f1b8f688c05c35442fc620865Devang Patel // then reuse last ContinueBlock. 54351b09f2c528c8460b5465c676173324e44176d62Devang Patel llvm::BasicBlock *ContinueBlock = NULL; 54451b09f2c528c8460b5465c676173324e44176d62Devang Patel if (!BreakContinueStack.empty()) 54551b09f2c528c8460b5465c676173324e44176d62Devang Patel ContinueBlock = BreakContinueStack.back().ContinueBlock; 54651b09f2c528c8460b5465c676173324e44176d62Devang Patel BreakContinueStack.push_back(BreakContinue(NextBlock, ContinueBlock)); 54751b09f2c528c8460b5465c676173324e44176d62Devang Patel 54851b09f2c528c8460b5465c676173324e44176d62Devang Patel // Emit switch body. 54951b09f2c528c8460b5465c676173324e44176d62Devang Patel EmitStmt(S.getBody()); 55051b09f2c528c8460b5465c676173324e44176d62Devang Patel BreakContinueStack.pop_back(); 55151b09f2c528c8460b5465c676173324e44176d62Devang Patel 55216f23570999cac1fa13597386938450843003840Daniel Dunbar // Update the default block in case explicit case range tests have 55316f23570999cac1fa13597386938450843003840Daniel Dunbar // been chained on top. 55416f23570999cac1fa13597386938450843003840Daniel Dunbar SwitchInsn->setSuccessor(0, CaseRangeBlock); 555c049e4f406a7f7179eba98659044a32508e53289Devang Patel 55616f23570999cac1fa13597386938450843003840Daniel Dunbar // If a default was never emitted then reroute any jumps to it and 55716f23570999cac1fa13597386938450843003840Daniel Dunbar // discard. 55816f23570999cac1fa13597386938450843003840Daniel Dunbar if (!DefaultBlock->getParent()) { 55916f23570999cac1fa13597386938450843003840Daniel Dunbar DefaultBlock->replaceAllUsesWith(NextBlock); 56016f23570999cac1fa13597386938450843003840Daniel Dunbar delete DefaultBlock; 56116f23570999cac1fa13597386938450843003840Daniel Dunbar } 56216f23570999cac1fa13597386938450843003840Daniel Dunbar 56316f23570999cac1fa13597386938450843003840Daniel Dunbar // Emit continuation. 56416f23570999cac1fa13597386938450843003840Daniel Dunbar EmitBlock(NextBlock); 56551b09f2c528c8460b5465c676173324e44176d62Devang Patel 56651b09f2c528c8460b5465c676173324e44176d62Devang Patel SwitchInsn = SavedSwitchInsn; 567c049e4f406a7f7179eba98659044a32508e53289Devang Patel CaseRangeBlock = SavedCRBlock; 56851b09f2c528c8460b5465c676173324e44176d62Devang Patel} 569fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson 570345f7209692b116ca433a3196c1e3c998e0ffcdeChris Lattnerstatic std::string ConvertAsmString(const char *Start, unsigned NumOperands, 571345f7209692b116ca433a3196c1e3c998e0ffcdeChris Lattner bool IsSimple) { 572fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson static unsigned AsmCounter = 0; 573fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson AsmCounter++; 574fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson std::string Result; 5752abd25f29658880f53baf557d51cd1246484ab50Anders Carlsson if (IsSimple) { 5762abd25f29658880f53baf557d51cd1246484ab50Anders Carlsson while (*Start) { 5772abd25f29658880f53baf557d51cd1246484ab50Anders Carlsson switch (*Start) { 5782abd25f29658880f53baf557d51cd1246484ab50Anders Carlsson default: 5792abd25f29658880f53baf557d51cd1246484ab50Anders Carlsson Result += *Start; 5802abd25f29658880f53baf557d51cd1246484ab50Anders Carlsson break; 5812abd25f29658880f53baf557d51cd1246484ab50Anders Carlsson case '$': 5822abd25f29658880f53baf557d51cd1246484ab50Anders Carlsson Result += "$$"; 5832abd25f29658880f53baf557d51cd1246484ab50Anders Carlsson break; 5842abd25f29658880f53baf557d51cd1246484ab50Anders Carlsson } 5852abd25f29658880f53baf557d51cd1246484ab50Anders Carlsson Start++; 5862abd25f29658880f53baf557d51cd1246484ab50Anders Carlsson } 5872abd25f29658880f53baf557d51cd1246484ab50Anders Carlsson 5882abd25f29658880f53baf557d51cd1246484ab50Anders Carlsson return Result; 5892abd25f29658880f53baf557d51cd1246484ab50Anders Carlsson } 590fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson 591fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson while (*Start) { 592fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson switch (*Start) { 593fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson default: 594fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson Result += *Start; 595fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson break; 596fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson case '$': 597fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson Result += "$$"; 598fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson break; 599fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson case '%': 600fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson // Escaped character 601fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson Start++; 602fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson if (!*Start) { 603fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson // FIXME: This should be caught during Sema. 604fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson assert(0 && "Trailing '%' in asm string."); 605fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson } 606fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson 607fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson char EscapedChar = *Start; 608fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson if (EscapedChar == '%') { 609fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson // Escaped percentage sign. 610fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson Result += '%'; 611345f7209692b116ca433a3196c1e3c998e0ffcdeChris Lattner } else if (EscapedChar == '=') { 612fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson // Generate an unique ID. 613fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson Result += llvm::utostr(AsmCounter); 614fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson } else if (isdigit(EscapedChar)) { 615fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson // %n - Assembler operand n 616fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson char *End; 617fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson unsigned long n = strtoul(Start, &End, 10); 618fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson if (Start == End) { 619fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson // FIXME: This should be caught during Sema. 620fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson assert(0 && "Missing operand!"); 621fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson } else if (n >= NumOperands) { 622fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson // FIXME: This should be caught during Sema. 623fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson assert(0 && "Operand number out of range!"); 624fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson } 625fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson 626fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson Result += '$' + llvm::utostr(n); 6277695f70bbd3e4d42adaa1ef2ff5e1b9ab3d9c345Lauro Ramos Venancio Start = End - 1; 6282abd25f29658880f53baf557d51cd1246484ab50Anders Carlsson } else if (isalpha(EscapedChar)) { 6292abd25f29658880f53baf557d51cd1246484ab50Anders Carlsson char *End; 6302abd25f29658880f53baf557d51cd1246484ab50Anders Carlsson 6312abd25f29658880f53baf557d51cd1246484ab50Anders Carlsson unsigned long n = strtoul(Start + 1, &End, 10); 6322abd25f29658880f53baf557d51cd1246484ab50Anders Carlsson if (Start == End) { 6332abd25f29658880f53baf557d51cd1246484ab50Anders Carlsson // FIXME: This should be caught during Sema. 6342abd25f29658880f53baf557d51cd1246484ab50Anders Carlsson assert(0 && "Missing operand!"); 6352abd25f29658880f53baf557d51cd1246484ab50Anders Carlsson } else if (n >= NumOperands) { 6362abd25f29658880f53baf557d51cd1246484ab50Anders Carlsson // FIXME: This should be caught during Sema. 6372abd25f29658880f53baf557d51cd1246484ab50Anders Carlsson assert(0 && "Operand number out of range!"); 6382abd25f29658880f53baf557d51cd1246484ab50Anders Carlsson } 6392abd25f29658880f53baf557d51cd1246484ab50Anders Carlsson 6402abd25f29658880f53baf557d51cd1246484ab50Anders Carlsson Result += "${" + llvm::utostr(n) + ':' + EscapedChar + '}'; 6417695f70bbd3e4d42adaa1ef2ff5e1b9ab3d9c345Lauro Ramos Venancio Start = End - 1; 642fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson } else { 643fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson assert(0 && "Unhandled asm escaped character!"); 644fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson } 645fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson } 646fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson Start++; 647fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson } 648fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson 649fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson return Result; 650fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson} 651fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson 652a5694b8b0096215137bf1c273764ec93ac4898fdLauro Ramos Venanciostatic std::string SimplifyConstraint(const char* Constraint, 653a5694b8b0096215137bf1c273764ec93ac4898fdLauro Ramos Venancio TargetInfo &Target) { 654fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson std::string Result; 655fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson 656fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson while (*Constraint) { 657fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson switch (*Constraint) { 658fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson default: 659a5694b8b0096215137bf1c273764ec93ac4898fdLauro Ramos Venancio Result += Target.convertConstraint(*Constraint); 660fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson break; 661fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson // Ignore these 662fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson case '*': 663fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson case '?': 664fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson case '!': 665fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson break; 666fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson case 'g': 667fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson Result += "imr"; 668fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson break; 669fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson } 670fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson 671fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson Constraint++; 672fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson } 673fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson 674fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson return Result; 675fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson} 676fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson 677fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlssonvoid CodeGenFunction::EmitAsmStmt(const AsmStmt &S) { 678fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson std::string AsmString = 679fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson ConvertAsmString(std::string(S.getAsmString()->getStrData(), 680fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson S.getAsmString()->getByteLength()).c_str(), 6812abd25f29658880f53baf557d51cd1246484ab50Anders Carlsson S.getNumOutputs() + S.getNumInputs(), S.isSimple()); 682fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson 683fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson std::string Constraints; 684fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson 685fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson llvm::Value *ResultAddr = 0; 686fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson const llvm::Type *ResultType = llvm::Type::VoidTy; 687fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson 688fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson std::vector<const llvm::Type*> ArgTypes; 689fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson std::vector<llvm::Value*> Args; 690f39a4211bdea6c136562a5225e5a84d54e62dc8fAnders Carlsson 691f39a4211bdea6c136562a5225e5a84d54e62dc8fAnders Carlsson // Keep track of inout constraints. 692f39a4211bdea6c136562a5225e5a84d54e62dc8fAnders Carlsson std::string InOutConstraints; 693f39a4211bdea6c136562a5225e5a84d54e62dc8fAnders Carlsson std::vector<llvm::Value*> InOutArgs; 694f39a4211bdea6c136562a5225e5a84d54e62dc8fAnders Carlsson std::vector<const llvm::Type*> InOutArgTypes; 695fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson 696fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson for (unsigned i = 0, e = S.getNumOutputs(); i != e; i++) { 697fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson std::string OutputConstraint(S.getOutputConstraint(i)->getStrData(), 698fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson S.getOutputConstraint(i)->getByteLength()); 699fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson 700fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson TargetInfo::ConstraintInfo Info; 701fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson bool result = Target.validateOutputConstraint(OutputConstraint.c_str(), 702fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson Info); 703fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson assert(result && "Failed to parse output constraint"); 704fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson 705fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson // Simplify the output constraint. 706a5694b8b0096215137bf1c273764ec93ac4898fdLauro Ramos Venancio OutputConstraint = SimplifyConstraint(OutputConstraint.c_str() + 1, Target); 707fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson 708fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson LValue Dest = EmitLValue(S.getOutputExpr(i)); 709fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson const llvm::Type *DestValueType = 710fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson cast<llvm::PointerType>(Dest.getAddress()->getType())->getElementType(); 711fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson 712fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson // If the first output operand is not a memory dest, we'll 713fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson // make it the return value. 714fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson if (i == 0 && !(Info & TargetInfo::CI_AllowsMemory) && 715d79a726dc3c8af61b486948c97a183c7fe5b0179Dan Gohman DestValueType->isSingleValueType()) { 716fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson ResultAddr = Dest.getAddress(); 717fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson ResultType = DestValueType; 718fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson Constraints += "=" + OutputConstraint; 719fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson } else { 720fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson ArgTypes.push_back(Dest.getAddress()->getType()); 721cad3ab611ebd3bee3ce6395d649640047f904cdeAnders Carlsson Args.push_back(Dest.getAddress()); 722fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson if (i != 0) 723fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson Constraints += ','; 724f39a4211bdea6c136562a5225e5a84d54e62dc8fAnders Carlsson Constraints += "=*"; 725fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson Constraints += OutputConstraint; 726f39a4211bdea6c136562a5225e5a84d54e62dc8fAnders Carlsson } 727f39a4211bdea6c136562a5225e5a84d54e62dc8fAnders Carlsson 728f39a4211bdea6c136562a5225e5a84d54e62dc8fAnders Carlsson if (Info & TargetInfo::CI_ReadWrite) { 729f39a4211bdea6c136562a5225e5a84d54e62dc8fAnders Carlsson // FIXME: This code should be shared with the code that handles inputs. 730f39a4211bdea6c136562a5225e5a84d54e62dc8fAnders Carlsson InOutConstraints += ','; 731f39a4211bdea6c136562a5225e5a84d54e62dc8fAnders Carlsson 732f39a4211bdea6c136562a5225e5a84d54e62dc8fAnders Carlsson const Expr *InputExpr = S.getOutputExpr(i); 733f39a4211bdea6c136562a5225e5a84d54e62dc8fAnders Carlsson llvm::Value *Arg; 734f39a4211bdea6c136562a5225e5a84d54e62dc8fAnders Carlsson if ((Info & TargetInfo::CI_AllowsRegister) || 735f39a4211bdea6c136562a5225e5a84d54e62dc8fAnders Carlsson !(Info & TargetInfo::CI_AllowsMemory)) { 736d79a726dc3c8af61b486948c97a183c7fe5b0179Dan Gohman if (ConvertType(InputExpr->getType())->isSingleValueType()) { 737f39a4211bdea6c136562a5225e5a84d54e62dc8fAnders Carlsson Arg = EmitScalarExpr(InputExpr); 738f39a4211bdea6c136562a5225e5a84d54e62dc8fAnders Carlsson } else { 739d79a726dc3c8af61b486948c97a183c7fe5b0179Dan Gohman assert(0 && "FIXME: Implement passing multiple-value types as inputs"); 740f39a4211bdea6c136562a5225e5a84d54e62dc8fAnders Carlsson } 741f39a4211bdea6c136562a5225e5a84d54e62dc8fAnders Carlsson } else { 742f39a4211bdea6c136562a5225e5a84d54e62dc8fAnders Carlsson LValue Dest = EmitLValue(InputExpr); 743f39a4211bdea6c136562a5225e5a84d54e62dc8fAnders Carlsson Arg = Dest.getAddress(); 744f39a4211bdea6c136562a5225e5a84d54e62dc8fAnders Carlsson InOutConstraints += '*'; 745f39a4211bdea6c136562a5225e5a84d54e62dc8fAnders Carlsson } 746f39a4211bdea6c136562a5225e5a84d54e62dc8fAnders Carlsson 747f39a4211bdea6c136562a5225e5a84d54e62dc8fAnders Carlsson InOutArgTypes.push_back(Arg->getType()); 748f39a4211bdea6c136562a5225e5a84d54e62dc8fAnders Carlsson InOutArgs.push_back(Arg); 749f39a4211bdea6c136562a5225e5a84d54e62dc8fAnders Carlsson InOutConstraints += OutputConstraint; 750f39a4211bdea6c136562a5225e5a84d54e62dc8fAnders Carlsson } 751fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson } 752fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson 753fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson unsigned NumConstraints = S.getNumOutputs() + S.getNumInputs(); 754fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson 755fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson for (unsigned i = 0, e = S.getNumInputs(); i != e; i++) { 756fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson const Expr *InputExpr = S.getInputExpr(i); 757fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson 758fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson std::string InputConstraint(S.getInputConstraint(i)->getStrData(), 759fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson S.getInputConstraint(i)->getByteLength()); 760fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson 761fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson TargetInfo::ConstraintInfo Info; 762fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson bool result = Target.validateInputConstraint(InputConstraint.c_str(), 763fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson NumConstraints, 764fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson Info); 765fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson assert(result && "Failed to parse input constraint"); 766fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson 767fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson if (i != 0 || S.getNumOutputs() > 0) 768fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson Constraints += ','; 769fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson 770fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson // Simplify the input constraint. 771a5694b8b0096215137bf1c273764ec93ac4898fdLauro Ramos Venancio InputConstraint = SimplifyConstraint(InputConstraint.c_str(), Target); 772fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson 773fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson llvm::Value *Arg; 774fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson 775fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson if ((Info & TargetInfo::CI_AllowsRegister) || 776fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson !(Info & TargetInfo::CI_AllowsMemory)) { 777d79a726dc3c8af61b486948c97a183c7fe5b0179Dan Gohman if (ConvertType(InputExpr->getType())->isSingleValueType()) { 778fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson Arg = EmitScalarExpr(InputExpr); 779fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson } else { 780d79a726dc3c8af61b486948c97a183c7fe5b0179Dan Gohman assert(0 && "FIXME: Implement passing multiple-value types as inputs"); 781fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson } 782fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson } else { 783fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson LValue Dest = EmitLValue(InputExpr); 784fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson Arg = Dest.getAddress(); 785fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson Constraints += '*'; 786fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson } 787fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson 788fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson ArgTypes.push_back(Arg->getType()); 789fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson Args.push_back(Arg); 790fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson Constraints += InputConstraint; 791fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson } 792fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson 793f39a4211bdea6c136562a5225e5a84d54e62dc8fAnders Carlsson // Append the "input" part of inout constraints last. 794f39a4211bdea6c136562a5225e5a84d54e62dc8fAnders Carlsson for (unsigned i = 0, e = InOutArgs.size(); i != e; i++) { 795f39a4211bdea6c136562a5225e5a84d54e62dc8fAnders Carlsson ArgTypes.push_back(InOutArgTypes[i]); 796f39a4211bdea6c136562a5225e5a84d54e62dc8fAnders Carlsson Args.push_back(InOutArgs[i]); 797f39a4211bdea6c136562a5225e5a84d54e62dc8fAnders Carlsson } 798f39a4211bdea6c136562a5225e5a84d54e62dc8fAnders Carlsson Constraints += InOutConstraints; 799f39a4211bdea6c136562a5225e5a84d54e62dc8fAnders Carlsson 800fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson // Clobbers 801fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson for (unsigned i = 0, e = S.getNumClobbers(); i != e; i++) { 802fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson std::string Clobber(S.getClobber(i)->getStrData(), 803fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson S.getClobber(i)->getByteLength()); 804fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson 805fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson Clobber = Target.getNormalizedGCCRegisterName(Clobber.c_str()); 806fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson 807ea041758d49215167e473a515b8d46e77b170ccfAnders Carlsson if (i != 0 || NumConstraints != 0) 808fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson Constraints += ','; 809ea041758d49215167e473a515b8d46e77b170ccfAnders Carlsson 810ea041758d49215167e473a515b8d46e77b170ccfAnders Carlsson Constraints += "~{"; 811fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson Constraints += Clobber; 812ea041758d49215167e473a515b8d46e77b170ccfAnders Carlsson Constraints += '}'; 813fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson } 814fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson 815fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson // Add machine specific clobbers 816fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson if (const char *C = Target.getClobbers()) { 817fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson if (!Constraints.empty()) 818fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson Constraints += ','; 819fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson Constraints += C; 820fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson } 821f39a4211bdea6c136562a5225e5a84d54e62dc8fAnders Carlsson 822fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson const llvm::FunctionType *FTy = 823fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson llvm::FunctionType::get(ResultType, ArgTypes, false); 824fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson 825fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson llvm::InlineAsm *IA = 826fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson llvm::InlineAsm::get(FTy, AsmString, Constraints, 827fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson S.isVolatile() || S.getNumOutputs() == 0); 828fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson llvm::Value *Result = Builder.CreateCall(IA, Args.begin(), Args.end(), ""); 8291e692ace08959399794363e77499b73da5494af9Eli Friedman if (ResultAddr) // FIXME: volatility 830fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson Builder.CreateStore(Result, ResultAddr); 831fb1aeb804c08d5288a923fb278161783e6abdc66Anders Carlsson} 832