CGStmt.cpp revision 64d5d6c5903157c521af496479d06dc26032d718 
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/InlineAsm.h"
20#include "llvm/ADT/StringExtras.h"
21using namespace clang;
22using namespace CodeGen;
23
24//===----------------------------------------------------------------------===//
25//                              Statement Emission
26//===----------------------------------------------------------------------===//
27
28void CodeGenFunction::EmitStmt(const Stmt *S) {
29  assert(S && "Null statement?");
30
31  // Generate stoppoints if we are emitting debug info.
32  // Beginning of a Compound Statement (e.g. an opening '{') does not produce
33  // executable code. So do not generate a stoppoint for that.
34  CGDebugInfo *DI = CGM.getDebugInfo();
35  if (DI && S->getStmtClass() != Stmt::CompoundStmtClass) {
36    if (S->getLocStart().isValid()) {
37        DI->setLocation(S->getLocStart());
38    }
39
40    DI->EmitStopPoint(CurFn, Builder);
41  }
42
43  switch (S->getStmtClass()) {
44  default:
45    // Must be an expression in a stmt context.  Emit the value (to get
46    // side-effects) and ignore the result.
47    if (const Expr *E = dyn_cast<Expr>(S)) {
48      if (!hasAggregateLLVMType(E->getType()))
49        EmitScalarExpr(E);
50      else if (E->getType()->isAnyComplexType())
51        EmitComplexExpr(E);
52      else
53        EmitAggExpr(E, 0, false);
54    } else {
55      ErrorUnsupported(S, "statement");
56    }
57    break;
58  case Stmt::NullStmtClass: break;
59  case Stmt::CompoundStmtClass: EmitCompoundStmt(cast<CompoundStmt>(*S)); break;
60  case Stmt::LabelStmtClass:    EmitLabelStmt(cast<LabelStmt>(*S));       break;
61  case Stmt::GotoStmtClass:     EmitGotoStmt(cast<GotoStmt>(*S));         break;
62  case Stmt::IndirectGotoStmtClass:
63    EmitIndirectGotoStmt(cast<IndirectGotoStmt>(*S)); break;
64
65  case Stmt::IfStmtClass:       EmitIfStmt(cast<IfStmt>(*S));             break;
66  case Stmt::WhileStmtClass:    EmitWhileStmt(cast<WhileStmt>(*S));       break;
67  case Stmt::DoStmtClass:       EmitDoStmt(cast<DoStmt>(*S));             break;
68  case Stmt::ForStmtClass:      EmitForStmt(cast<ForStmt>(*S));           break;
69
70  case Stmt::ReturnStmtClass:   EmitReturnStmt(cast<ReturnStmt>(*S));     break;
71  case Stmt::DeclStmtClass:     EmitDeclStmt(cast<DeclStmt>(*S));         break;
72
73  case Stmt::BreakStmtClass:    EmitBreakStmt();                          break;
74  case Stmt::ContinueStmtClass: EmitContinueStmt();                       break;
75  case Stmt::SwitchStmtClass:   EmitSwitchStmt(cast<SwitchStmt>(*S));     break;
76  case Stmt::DefaultStmtClass:  EmitDefaultStmt(cast<DefaultStmt>(*S));   break;
77  case Stmt::CaseStmtClass:     EmitCaseStmt(cast<CaseStmt>(*S));         break;
78  case Stmt::AsmStmtClass:      EmitAsmStmt(cast<AsmStmt>(*S));           break;
79
80  case Stmt::ObjCAtTryStmtClass:
81    EmitObjCAtTryStmt(cast<ObjCAtTryStmt>(*S));
82    break;
83  case Stmt::ObjCAtCatchStmtClass:
84    assert(0 && "@catch statements should be handled by EmitObjCAtTryStmt");
85    break;
86  case Stmt::ObjCAtFinallyStmtClass:
87    assert(0 && "@finally statements should be handled by EmitObjCAtTryStmt");
88    break;
89  case Stmt::ObjCAtThrowStmtClass:
90    EmitObjCAtThrowStmt(cast<ObjCAtThrowStmt>(*S));
91    break;
92  case Stmt::ObjCAtSynchronizedStmtClass:
93    ErrorUnsupported(S, "@synchronized statement");
94    break;
95  case Stmt::ObjCForCollectionStmtClass:
96    EmitObjCForCollectionStmt(cast<ObjCForCollectionStmt>(*S));
97    break;
98  }
99}
100
101/// EmitCompoundStmt - Emit a compound statement {..} node.  If GetLast is true,
102/// this captures the expression result of the last sub-statement and returns it
103/// (for use by the statement expression extension).
104RValue CodeGenFunction::EmitCompoundStmt(const CompoundStmt &S, bool GetLast,
105                                         llvm::Value *AggLoc, bool isAggVol) {
106  // FIXME: handle vla's etc.
107  CGDebugInfo *DI = CGM.getDebugInfo();
108  if (DI) {
109    if (S.getLBracLoc().isValid())
110      DI->setLocation(S.getLBracLoc());
111    DI->EmitRegionStart(CurFn, Builder);
112  }
113
114  for (CompoundStmt::const_body_iterator I = S.body_begin(),
115       E = S.body_end()-GetLast; I != E; ++I)
116    EmitStmt(*I);
117
118  if (DI) {
119    if (S.getRBracLoc().isValid())
120      DI->setLocation(S.getRBracLoc());
121    DI->EmitRegionEnd(CurFn, Builder);
122  }
123
124  if (!GetLast)
125    return RValue::get(0);
126
127  // We have to special case labels here.  They are statements, but when put at
128  // the end of a statement expression, they yield the value of their
129  // subexpression.  Handle this by walking through all labels we encounter,
130  // emitting them before we evaluate the subexpr.
131  const Stmt *LastStmt = S.body_back();
132  while (const LabelStmt *LS = dyn_cast<LabelStmt>(LastStmt)) {
133    EmitLabel(*LS);
134    LastStmt = LS->getSubStmt();
135  }
136
137  return EmitAnyExpr(cast<Expr>(LastStmt), AggLoc);
138}
139
140void CodeGenFunction::EmitBlock(llvm::BasicBlock *BB) {
141  // Emit a branch from this block to the next one if this was a real block.  If
142  // this was just a fall-through block after a terminator, don't emit it.
143  llvm::BasicBlock *LastBB = Builder.GetInsertBlock();
144
145  if (LastBB->getTerminator()) {
146    // If the previous block is already terminated, don't touch it.
147  } else if (LastBB->empty() && isDummyBlock(LastBB)) {
148    // If the last block was an empty placeholder, remove it now.
149    // TODO: cache and reuse these.
150    LastBB->eraseFromParent();
151  } else {
152    // Otherwise, create a fall-through branch.
153    Builder.CreateBr(BB);
154  }
155  CurFn->getBasicBlockList().push_back(BB);
156  Builder.SetInsertPoint(BB);
157}
158
159void CodeGenFunction::EmitLabel(const LabelStmt &S) {
160  llvm::BasicBlock *NextBB = getBasicBlockForLabel(&S);
161  EmitBlock(NextBB);
162}
163
164
165void CodeGenFunction::EmitLabelStmt(const LabelStmt &S) {
166  EmitLabel(S);
167  EmitStmt(S.getSubStmt());
168}
169
170void CodeGenFunction::EmitGotoStmt(const GotoStmt &S) {
171  Builder.CreateBr(getBasicBlockForLabel(S.getLabel()));
172
173  // Emit a block after the branch so that dead code after a goto has some place
174  // to go.
175  Builder.SetInsertPoint(llvm::BasicBlock::Create("", CurFn));
176}
177
178void CodeGenFunction::EmitIndirectGotoStmt(const IndirectGotoStmt &S) {
179  // Emit initial switch which will be patched up later by
180  // EmitIndirectSwitches(). We need a default dest, so we use the
181  // current BB, but this is overwritten.
182  llvm::Value *V = Builder.CreatePtrToInt(EmitScalarExpr(S.getTarget()),
183                                          llvm::Type::Int32Ty,
184                                          "addr");
185  llvm::SwitchInst *I = Builder.CreateSwitch(V, Builder.GetInsertBlock());
186  IndirectSwitches.push_back(I);
187
188  // Emit a block after the branch so that dead code after a goto has some place
189  // to go.
190  Builder.SetInsertPoint(llvm::BasicBlock::Create("", CurFn));
191}
192
193void CodeGenFunction::EmitIfStmt(const IfStmt &S) {
194  // FIXME: It would probably be nice for us to skip emission of if
195  // (0) code here.
196
197  // C99 6.8.4.1: The first substatement is executed if the expression compares
198  // unequal to 0.  The condition must be a scalar type.
199  llvm::Value *BoolCondVal = EvaluateExprAsBool(S.getCond());
200
201  llvm::BasicBlock *ContBlock = llvm::BasicBlock::Create("ifend");
202  llvm::BasicBlock *ThenBlock = llvm::BasicBlock::Create("ifthen");
203  llvm::BasicBlock *ElseBlock = ContBlock;
204
205  if (S.getElse())
206    ElseBlock = llvm::BasicBlock::Create("ifelse");
207
208  // Insert the conditional branch.
209  Builder.CreateCondBr(BoolCondVal, ThenBlock, ElseBlock);
210
211  // Emit the 'then' code.
212  EmitBlock(ThenBlock);
213  EmitStmt(S.getThen());
214  llvm::BasicBlock *BB = Builder.GetInsertBlock();
215  if (isDummyBlock(BB)) {
216    BB->eraseFromParent();
217    Builder.SetInsertPoint(ThenBlock);
218  } else {
219    Builder.CreateBr(ContBlock);
220  }
221
222  // Emit the 'else' code if present.
223  if (const Stmt *Else = S.getElse()) {
224    EmitBlock(ElseBlock);
225    EmitStmt(Else);
226    llvm::BasicBlock *BB = Builder.GetInsertBlock();
227    if (isDummyBlock(BB)) {
228      BB->eraseFromParent();
229      Builder.SetInsertPoint(ElseBlock);
230    } else {
231      Builder.CreateBr(ContBlock);
232    }
233  }
234
235  // Emit the continuation block for code after the if.
236  EmitBlock(ContBlock);
237}
238
239void CodeGenFunction::EmitWhileStmt(const WhileStmt &S) {
240  // Emit the header for the loop, insert it, which will create an uncond br to
241  // it.
242  llvm::BasicBlock *LoopHeader = llvm::BasicBlock::Create("whilecond");
243  EmitBlock(LoopHeader);
244
245  // Evaluate the conditional in the while header.  C99 6.8.5.1: The evaluation
246  // of the controlling expression takes place before each execution of the loop
247  // body.
248  llvm::Value *BoolCondVal = EvaluateExprAsBool(S.getCond());
249
250  // while(1) is common, avoid extra exit blocks.  Be sure
251  // to correctly handle break/continue though.
252  bool EmitBoolCondBranch = true;
253  if (llvm::ConstantInt *C = dyn_cast<llvm::ConstantInt>(BoolCondVal))
254    if (C->isOne())
255      EmitBoolCondBranch = false;
256
257  // Create an exit block for when the condition fails, create a block for the
258  // body of the loop.
259  llvm::BasicBlock *ExitBlock = llvm::BasicBlock::Create("whileexit");
260  llvm::BasicBlock *LoopBody  = llvm::BasicBlock::Create("whilebody");
261
262  // As long as the condition is true, go to the loop body.
263  if (EmitBoolCondBranch)
264    Builder.CreateCondBr(BoolCondVal, LoopBody, ExitBlock);
265
266  // Store the blocks to use for break and continue.
267  BreakContinueStack.push_back(BreakContinue(ExitBlock, LoopHeader));
268
269  // Emit the loop body.
270  EmitBlock(LoopBody);
271  EmitStmt(S.getBody());
272
273  BreakContinueStack.pop_back();
274
275  // Cycle to the condition.
276  Builder.CreateBr(LoopHeader);
277
278  // Emit the exit block.
279  EmitBlock(ExitBlock);
280
281  // If LoopHeader is a simple forwarding block then eliminate it.
282  if (!EmitBoolCondBranch
283      && &LoopHeader->front() == LoopHeader->getTerminator()) {
284    LoopHeader->replaceAllUsesWith(LoopBody);
285    LoopHeader->getTerminator()->eraseFromParent();
286    LoopHeader->eraseFromParent();
287  }
288}
289
290void CodeGenFunction::EmitDoStmt(const DoStmt &S) {
291  // Emit the body for the loop, insert it, which will create an uncond br to
292  // it.
293  llvm::BasicBlock *LoopBody = llvm::BasicBlock::Create("dobody");
294  llvm::BasicBlock *AfterDo = llvm::BasicBlock::Create("afterdo");
295  EmitBlock(LoopBody);
296
297  llvm::BasicBlock *DoCond = llvm::BasicBlock::Create("docond");
298
299  // Store the blocks to use for break and continue.
300  BreakContinueStack.push_back(BreakContinue(AfterDo, DoCond));
301
302  // Emit the body of the loop into the block.
303  EmitStmt(S.getBody());
304
305  BreakContinueStack.pop_back();
306
307  EmitBlock(DoCond);
308
309  // C99 6.8.5.2: "The evaluation of the controlling expression takes place
310  // after each execution of the loop body."
311
312  // Evaluate the conditional in the while header.
313  // C99 6.8.5p2/p4: The first substatement is executed if the expression
314  // compares unequal to 0.  The condition must be a scalar type.
315  llvm::Value *BoolCondVal = EvaluateExprAsBool(S.getCond());
316
317  // "do {} while (0)" is common in macros, avoid extra blocks.  Be sure
318  // to correctly handle break/continue though.
319  bool EmitBoolCondBranch = true;
320  if (llvm::ConstantInt *C = dyn_cast<llvm::ConstantInt>(BoolCondVal))
321    if (C->isZero())
322      EmitBoolCondBranch = false;
323
324  // As long as the condition is true, iterate the loop.
325  if (EmitBoolCondBranch)
326    Builder.CreateCondBr(BoolCondVal, LoopBody, AfterDo);
327
328  // Emit the exit block.
329  EmitBlock(AfterDo);
330
331  // If DoCond is a simple forwarding block then eliminate it.
332  if (!EmitBoolCondBranch && &DoCond->front() == DoCond->getTerminator()) {
333    DoCond->replaceAllUsesWith(AfterDo);
334    DoCond->getTerminator()->eraseFromParent();
335    DoCond->eraseFromParent();
336  }
337}
338
339void CodeGenFunction::EmitForStmt(const ForStmt &S) {
340  // FIXME: What do we do if the increment (f.e.) contains a stmt expression,
341  // which contains a continue/break?
342  // TODO: We could keep track of whether the loop body contains any
343  // break/continue statements and not create unnecessary blocks (like
344  // "afterfor" for a condless loop) if it doesn't.
345
346  // Evaluate the first part before the loop.
347  if (S.getInit())
348    EmitStmt(S.getInit());
349
350  // Start the loop with a block that tests the condition.
351  llvm::BasicBlock *CondBlock = llvm::BasicBlock::Create("forcond");
352  llvm::BasicBlock *AfterFor = llvm::BasicBlock::Create("afterfor");
353
354  EmitBlock(CondBlock);
355
356  // Evaluate the condition if present.  If not, treat it as a non-zero-constant
357  // according to 6.8.5.3p2, aka, true.
358  if (S.getCond()) {
359    // C99 6.8.5p2/p4: The first substatement is executed if the expression
360    // compares unequal to 0.  The condition must be a scalar type.
361    llvm::Value *BoolCondVal = EvaluateExprAsBool(S.getCond());
362
363    // As long as the condition is true, iterate the loop.
364    llvm::BasicBlock *ForBody = llvm::BasicBlock::Create("forbody");
365    Builder.CreateCondBr(BoolCondVal, ForBody, AfterFor);
366    EmitBlock(ForBody);
367  } else {
368    // Treat it as a non-zero constant.  Don't even create a new block for the
369    // body, just fall into it.
370  }
371
372  // If the for loop doesn't have an increment we can just use the
373  // condition as the continue block.
374  llvm::BasicBlock *ContinueBlock;
375  if (S.getInc())
376    ContinueBlock = llvm::BasicBlock::Create("forinc");
377  else
378    ContinueBlock = CondBlock;
379
380  // Store the blocks to use for break and continue.
381  BreakContinueStack.push_back(BreakContinue(AfterFor, ContinueBlock));
382
383  // If the condition is true, execute the body of the for stmt.
384  EmitStmt(S.getBody());
385
386  BreakContinueStack.pop_back();
387
388  if (S.getInc())
389    EmitBlock(ContinueBlock);
390
391  // If there is an increment, emit it next.
392  if (S.getInc())
393    EmitStmt(S.getInc());
394
395  // Finally, branch back up to the condition for the next iteration.
396  Builder.CreateBr(CondBlock);
397
398  // Emit the fall-through block.
399  EmitBlock(AfterFor);
400}
401
402/// EmitReturnStmt - Note that due to GCC extensions, this can have an operand
403/// if the function returns void, or may be missing one if the function returns
404/// non-void.  Fun stuff :).
405void CodeGenFunction::EmitReturnStmt(const ReturnStmt &S) {
406  // Emit the result value, even if unused, to evalute the side effects.
407  const Expr *RV = S.getRetValue();
408
409  llvm::Value* RetValue = 0;
410  if (FnRetTy->isVoidType()) {
411    // Make sure not to return anything
412    if (RV) {
413      // Evaluate the expression for side effects
414      EmitAnyExpr(RV);
415    }
416  } else if (RV == 0) {
417    const llvm::Type *RetTy = CurFn->getFunctionType()->getReturnType();
418    if (RetTy != llvm::Type::VoidTy) {
419      // Handle "return;" in a function that returns a value.
420      RetValue = llvm::UndefValue::get(RetTy);
421    }
422  } else if (!hasAggregateLLVMType(RV->getType())) {
423    RetValue = EmitScalarExpr(RV);
424  } else if (RV->getType()->isAnyComplexType()) {
425    EmitComplexExprIntoAddr(RV, CurFn->arg_begin(), false);
426  } else {
427    EmitAggExpr(RV, CurFn->arg_begin(), false);
428  }
429
430  if (RetValue) {
431    Builder.CreateRet(RetValue);
432  } else {
433    Builder.CreateRetVoid();
434  }
435
436  // Emit a block after the branch so that dead code after a return has some
437  // place to go.
438  EmitBlock(llvm::BasicBlock::Create());
439}
440
441void CodeGenFunction::EmitDeclStmt(const DeclStmt &S) {
442  for (const ScopedDecl *Decl = S.getDecl(); Decl;
443       Decl = Decl->getNextDeclarator())
444    EmitDecl(*Decl);
445}
446
447void CodeGenFunction::EmitBreakStmt() {
448  assert(!BreakContinueStack.empty() && "break stmt not in a loop or switch!");
449
450  llvm::BasicBlock *Block = BreakContinueStack.back().BreakBlock;
451  Builder.CreateBr(Block);
452  EmitBlock(llvm::BasicBlock::Create());
453}
454
455void CodeGenFunction::EmitContinueStmt() {
456  assert(!BreakContinueStack.empty() && "continue stmt not in a loop!");
457
458  llvm::BasicBlock *Block = BreakContinueStack.back().ContinueBlock;
459  Builder.CreateBr(Block);
460  EmitBlock(llvm::BasicBlock::Create());
461}
462
463/// EmitCaseStmtRange - If case statement range is not too big then
464/// add multiple cases to switch instruction, one for each value within
465/// the range. If range is too big then emit "if" condition check.
466void CodeGenFunction::EmitCaseStmtRange(const CaseStmt &S) {
467  // FIXME: kill me with param - ddunbar
468  assert(S.getRHS() && "Expected RHS value in CaseStmt");
469
470  llvm::APSInt LHS = S.getLHS()->getIntegerConstantExprValue(getContext());
471  llvm::APSInt RHS = S.getRHS()->getIntegerConstantExprValue(getContext());
472
473  // Emit the code for this case. We do this first to make sure it is
474  // properly chained from our predecessor before generating the
475  // switch machinery to enter this block.
476  StartBlock("sw.bb");
477  llvm::BasicBlock *CaseDest = Builder.GetInsertBlock();
478  EmitStmt(S.getSubStmt());
479
480  // If range is empty, do nothing.
481  if (LHS.isSigned() ? RHS.slt(LHS) : RHS.ult(LHS))
482    return;
483
484  llvm::APInt Range = RHS - LHS;
485  // FIXME: parameters such as this should not be hardcoded.
486  if (Range.ult(llvm::APInt(Range.getBitWidth(), 64))) {
487    // Range is small enough to add multiple switch instruction cases.
488    for (unsigned i = 0, e = Range.getZExtValue() + 1; i != e; ++i) {
489      SwitchInsn->addCase(llvm::ConstantInt::get(LHS), CaseDest);
490      LHS++;
491    }
492    return;
493  }
494
495  // The range is too big. Emit "if" condition into a new block,
496  // making sure to save and restore the current insertion point.
497  llvm::BasicBlock *RestoreBB = Builder.GetInsertBlock();
498
499  // Push this test onto the chain of range checks (which terminates
500  // in the default basic block). The switch's default will be changed
501  // to the top of this chain after switch emission is complete.
502  llvm::BasicBlock *FalseDest = CaseRangeBlock;
503  CaseRangeBlock = llvm::BasicBlock::Create("sw.caserange");
504
505  CurFn->getBasicBlockList().push_back(CaseRangeBlock);
506  Builder.SetInsertPoint(CaseRangeBlock);
507
508  // Emit range check.
509  llvm::Value *Diff =
510    Builder.CreateSub(SwitchInsn->getCondition(), llvm::ConstantInt::get(LHS),
511                      "tmp");
512  llvm::Value *Cond =
513    Builder.CreateICmpULE(Diff, llvm::ConstantInt::get(Range), "tmp");
514  Builder.CreateCondBr(Cond, CaseDest, FalseDest);
515
516  // Restore the appropriate insertion point.
517  Builder.SetInsertPoint(RestoreBB);
518}
519
520void CodeGenFunction::EmitCaseStmt(const CaseStmt &S) {
521  if (S.getRHS()) {
522    EmitCaseStmtRange(S);
523    return;
524  }
525
526  StartBlock("sw.bb");
527  llvm::BasicBlock *CaseDest = Builder.GetInsertBlock();
528  llvm::APSInt CaseVal = S.getLHS()->getIntegerConstantExprValue(getContext());
529  SwitchInsn->addCase(llvm::ConstantInt::get(CaseVal),
530                      CaseDest);
531  EmitStmt(S.getSubStmt());
532}
533
534void CodeGenFunction::EmitDefaultStmt(const DefaultStmt &S) {
535  llvm::BasicBlock *DefaultBlock = SwitchInsn->getDefaultDest();
536  assert(DefaultBlock->empty() && "EmitDefaultStmt: Default block already defined?");
537  EmitBlock(DefaultBlock);
538  EmitStmt(S.getSubStmt());
539}
540
541void CodeGenFunction::EmitSwitchStmt(const SwitchStmt &S) {
542  llvm::Value *CondV = EmitScalarExpr(S.getCond());
543
544  // Handle nested switch statements.
545  llvm::SwitchInst *SavedSwitchInsn = SwitchInsn;
546  llvm::BasicBlock *SavedCRBlock = CaseRangeBlock;
547
548  // Create basic block to hold stuff that comes after switch
549  // statement. We also need to create a default block now so that
550  // explicit case ranges tests can have a place to jump to on
551  // failure.
552  llvm::BasicBlock *NextBlock = llvm::BasicBlock::Create("sw.epilog");
553  llvm::BasicBlock *DefaultBlock = llvm::BasicBlock::Create("sw.default");
554  SwitchInsn = Builder.CreateSwitch(CondV, DefaultBlock);
555  CaseRangeBlock = DefaultBlock;
556
557  // Create basic block for body of switch
558  StartBlock("sw.body");
559
560  // All break statements jump to NextBlock. If BreakContinueStack is non empty
561  // then reuse last ContinueBlock.
562  llvm::BasicBlock *ContinueBlock = NULL;
563  if (!BreakContinueStack.empty())
564    ContinueBlock = BreakContinueStack.back().ContinueBlock;
565  BreakContinueStack.push_back(BreakContinue(NextBlock, ContinueBlock));
566
567  // Emit switch body.
568  EmitStmt(S.getBody());
569  BreakContinueStack.pop_back();
570
571  // Update the default block in case explicit case range tests have
572  // been chained on top.
573  SwitchInsn->setSuccessor(0, CaseRangeBlock);
574
575  // If a default was never emitted then reroute any jumps to it and
576  // discard.
577  if (!DefaultBlock->getParent()) {
578    DefaultBlock->replaceAllUsesWith(NextBlock);
579    delete DefaultBlock;
580  }
581
582  // Emit continuation.
583  EmitBlock(NextBlock);
584
585  SwitchInsn = SavedSwitchInsn;
586  CaseRangeBlock = SavedCRBlock;
587}
588
589static std::string ConvertAsmString(const char *Start, unsigned NumOperands,
590                                    bool IsSimple) {
591  static unsigned AsmCounter = 0;
592  AsmCounter++;
593  std::string Result;
594  if (IsSimple) {
595    while (*Start) {
596      switch (*Start) {
597      default:
598        Result += *Start;
599        break;
600      case '$':
601        Result += "$$";
602        break;
603      }
604      Start++;
605    }
606
607    return Result;
608  }
609
610  while (*Start) {
611    switch (*Start) {
612    default:
613      Result += *Start;
614      break;
615    case '$':
616      Result += "$$";
617      break;
618    case '%':
619      // Escaped character
620      Start++;
621      if (!*Start) {
622        // FIXME: This should be caught during Sema.
623        assert(0 && "Trailing '%' in asm string.");
624      }
625
626      char EscapedChar = *Start;
627      if (EscapedChar == '%') {
628        // Escaped percentage sign.
629        Result += '%';
630      } else if (EscapedChar == '=') {
631        // Generate an unique ID.
632        Result += llvm::utostr(AsmCounter);
633      } else if (isdigit(EscapedChar)) {
634        // %n - Assembler operand n
635        char *End;
636        unsigned long n = strtoul(Start, &End, 10);
637        if (Start == End) {
638          // FIXME: This should be caught during Sema.
639          assert(0 && "Missing operand!");
640        } else if (n >= NumOperands) {
641          // FIXME: This should be caught during Sema.
642          assert(0 && "Operand number out of range!");
643        }
644
645        Result += '$' + llvm::utostr(n);
646        Start = End - 1;
647      } else if (isalpha(EscapedChar)) {
648        char *End;
649
650        unsigned long n = strtoul(Start + 1, &End, 10);
651        if (Start == End) {
652          // FIXME: This should be caught during Sema.
653          assert(0 && "Missing operand!");
654        } else if (n >= NumOperands) {
655          // FIXME: This should be caught during Sema.
656          assert(0 && "Operand number out of range!");
657        }
658
659        Result += "${" + llvm::utostr(n) + ':' + EscapedChar + '}';
660        Start = End - 1;
661      } else {
662        assert(0 && "Unhandled asm escaped character!");
663      }
664    }
665    Start++;
666  }
667
668  return Result;
669}
670
671static std::string SimplifyConstraint(const char* Constraint,
672                                      TargetInfo &Target) {
673  std::string Result;
674
675  while (*Constraint) {
676    switch (*Constraint) {
677    default:
678      Result += Target.convertConstraint(*Constraint);
679      break;
680    // Ignore these
681    case '*':
682    case '?':
683    case '!':
684      break;
685    case 'g':
686      Result += "imr";
687      break;
688    }
689
690    Constraint++;
691  }
692
693  return Result;
694}
695
696void CodeGenFunction::EmitAsmStmt(const AsmStmt &S) {
697  std::string AsmString =
698    ConvertAsmString(std::string(S.getAsmString()->getStrData(),
699                                 S.getAsmString()->getByteLength()).c_str(),
700                     S.getNumOutputs() + S.getNumInputs(), S.isSimple());
701
702  std::string Constraints;
703
704  llvm::Value *ResultAddr = 0;
705  const llvm::Type *ResultType = llvm::Type::VoidTy;
706
707  std::vector<const llvm::Type*> ArgTypes;
708  std::vector<llvm::Value*> Args;
709
710  // Keep track of inout constraints.
711  std::string InOutConstraints;
712  std::vector<llvm::Value*> InOutArgs;
713  std::vector<const llvm::Type*> InOutArgTypes;
714
715  for (unsigned i = 0, e = S.getNumOutputs(); i != e; i++) {
716    std::string OutputConstraint(S.getOutputConstraint(i)->getStrData(),
717                                 S.getOutputConstraint(i)->getByteLength());
718
719    TargetInfo::ConstraintInfo Info;
720    bool result = Target.validateOutputConstraint(OutputConstraint.c_str(),
721                                                  Info);
722    assert(result && "Failed to parse output constraint");
723
724    // Simplify the output constraint.
725    OutputConstraint = SimplifyConstraint(OutputConstraint.c_str() + 1, Target);
726
727    LValue Dest = EmitLValue(S.getOutputExpr(i));
728    const llvm::Type *DestValueType =
729      cast<llvm::PointerType>(Dest.getAddress()->getType())->getElementType();
730
731    // If the first output operand is not a memory dest, we'll
732    // make it the return value.
733    if (i == 0 && !(Info & TargetInfo::CI_AllowsMemory) &&
734        DestValueType->isSingleValueType()) {
735      ResultAddr = Dest.getAddress();
736      ResultType = DestValueType;
737      Constraints += "=" + OutputConstraint;
738    } else {
739      ArgTypes.push_back(Dest.getAddress()->getType());
740      Args.push_back(Dest.getAddress());
741      if (i != 0)
742        Constraints += ',';
743      Constraints += "=*";
744      Constraints += OutputConstraint;
745    }
746
747    if (Info & TargetInfo::CI_ReadWrite) {
748      // FIXME: This code should be shared with the code that handles inputs.
749      InOutConstraints += ',';
750
751      const Expr *InputExpr = S.getOutputExpr(i);
752      llvm::Value *Arg;
753      if ((Info & TargetInfo::CI_AllowsRegister) ||
754          !(Info & TargetInfo::CI_AllowsMemory)) {
755        if (ConvertType(InputExpr->getType())->isSingleValueType()) {
756          Arg = EmitScalarExpr(InputExpr);
757        } else {
758          ErrorUnsupported(&S, "asm statement passing multiple-value types as inputs");
759        }
760      } else {
761        LValue Dest = EmitLValue(InputExpr);
762        Arg = Dest.getAddress();
763        InOutConstraints += '*';
764      }
765
766      InOutArgTypes.push_back(Arg->getType());
767      InOutArgs.push_back(Arg);
768      InOutConstraints += OutputConstraint;
769    }
770  }
771
772  unsigned NumConstraints = S.getNumOutputs() + S.getNumInputs();
773
774  for (unsigned i = 0, e = S.getNumInputs(); i != e; i++) {
775    const Expr *InputExpr = S.getInputExpr(i);
776
777    std::string InputConstraint(S.getInputConstraint(i)->getStrData(),
778                                S.getInputConstraint(i)->getByteLength());
779
780    TargetInfo::ConstraintInfo Info;
781    bool result = Target.validateInputConstraint(InputConstraint.c_str(),
782                                                 NumConstraints,
783                                                 Info);
784    assert(result && "Failed to parse input constraint");
785
786    if (i != 0 || S.getNumOutputs() > 0)
787      Constraints += ',';
788
789    // Simplify the input constraint.
790    InputConstraint = SimplifyConstraint(InputConstraint.c_str(), Target);
791
792    llvm::Value *Arg;
793
794    if ((Info & TargetInfo::CI_AllowsRegister) ||
795        !(Info & TargetInfo::CI_AllowsMemory)) {
796      if (ConvertType(InputExpr->getType())->isSingleValueType()) {
797        Arg = EmitScalarExpr(InputExpr);
798      } else {
799        ErrorUnsupported(&S, "asm statement passing multiple-value types as inputs");
800      }
801    } else {
802      LValue Dest = EmitLValue(InputExpr);
803      Arg = Dest.getAddress();
804      Constraints += '*';
805    }
806
807    ArgTypes.push_back(Arg->getType());
808    Args.push_back(Arg);
809    Constraints += InputConstraint;
810  }
811
812  // Append the "input" part of inout constraints last.
813  for (unsigned i = 0, e = InOutArgs.size(); i != e; i++) {
814    ArgTypes.push_back(InOutArgTypes[i]);
815    Args.push_back(InOutArgs[i]);
816  }
817  Constraints += InOutConstraints;
818
819  // Clobbers
820  for (unsigned i = 0, e = S.getNumClobbers(); i != e; i++) {
821    std::string Clobber(S.getClobber(i)->getStrData(),
822                        S.getClobber(i)->getByteLength());
823
824    Clobber = Target.getNormalizedGCCRegisterName(Clobber.c_str());
825
826    if (i != 0 || NumConstraints != 0)
827      Constraints += ',';
828
829    Constraints += "~{";
830    Constraints += Clobber;
831    Constraints += '}';
832  }
833
834  // Add machine specific clobbers
835  if (const char *C = Target.getClobbers()) {
836    if (!Constraints.empty())
837      Constraints += ',';
838    Constraints += C;
839  }
840
841  const llvm::FunctionType *FTy =
842    llvm::FunctionType::get(ResultType, ArgTypes, false);
843
844  llvm::InlineAsm *IA =
845    llvm::InlineAsm::get(FTy, AsmString, Constraints,
846                         S.isVolatile() || S.getNumOutputs() == 0);
847  llvm::Value *Result = Builder.CreateCall(IA, Args.begin(), Args.end(), "");
848  if (ResultAddr) // FIXME: volatility
849    Builder.CreateStore(Result, ResultAddr);
850}
851