Mercurial > projects > ldc

comparison gen/statements.cpp @ 1571:8d086d552909

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
IntegerType is now contextifed. Requires llvm >= 78969. resistor says this will be the last context API change :)
author Benjamin Kramer <benny.kra@gmail.com>
date Fri, 14 Aug 2009 00:39:18 +0200
parents 755abafbf25d
children 332925de1881
comparison
equal deleted inserted replaced
1570:ab03cfb3a212 1571:8d086d552909
59 // is there a return value expression? 59 // is there a return value expression?
60 if (exp) 60 if (exp)
61 { 61 {
62 // if the functions return type is void this means that 62 // if the functions return type is void this means that
63 // we are returning through a pointer argument 63 // we are returning through a pointer argument
64 if (p->topfunc()->getReturnType() == LLType::VoidTy) 64 if (p->topfunc()->getReturnType() == LLType::getVoidTy(gIR->context()))
65 { 65 {
66 // sanity check 66 // sanity check
67 IrFunction* f = p->func(); 67 IrFunction* f = p->func();
68 assert(f->decl->ir.irFunc->retArg); 68 assert(f->decl->ir.irFunc->retArg);
69 69
80 80
81 // emit dbg end function 81 // emit dbg end function
82 if (global.params.symdebug) DtoDwarfFuncEnd(f->decl); 82 if (global.params.symdebug) DtoDwarfFuncEnd(f->decl);
83 83
84 // emit ret 84 // emit ret
85 llvm::ReturnInst::Create(p->scopebb()); 85 llvm::ReturnInst::Create(gIR->context(), p->scopebb());
86 86
87 } 87 }
88 // the return type is not void, so this is a normal "register" return 88 // the return type is not void, so this is a normal "register" return
89 else 89 else
90 { 90 {
121 } 121 }
122 122
123 DtoEnclosingHandlers(loc, NULL); 123 DtoEnclosingHandlers(loc, NULL);
124 124
125 if (global.params.symdebug) DtoDwarfFuncEnd(p->func()->decl); 125 if (global.params.symdebug) DtoDwarfFuncEnd(p->func()->decl);
126 llvm::ReturnInst::Create(v, p->scopebb()); 126 llvm::ReturnInst::Create(gIR->context(), v, p->scopebb());
127 } 127 }
128 } 128 }
129 // no return value expression means it's a void function 129 // no return value expression means it's a void function
130 else 130 else
131 { 131 {
132 assert(p->topfunc()->getReturnType() == LLType::VoidTy); 132 assert(p->topfunc()->getReturnType() == LLType::getVoidTy(gIR->context()));
133 DtoEnclosingHandlers(loc, NULL); 133 DtoEnclosingHandlers(loc, NULL);
134 134
135 if (global.params.symdebug) DtoDwarfFuncEnd(p->func()->decl); 135 if (global.params.symdebug) DtoDwarfFuncEnd(p->func()->decl);
136 llvm::ReturnInst::Create(p->scopebb()); 136 llvm::ReturnInst::Create(gIR->context(), p->scopebb());
137 } 137 }
138 138
139 // the return terminated this basicblock, start a new one 139 // the return terminated this basicblock, start a new one
140 llvm::BasicBlock* oldend = gIR->scopeend(); 140 llvm::BasicBlock* oldend = gIR->scopeend();
141 llvm::BasicBlock* bb = llvm::BasicBlock::Create("afterreturn", p->topfunc(), oldend); 141 llvm::BasicBlock* bb = llvm::BasicBlock::Create(gIR->context(), "afterreturn", p->topfunc(), oldend);
142 p->scope() = IRScope(bb,oldend); 142 p->scope() = IRScope(bb,oldend);
143 } 143 }
144 144
145 ////////////////////////////////////////////////////////////////////////////// 145 //////////////////////////////////////////////////////////////////////////////
146 146
187 DValue* cond_e = condition->toElem(p); 187 DValue* cond_e = condition->toElem(p);
188 LLValue* cond_val = cond_e->getRVal(); 188 LLValue* cond_val = cond_e->getRVal();
189 189
190 llvm::BasicBlock* oldend = gIR->scopeend(); 190 llvm::BasicBlock* oldend = gIR->scopeend();
191 191
192 llvm::BasicBlock* ifbb = llvm::BasicBlock::Create("if", gIR->topfunc(), oldend); 192 llvm::BasicBlock* ifbb = llvm::BasicBlock::Create(gIR->context(), "if", gIR->topfunc(), oldend);
193 llvm::BasicBlock* endbb = llvm::BasicBlock::Create("endif", gIR->topfunc(), oldend); 193 llvm::BasicBlock* endbb = llvm::BasicBlock::Create(gIR->context(), "endif", gIR->topfunc(), oldend);
194 llvm::BasicBlock* elsebb = elsebody ? llvm::BasicBlock::Create("else", gIR->topfunc(), endbb) : endbb; 194 llvm::BasicBlock* elsebb = elsebody ? llvm::BasicBlock::Create(gIR->context(), "else", gIR->topfunc(), endbb) : endbb;
195 195
196 if (cond_val->getType() != LLType::Int1Ty) { 196 if (cond_val->getType() != LLType::getInt1Ty(gIR->context())) {
197 if (Logger::enabled()) 197 if (Logger::enabled())
198 Logger::cout() << "if conditional: " << *cond_val << '\n'; 198 Logger::cout() << "if conditional: " << *cond_val << '\n';
199 cond_val = DtoCast(loc, cond_e, Type::tbool)->getRVal(); 199 cond_val = DtoCast(loc, cond_e, Type::tbool)->getRVal();
200 } 200 }
201 LLValue* ifgoback = llvm::BranchInst::Create(ifbb, elsebb, cond_val, gIR->scopebb()); 201 LLValue* ifgoback = llvm::BranchInst::Create(ifbb, elsebb, cond_val, gIR->scopebb());
238 llvm::BasicBlock* bb = p->scopebb(); 238 llvm::BasicBlock* bb = p->scopebb();
239 if (bb->empty()) { 239 if (bb->empty()) {
240 beginbb = bb; 240 beginbb = bb;
241 } 241 }
242 else { 242 else {
243 beginbb = llvm::BasicBlock::Create("scope", p->topfunc(), oldend); 243 beginbb = llvm::BasicBlock::Create(gIR->context(), "scope", p->topfunc(), oldend);
244 if (!p->scopereturned()) 244 if (!p->scopereturned())
245 llvm::BranchInst::Create(beginbb, bb); 245 llvm::BranchInst::Create(beginbb, bb);
246 } 246 }
247 247
248 llvm::BasicBlock* endbb = llvm::BasicBlock::Create("endscope", p->topfunc(), oldend); 248 llvm::BasicBlock* endbb = llvm::BasicBlock::Create(gIR->context(), "endscope", p->topfunc(), oldend);
249 if (beginbb != bb) 249 if (beginbb != bb)
250 p->scope() = IRScope(beginbb, endbb); 250 p->scope() = IRScope(beginbb, endbb);
251 else 251 else
252 p->scope().end = endbb;*/ 252 p->scope().end = endbb;*/
253 253
269 if (global.params.symdebug) 269 if (global.params.symdebug)
270 DtoDwarfStopPoint(loc.linnum); 270 DtoDwarfStopPoint(loc.linnum);
271 271
272 // create while blocks 272 // create while blocks
273 llvm::BasicBlock* oldend = gIR->scopeend(); 273 llvm::BasicBlock* oldend = gIR->scopeend();
274 llvm::BasicBlock* whilebb = llvm::BasicBlock::Create("whilecond", gIR->topfunc(), oldend); 274 llvm::BasicBlock* whilebb = llvm::BasicBlock::Create(gIR->context(), "whilecond", gIR->topfunc(), oldend);
275 llvm::BasicBlock* whilebodybb = llvm::BasicBlock::Create("whilebody", gIR->topfunc(), oldend); 275 llvm::BasicBlock* whilebodybb = llvm::BasicBlock::Create(gIR->context(), "whilebody", gIR->topfunc(), oldend);
276 llvm::BasicBlock* endbb = llvm::BasicBlock::Create("endwhile", gIR->topfunc(), oldend); 276 llvm::BasicBlock* endbb = llvm::BasicBlock::Create(gIR->context(), "endwhile", gIR->topfunc(), oldend);
277 277
278 // move into the while block 278 // move into the while block
279 p->ir->CreateBr(whilebb); 279 p->ir->CreateBr(whilebb);
280 //llvm::BranchInst::Create(whilebb, gIR->scopebb()); 280 //llvm::BranchInst::Create(whilebb, gIR->scopebb());
281 281
316 if (global.params.symdebug) 316 if (global.params.symdebug)
317 DtoDwarfStopPoint(loc.linnum); 317 DtoDwarfStopPoint(loc.linnum);
318 318
319 // create while blocks 319 // create while blocks
320 llvm::BasicBlock* oldend = gIR->scopeend(); 320 llvm::BasicBlock* oldend = gIR->scopeend();
321 llvm::BasicBlock* dowhilebb = llvm::BasicBlock::Create("dowhile", gIR->topfunc(), oldend); 321 llvm::BasicBlock* dowhilebb = llvm::BasicBlock::Create(gIR->context(), "dowhile", gIR->topfunc(), oldend);
322 llvm::BasicBlock* condbb = llvm::BasicBlock::Create("dowhilecond", gIR->topfunc(), oldend); 322 llvm::BasicBlock* condbb = llvm::BasicBlock::Create(gIR->context(), "dowhilecond", gIR->topfunc(), oldend);
323 llvm::BasicBlock* endbb = llvm::BasicBlock::Create("enddowhile", gIR->topfunc(), oldend); 323 llvm::BasicBlock* endbb = llvm::BasicBlock::Create(gIR->context(), "enddowhile", gIR->topfunc(), oldend);
324 324
325 // move into the while block 325 // move into the while block
326 assert(!gIR->scopereturned()); 326 assert(!gIR->scopereturned());
327 llvm::BranchInst::Create(dowhilebb, gIR->scopebb()); 327 llvm::BranchInst::Create(dowhilebb, gIR->scopebb());
328 328
360 if (global.params.symdebug) 360 if (global.params.symdebug)
361 DtoDwarfStopPoint(loc.linnum); 361 DtoDwarfStopPoint(loc.linnum);
362 362
363 // create for blocks 363 // create for blocks
364 llvm::BasicBlock* oldend = gIR->scopeend(); 364 llvm::BasicBlock* oldend = gIR->scopeend();
365 llvm::BasicBlock* forbb = llvm::BasicBlock::Create("forcond", gIR->topfunc(), oldend); 365 llvm::BasicBlock* forbb = llvm::BasicBlock::Create(gIR->context(), "forcond", gIR->topfunc(), oldend);
366 llvm::BasicBlock* forbodybb = llvm::BasicBlock::Create("forbody", gIR->topfunc(), oldend); 366 llvm::BasicBlock* forbodybb = llvm::BasicBlock::Create(gIR->context(), "forbody", gIR->topfunc(), oldend);
367 llvm::BasicBlock* forincbb = llvm::BasicBlock::Create("forinc", gIR->topfunc(), oldend); 367 llvm::BasicBlock* forincbb = llvm::BasicBlock::Create(gIR->context(), "forinc", gIR->topfunc(), oldend);
368 llvm::BasicBlock* endbb = llvm::BasicBlock::Create("endfor", gIR->topfunc(), oldend); 368 llvm::BasicBlock* endbb = llvm::BasicBlock::Create(gIR->context(), "endfor", gIR->topfunc(), oldend);
369 369
370 // init 370 // init
371 if (init != 0) 371 if (init != 0)
372 init->toIR(p); 372 init->toIR(p);
373 373
478 llvm::BranchInst::Create(it->breakTarget, gIR->scopebb()); 478 llvm::BranchInst::Create(it->breakTarget, gIR->scopebb());
479 } 479 }
480 480
481 // the break terminated this basicblock, start a new one 481 // the break terminated this basicblock, start a new one
482 llvm::BasicBlock* oldend = gIR->scopeend(); 482 llvm::BasicBlock* oldend = gIR->scopeend();
483 llvm::BasicBlock* bb = llvm::BasicBlock::Create("afterbreak", p->topfunc(), oldend); 483 llvm::BasicBlock* bb = llvm::BasicBlock::Create(gIR->context(), "afterbreak", p->topfunc(), oldend);
484 p->scope() = IRScope(bb,oldend); 484 p->scope() = IRScope(bb,oldend);
485 } 485 }
486 486
487 ////////////////////////////////////////////////////////////////////////////// 487 //////////////////////////////////////////////////////////////////////////////
488 488
533 llvm::BranchInst::Create(it->continueTarget, gIR->scopebb()); 533 llvm::BranchInst::Create(it->continueTarget, gIR->scopebb());
534 } 534 }
535 535
536 // the continue terminated this basicblock, start a new one 536 // the continue terminated this basicblock, start a new one
537 llvm::BasicBlock* oldend = gIR->scopeend(); 537 llvm::BasicBlock* oldend = gIR->scopeend();
538 llvm::BasicBlock* bb = llvm::BasicBlock::Create("aftercontinue", p->topfunc(), oldend); 538 llvm::BasicBlock* bb = llvm::BasicBlock::Create(gIR->context(), "aftercontinue", p->topfunc(), oldend);
539 p->scope() = IRScope(bb,oldend); 539 p->scope() = IRScope(bb,oldend);
540 } 540 }
541 541
542 ////////////////////////////////////////////////////////////////////////////// 542 //////////////////////////////////////////////////////////////////////////////
543 543
572 } 572 }
573 573
574 // create basic blocks 574 // create basic blocks
575 llvm::BasicBlock* oldend = p->scopeend(); 575 llvm::BasicBlock* oldend = p->scopeend();
576 576
577 llvm::BasicBlock* trybb = llvm::BasicBlock::Create("try", p->topfunc(), oldend); 577 llvm::BasicBlock* trybb = llvm::BasicBlock::Create(gIR->context(), "try", p->topfunc(), oldend);
578 llvm::BasicBlock* finallybb = llvm::BasicBlock::Create("finally", p->topfunc(), oldend); 578 llvm::BasicBlock* finallybb = llvm::BasicBlock::Create(gIR->context(), "finally", p->topfunc(), oldend);
579 // the landing pad for statements in the try block 579 // the landing pad for statements in the try block
580 llvm::BasicBlock* landingpadbb = llvm::BasicBlock::Create("landingpad", p->topfunc(), oldend); 580 llvm::BasicBlock* landingpadbb = llvm::BasicBlock::Create(gIR->context(), "landingpad", p->topfunc(), oldend);
581 llvm::BasicBlock* endbb = llvm::BasicBlock::Create("endtryfinally", p->topfunc(), oldend); 581 llvm::BasicBlock* endbb = llvm::BasicBlock::Create(gIR->context(), "endtryfinally", p->topfunc(), oldend);
582 582
583 // pass the previous BB into this 583 // pass the previous BB into this
584 assert(!gIR->scopereturned()); 584 assert(!gIR->scopereturned());
585 llvm::BranchInst::Create(trybb, p->scopebb()); 585 llvm::BranchInst::Create(trybb, p->scopebb());
586 586
639 DtoDwarfStopPoint(loc.linnum); 639 DtoDwarfStopPoint(loc.linnum);
640 640
641 // create basic blocks 641 // create basic blocks
642 llvm::BasicBlock* oldend = p->scopeend(); 642 llvm::BasicBlock* oldend = p->scopeend();
643 643
644 llvm::BasicBlock* trybb = llvm::BasicBlock::Create("try", p->topfunc(), oldend); 644 llvm::BasicBlock* trybb = llvm::BasicBlock::Create(gIR->context(), "try", p->topfunc(), oldend);
645 // the landing pad will be responsible for branching to the correct catch block 645 // the landing pad will be responsible for branching to the correct catch block
646 llvm::BasicBlock* landingpadbb = llvm::BasicBlock::Create("landingpad", p->topfunc(), oldend); 646 llvm::BasicBlock* landingpadbb = llvm::BasicBlock::Create(gIR->context(), "landingpad", p->topfunc(), oldend);
647 llvm::BasicBlock* endbb = llvm::BasicBlock::Create("endtrycatch", p->topfunc(), oldend); 647 llvm::BasicBlock* endbb = llvm::BasicBlock::Create(gIR->context(), "endtrycatch", p->topfunc(), oldend);
648 648
649 // pass the previous BB into this 649 // pass the previous BB into this
650 assert(!gIR->scopereturned()); 650 assert(!gIR->scopereturned());
651 llvm::BranchInst::Create(trybb, p->scopebb()); 651 llvm::BranchInst::Create(trybb, p->scopebb());
652 652
706 gIR->CreateCallOrInvoke(fn, arg); 706 gIR->CreateCallOrInvoke(fn, arg);
707 gIR->ir->CreateUnreachable(); 707 gIR->ir->CreateUnreachable();
708 708
709 // need a block after the throw for now 709 // need a block after the throw for now
710 llvm::BasicBlock* oldend = gIR->scopeend(); 710 llvm::BasicBlock* oldend = gIR->scopeend();
711 llvm::BasicBlock* bb = llvm::BasicBlock::Create("afterthrow", p->topfunc(), oldend); 711 llvm::BasicBlock* bb = llvm::BasicBlock::Create(gIR->context(), "afterthrow", p->topfunc(), oldend);
712 p->scope() = IRScope(bb,oldend); 712 p->scope() = IRScope(bb,oldend);
713 } 713 }
714 714
715 ////////////////////////////////////////////////////////////////////////////// 715 //////////////////////////////////////////////////////////////////////////////
716 716
831 sinits.push_back(arrPtr); 831 sinits.push_back(arrPtr);
832 switchTable = llvm::ConstantStruct::get(sTy, sinits); 832 switchTable = llvm::ConstantStruct::get(sTy, sinits);
833 } 833 }
834 834
835 // body block 835 // body block
836 llvm::BasicBlock* bodybb = llvm::BasicBlock::Create("switchbody", p->topfunc(), oldend); 836 llvm::BasicBlock* bodybb = llvm::BasicBlock::Create(gIR->context(), "switchbody", p->topfunc(), oldend);
837 837
838 // default 838 // default
839 llvm::BasicBlock* defbb = 0; 839 llvm::BasicBlock* defbb = 0;
840 if (sdefault) { 840 if (sdefault) {
841 Logger::println("has default"); 841 Logger::println("has default");
842 defbb = llvm::BasicBlock::Create("default", p->topfunc(), oldend); 842 defbb = llvm::BasicBlock::Create(gIR->context(), "default", p->topfunc(), oldend);
843 sdefault->bodyBB = defbb; 843 sdefault->bodyBB = defbb;
844 } 844 }
845 845
846 // end (break point) 846 // end (break point)
847 llvm::BasicBlock* endbb = llvm::BasicBlock::Create("switchend", p->topfunc(), oldend); 847 llvm::BasicBlock* endbb = llvm::BasicBlock::Create(gIR->context(), "switchend", p->topfunc(), oldend);
848 848
849 // condition var 849 // condition var
850 LLValue* condVal; 850 LLValue* condVal;
851 // integral switch 851 // integral switch
852 if (condition->type->isintegral()) { 852 if (condition->type->isintegral()) {
884 void CaseStatement::toIR(IRState* p) 884 void CaseStatement::toIR(IRState* p)
885 { 885 {
886 Logger::println("CaseStatement::toIR(): %s", loc.toChars()); 886 Logger::println("CaseStatement::toIR(): %s", loc.toChars());
887 LOG_SCOPE; 887 LOG_SCOPE;
888 888
889 llvm::BasicBlock* nbb = llvm::BasicBlock::Create("case", p->topfunc(), p->scopeend()); 889 llvm::BasicBlock* nbb = llvm::BasicBlock::Create(gIR->context(), "case", p->topfunc(), p->scopeend());
890 890
891 if (bodyBB && !bodyBB->getTerminator()) 891 if (bodyBB && !bodyBB->getTerminator())
892 { 892 {
893 llvm::BranchInst::Create(nbb, bodyBB); 893 llvm::BranchInst::Create(nbb, bodyBB);
894 } 894 }
914 Logger::println("DefaultStatement::toIR(): %s", loc.toChars()); 914 Logger::println("DefaultStatement::toIR(): %s", loc.toChars());
915 LOG_SCOPE; 915 LOG_SCOPE;
916 916
917 assert(bodyBB); 917 assert(bodyBB);
918 918
919 llvm::BasicBlock* nbb = llvm::BasicBlock::Create("default", p->topfunc(), p->scopeend()); 919 llvm::BasicBlock* nbb = llvm::BasicBlock::Create(gIR->context(), "default", p->topfunc(), p->scopeend());
920 920
921 if (!bodyBB->getTerminator()) 921 if (!bodyBB->getTerminator())
922 { 922 {
923 llvm::BranchInst::Create(nbb, bodyBB); 923 llvm::BranchInst::Create(nbb, bodyBB);
924 } 924 }
956 size_t nstmt = statements->dim; 956 size_t nstmt = statements->dim;
957 LLSmallVector<llvm::BasicBlock*, 4> blocks(nstmt, NULL); 957 LLSmallVector<llvm::BasicBlock*, 4> blocks(nstmt, NULL);
958 958
959 for (size_t i=0; i<nstmt; i++) 959 for (size_t i=0; i<nstmt; i++)
960 { 960 {
961 blocks[i] = llvm::BasicBlock::Create("unrolledstmt", p->topfunc(), oldend); 961 blocks[i] = llvm::BasicBlock::Create(gIR->context(), "unrolledstmt", p->topfunc(), oldend);
962 } 962 }
963 963
964 // create end block 964 // create end block
965 llvm::BasicBlock* endbb = llvm::BasicBlock::Create("unrolledend", p->topfunc(), oldend); 965 llvm::BasicBlock* endbb = llvm::BasicBlock::Create(gIR->context(), "unrolledend", p->topfunc(), oldend);
966 966
967 // enter first stmt 967 // enter first stmt
968 if (!p->scopereturned()) 968 if (!p->scopereturned())
969 p->ir->CreateBr(blocks[0]); 969 p->ir->CreateBr(blocks[0]);
970 970
1068 else { 1068 else {
1069 new llvm::StoreInst(niters, keyvar, p->scopebb()); 1069 new llvm::StoreInst(niters, keyvar, p->scopebb());
1070 } 1070 }
1071 1071
1072 llvm::BasicBlock* oldend = gIR->scopeend(); 1072 llvm::BasicBlock* oldend = gIR->scopeend();
1073 llvm::BasicBlock* condbb = llvm::BasicBlock::Create("foreachcond", p->topfunc(), oldend); 1073 llvm::BasicBlock* condbb = llvm::BasicBlock::Create(gIR->context(), "foreachcond", p->topfunc(), oldend);
1074 llvm::BasicBlock* bodybb = llvm::BasicBlock::Create("foreachbody", p->topfunc(), oldend); 1074 llvm::BasicBlock* bodybb = llvm::BasicBlock::Create(gIR->context(), "foreachbody", p->topfunc(), oldend);
1075 llvm::BasicBlock* nextbb = llvm::BasicBlock::Create("foreachnext", p->topfunc(), oldend); 1075 llvm::BasicBlock* nextbb = llvm::BasicBlock::Create(gIR->context(), "foreachnext", p->topfunc(), oldend);
1076 llvm::BasicBlock* endbb = llvm::BasicBlock::Create("foreachend", p->topfunc(), oldend); 1076 llvm::BasicBlock* endbb = llvm::BasicBlock::Create(gIR->context(), "foreachend", p->topfunc(), oldend);
1077 1077
1078 llvm::BranchInst::Create(condbb, p->scopebb()); 1078 llvm::BranchInst::Create(condbb, p->scopebb());
1079 1079
1080 // condition 1080 // condition
1081 p->scope() = IRScope(condbb,bodybb); 1081 p->scope() = IRScope(condbb,bodybb);
1161 else 1161 else
1162 DtoStore(upper, keyval); 1162 DtoStore(upper, keyval);
1163 1163
1164 // set up the block we'll need 1164 // set up the block we'll need
1165 llvm::BasicBlock* oldend = gIR->scopeend(); 1165 llvm::BasicBlock* oldend = gIR->scopeend();
1166 llvm::BasicBlock* condbb = llvm::BasicBlock::Create("foreachrange_cond", p->topfunc(), oldend); 1166 llvm::BasicBlock* condbb = llvm::BasicBlock::Create(gIR->context(), "foreachrange_cond", p->topfunc(), oldend);
1167 llvm::BasicBlock* bodybb = llvm::BasicBlock::Create("foreachrange_body", p->topfunc(), oldend); 1167 llvm::BasicBlock* bodybb = llvm::BasicBlock::Create(gIR->context(), "foreachrange_body", p->topfunc(), oldend);
1168 llvm::BasicBlock* nextbb = llvm::BasicBlock::Create("foreachrange_next", p->topfunc(), oldend); 1168 llvm::BasicBlock* nextbb = llvm::BasicBlock::Create(gIR->context(), "foreachrange_next", p->topfunc(), oldend);
1169 llvm::BasicBlock* endbb = llvm::BasicBlock::Create("foreachrange_end", p->topfunc(), oldend); 1169 llvm::BasicBlock* endbb = llvm::BasicBlock::Create(gIR->context(), "foreachrange_end", p->topfunc(), oldend);
1170 1170
1171 // jump to condition 1171 // jump to condition
1172 llvm::BranchInst::Create(condbb, p->scopebb()); 1172 llvm::BranchInst::Create(condbb, p->scopebb());
1173 1173
1174 // CONDITION 1174 // CONDITION
1266 1266
1267 llvm::BasicBlock* oldend = gIR->scopeend(); 1267 llvm::BasicBlock* oldend = gIR->scopeend();
1268 if (labelBB != NULL) { 1268 if (labelBB != NULL) {
1269 labelBB->moveBefore(oldend); 1269 labelBB->moveBefore(oldend);
1270 } else { 1270 } else {
1271 labelBB = llvm::BasicBlock::Create("label_" + labelname, p->topfunc(), oldend); 1271 labelBB = llvm::BasicBlock::Create(gIR->context(), "label_" + labelname, p->topfunc(), oldend);
1272 } 1272 }
1273 1273
1274 if (!p->scopereturned()) 1274 if (!p->scopereturned())
1275 llvm::BranchInst::Create(labelBB, p->scopebb()); 1275 llvm::BranchInst::Create(labelBB, p->scopebb());
1276 1276
1293 1293
1294 if (global.params.symdebug) 1294 if (global.params.symdebug)
1295 DtoDwarfStopPoint(loc.linnum); 1295 DtoDwarfStopPoint(loc.linnum);
1296 1296
1297 llvm::BasicBlock* oldend = gIR->scopeend(); 1297 llvm::BasicBlock* oldend = gIR->scopeend();
1298 llvm::BasicBlock* bb = llvm::BasicBlock::Create("aftergoto", p->topfunc(), oldend); 1298 llvm::BasicBlock* bb = llvm::BasicBlock::Create(gIR->context(), "aftergoto", p->topfunc(), oldend);
1299 1299
1300 DtoGoto(loc, label->ident, enclosingFinally); 1300 DtoGoto(loc, label->ident, enclosingFinally);
1301 1301
1302 p->scope() = IRScope(bb,oldend); 1302 p->scope() = IRScope(bb,oldend);
1303 } 1303 }
1311 1311
1312 if (global.params.symdebug) 1312 if (global.params.symdebug)
1313 DtoDwarfStopPoint(loc.linnum); 1313 DtoDwarfStopPoint(loc.linnum);
1314 1314
1315 llvm::BasicBlock* oldend = gIR->scopeend(); 1315 llvm::BasicBlock* oldend = gIR->scopeend();
1316 llvm::BasicBlock* bb = llvm::BasicBlock::Create("aftergotodefault", p->topfunc(), oldend); 1316 llvm::BasicBlock* bb = llvm::BasicBlock::Create(gIR->context(), "aftergotodefault", p->topfunc(), oldend);
1317 1317
1318 assert(!p->scopereturned()); 1318 assert(!p->scopereturned());
1319 assert(sw->sdefault->bodyBB); 1319 assert(sw->sdefault->bodyBB);
1320 1320
1321 DtoEnclosingHandlers(loc, sw); 1321 DtoEnclosingHandlers(loc, sw);
1333 1333
1334 if (global.params.symdebug) 1334 if (global.params.symdebug)
1335 DtoDwarfStopPoint(loc.linnum); 1335 DtoDwarfStopPoint(loc.linnum);
1336 1336
1337 llvm::BasicBlock* oldend = gIR->scopeend(); 1337 llvm::BasicBlock* oldend = gIR->scopeend();
1338 llvm::BasicBlock* bb = llvm::BasicBlock::Create("aftergotocase", p->topfunc(), oldend); 1338 llvm::BasicBlock* bb = llvm::BasicBlock::Create(gIR->context(), "aftergotocase", p->topfunc(), oldend);
1339 1339
1340 assert(!p->scopereturned()); 1340 assert(!p->scopereturned());
1341 if (!cs->bodyBB) 1341 if (!cs->bodyBB)
1342 { 1342 {
1343 cs->bodyBB = llvm::BasicBlock::Create("goto_case", p->topfunc(), p->scopeend()); 1343 cs->bodyBB = llvm::BasicBlock::Create(gIR->context(), "goto_case", p->topfunc(), p->scopeend());
1344 } 1344 }
1345 1345
1346 DtoEnclosingHandlers(loc, sw); 1346 DtoEnclosingHandlers(loc, sw);
1347 1347
1348 llvm::BranchInst::Create(cs->bodyBB, p->scopebb()); 1348 llvm::BranchInst::Create(cs->bodyBB, p->scopebb());