Mercurial > projects > ldc

comparison gen/statements.cpp @ 1650:40bd4a0d4870

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Update to work with LLVM 2.7. Removed use of dyn_cast, llvm no compiles without exceptions and rtti by default. We do need exceptions for the libconfig stuff, but rtti isn't necessary (anymore). Debug info needs to be rewritten, as in LLVM 2.7 the format has completely changed. To have something to look at while rewriting, the old code has been wrapped inside #ifndef DISABLE_DEBUG_INFO , this means that you have to define this to compile at the moment. Updated tango 0.99.9 patch to include updated EH runtime code, which is needed for LLVM 2.7 as well.
author Tomas Lindquist Olsen
date Wed, 19 May 2010 12:42:32 +0200
parents 638a823ace45
children
comparison
equal deleted inserted replaced
1649:36da40ecbbe0 1650:40bd4a0d4870
51 void ReturnStatement::toIR(IRState* p) 51 void ReturnStatement::toIR(IRState* p)
52 { 52 {
53 Logger::println("ReturnStatement::toIR(): %s", loc.toChars()); 53 Logger::println("ReturnStatement::toIR(): %s", loc.toChars());
54 LOG_SCOPE; 54 LOG_SCOPE;
55 55
56 if (global.params.symdebug) 56 #ifndef DISABLE_DEBUG_INFO
57 DtoDwarfStopPoint(loc.linnum); 57 if (global.params.symdebug)
58 58 DtoDwarfStopPoint(loc.linnum);
59 #endif
60
59 // is there a return value expression? 61 // is there a return value expression?
60 if (exp || (!exp && (p->topfunc() == p->mainFunc)) ) 62 if (exp || (!exp && (p->topfunc() == p->mainFunc)) )
61 { 63 {
62 // if the functions return type is void this means that 64 // if the functions return type is void this means that
63 // we are returning through a pointer argument 65 // we are returning through a pointer argument
76 DtoAssign(loc, rvar, e); 78 DtoAssign(loc, rvar, e);
77 79
78 // emit scopes 80 // emit scopes
79 DtoEnclosingHandlers(loc, NULL); 81 DtoEnclosingHandlers(loc, NULL);
80 82
83 #ifndef DISABLE_DEBUG_INFO
81 // emit dbg end function 84 // emit dbg end function
82 if (global.params.symdebug) DtoDwarfFuncEnd(f->decl); 85 if (global.params.symdebug) DtoDwarfFuncEnd(f->decl);
86 #endif
83 87
84 // emit ret 88 // emit ret
85 llvm::ReturnInst::Create(gIR->context(), p->scopebb()); 89 llvm::ReturnInst::Create(gIR->context(), p->scopebb());
86 90
87 } 91 }
124 Logger::cout() << "return value after cast: " << *v << '\n'; 128 Logger::cout() << "return value after cast: " << *v << '\n';
125 } 129 }
126 130
127 DtoEnclosingHandlers(loc, NULL); 131 DtoEnclosingHandlers(loc, NULL);
128 132
133 #ifndef DISABLE_DEBUG_INFO
129 if (global.params.symdebug) DtoDwarfFuncEnd(p->func()->decl); 134 if (global.params.symdebug) DtoDwarfFuncEnd(p->func()->decl);
135 #endif
130 llvm::ReturnInst::Create(gIR->context(), v, p->scopebb()); 136 llvm::ReturnInst::Create(gIR->context(), v, p->scopebb());
131 } 137 }
132 } 138 }
133 // no return value expression means it's a void function 139 // no return value expression means it's a void function
134 else 140 else
135 { 141 {
136 assert(p->topfunc()->getReturnType() == LLType::getVoidTy(gIR->context())); 142 assert(p->topfunc()->getReturnType() == LLType::getVoidTy(gIR->context()));
137 DtoEnclosingHandlers(loc, NULL); 143 DtoEnclosingHandlers(loc, NULL);
138 144
145 #ifndef DISABLE_DEBUG_INFO
139 if (global.params.symdebug) DtoDwarfFuncEnd(p->func()->decl); 146 if (global.params.symdebug) DtoDwarfFuncEnd(p->func()->decl);
147 #endif
140 llvm::ReturnInst::Create(gIR->context(), p->scopebb()); 148 llvm::ReturnInst::Create(gIR->context(), p->scopebb());
141 } 149 }
142 150
143 // the return terminated this basicblock, start a new one 151 // the return terminated this basicblock, start a new one
144 llvm::BasicBlock* oldend = gIR->scopeend(); 152 llvm::BasicBlock* oldend = gIR->scopeend();
151 void ExpStatement::toIR(IRState* p) 159 void ExpStatement::toIR(IRState* p)
152 { 160 {
153 Logger::println("ExpStatement::toIR(): %s", loc.toChars()); 161 Logger::println("ExpStatement::toIR(): %s", loc.toChars());
154 LOG_SCOPE; 162 LOG_SCOPE;
155 163
156 if (global.params.symdebug) 164 #ifndef DISABLE_DEBUG_INFO
157 DtoDwarfStopPoint(loc.linnum); 165 if (global.params.symdebug)
166 DtoDwarfStopPoint(loc.linnum);
167 #endif
158 168
159 if (exp) { 169 if (exp) {
160 if (global.params.llvmAnnotate) 170 if (global.params.llvmAnnotate)
161 DtoAnnotation(exp->toChars()); 171 DtoAnnotation(exp->toChars());
162 elem* e; 172 elem* e;
180 void IfStatement::toIR(IRState* p) 190 void IfStatement::toIR(IRState* p)
181 { 191 {
182 Logger::println("IfStatement::toIR(): %s", loc.toChars()); 192 Logger::println("IfStatement::toIR(): %s", loc.toChars());
183 LOG_SCOPE; 193 LOG_SCOPE;
184 194
185 if (global.params.symdebug) 195 #ifndef DISABLE_DEBUG_INFO
186 DtoDwarfStopPoint(loc.linnum); 196 if (global.params.symdebug)
197 DtoDwarfStopPoint(loc.linnum);
198 #endif
187 199
188 if (match) 200 if (match)
189 DtoRawVarDeclaration(match); 201 DtoRawVarDeclaration(match);
190 202
191 DValue* cond_e = condition->toElem(p); 203 DValue* cond_e = condition->toElem(p);
268 void WhileStatement::toIR(IRState* p) 280 void WhileStatement::toIR(IRState* p)
269 { 281 {
270 Logger::println("WhileStatement::toIR(): %s", loc.toChars()); 282 Logger::println("WhileStatement::toIR(): %s", loc.toChars());
271 LOG_SCOPE; 283 LOG_SCOPE;
272 284
273 if (global.params.symdebug) 285 #ifndef DISABLE_DEBUG_INFO
274 DtoDwarfStopPoint(loc.linnum); 286 if (global.params.symdebug)
287 DtoDwarfStopPoint(loc.linnum);
288 #endif
275 289
276 // create while blocks 290 // create while blocks
277 llvm::BasicBlock* oldend = gIR->scopeend(); 291 llvm::BasicBlock* oldend = gIR->scopeend();
278 llvm::BasicBlock* whilebb = llvm::BasicBlock::Create(gIR->context(), "whilecond", gIR->topfunc(), oldend); 292 llvm::BasicBlock* whilebb = llvm::BasicBlock::Create(gIR->context(), "whilecond", gIR->topfunc(), oldend);
279 llvm::BasicBlock* whilebodybb = llvm::BasicBlock::Create(gIR->context(), "whilebody", gIR->topfunc(), oldend); 293 llvm::BasicBlock* whilebodybb = llvm::BasicBlock::Create(gIR->context(), "whilebody", gIR->topfunc(), oldend);
316 void DoStatement::toIR(IRState* p) 330 void DoStatement::toIR(IRState* p)
317 { 331 {
318 Logger::println("DoStatement::toIR(): %s", loc.toChars()); 332 Logger::println("DoStatement::toIR(): %s", loc.toChars());
319 LOG_SCOPE; 333 LOG_SCOPE;
320 334
321 if (global.params.symdebug) 335 #ifndef DISABLE_DEBUG_INFO
322 DtoDwarfStopPoint(loc.linnum); 336 if (global.params.symdebug)
337 DtoDwarfStopPoint(loc.linnum);
338 #endif
323 339
324 // create while blocks 340 // create while blocks
325 llvm::BasicBlock* oldend = gIR->scopeend(); 341 llvm::BasicBlock* oldend = gIR->scopeend();
326 llvm::BasicBlock* dowhilebb = llvm::BasicBlock::Create(gIR->context(), "dowhile", gIR->topfunc(), oldend); 342 llvm::BasicBlock* dowhilebb = llvm::BasicBlock::Create(gIR->context(), "dowhile", gIR->topfunc(), oldend);
327 llvm::BasicBlock* condbb = llvm::BasicBlock::Create(gIR->context(), "dowhilecond", gIR->topfunc(), oldend); 343 llvm::BasicBlock* condbb = llvm::BasicBlock::Create(gIR->context(), "dowhilecond", gIR->topfunc(), oldend);
361 void ForStatement::toIR(IRState* p) 377 void ForStatement::toIR(IRState* p)
362 { 378 {
363 Logger::println("ForStatement::toIR(): %s", loc.toChars()); 379 Logger::println("ForStatement::toIR(): %s", loc.toChars());
364 LOG_SCOPE; 380 LOG_SCOPE;
365 381
366 if (global.params.symdebug) 382 #ifndef DISABLE_DEBUG_INFO
367 DtoDwarfStopPoint(loc.linnum); 383 if (global.params.symdebug)
384 DtoDwarfStopPoint(loc.linnum);
385 #endif
368 386
369 // create for blocks 387 // create for blocks
370 llvm::BasicBlock* oldend = gIR->scopeend(); 388 llvm::BasicBlock* oldend = gIR->scopeend();
371 llvm::BasicBlock* forbb = llvm::BasicBlock::Create(gIR->context(), "forcond", gIR->topfunc(), oldend); 389 llvm::BasicBlock* forbb = llvm::BasicBlock::Create(gIR->context(), "forcond", gIR->topfunc(), oldend);
372 llvm::BasicBlock* forbodybb = llvm::BasicBlock::Create(gIR->context(), "forbody", gIR->topfunc(), oldend); 390 llvm::BasicBlock* forbodybb = llvm::BasicBlock::Create(gIR->context(), "forbody", gIR->topfunc(), oldend);
441 // don't emit two terminators in a row 459 // don't emit two terminators in a row
442 // happens just before DMD generated default statements if the last case terminates 460 // happens just before DMD generated default statements if the last case terminates
443 if (p->scopereturned()) 461 if (p->scopereturned())
444 return; 462 return;
445 463
446 if (global.params.symdebug) 464 #ifndef DISABLE_DEBUG_INFO
447 DtoDwarfStopPoint(loc.linnum); 465 if (global.params.symdebug)
466 DtoDwarfStopPoint(loc.linnum);
467 #endif
448 468
449 if (ident != 0) { 469 if (ident != 0) {
450 Logger::println("ident = %s", ident->toChars()); 470 Logger::println("ident = %s", ident->toChars());
451 471
452 DtoEnclosingHandlers(loc, target); 472 DtoEnclosingHandlers(loc, target);
496 void ContinueStatement::toIR(IRState* p) 516 void ContinueStatement::toIR(IRState* p)
497 { 517 {
498 Logger::println("ContinueStatement::toIR(): %s", loc.toChars()); 518 Logger::println("ContinueStatement::toIR(): %s", loc.toChars());
499 LOG_SCOPE; 519 LOG_SCOPE;
500 520
501 if (global.params.symdebug) 521 #ifndef DISABLE_DEBUG_INFO
502 DtoDwarfStopPoint(loc.linnum); 522 if (global.params.symdebug)
523 DtoDwarfStopPoint(loc.linnum);
524 #endif
503 525
504 if (ident != 0) { 526 if (ident != 0) {
505 Logger::println("ident = %s", ident->toChars()); 527 Logger::println("ident = %s", ident->toChars());
506 528
507 DtoEnclosingHandlers(loc, target); 529 DtoEnclosingHandlers(loc, target);
562 void TryFinallyStatement::toIR(IRState* p) 584 void TryFinallyStatement::toIR(IRState* p)
563 { 585 {
564 Logger::println("TryFinallyStatement::toIR(): %s", loc.toChars()); 586 Logger::println("TryFinallyStatement::toIR(): %s", loc.toChars());
565 LOG_SCOPE; 587 LOG_SCOPE;
566 588
567 if (global.params.symdebug) 589 #ifndef DISABLE_DEBUG_INFO
568 DtoDwarfStopPoint(loc.linnum); 590 if (global.params.symdebug)
591 DtoDwarfStopPoint(loc.linnum);
592 #endif
569 593
570 // if there's no finalbody or no body, things are simple 594 // if there's no finalbody or no body, things are simple
571 if (!finalbody) { 595 if (!finalbody) {
572 if (body) 596 if (body)
573 body->toIR(p); 597 body->toIR(p);
640 void TryCatchStatement::toIR(IRState* p) 664 void TryCatchStatement::toIR(IRState* p)
641 { 665 {
642 Logger::println("TryCatchStatement::toIR(): %s", loc.toChars()); 666 Logger::println("TryCatchStatement::toIR(): %s", loc.toChars());
643 LOG_SCOPE; 667 LOG_SCOPE;
644 668
645 if (global.params.symdebug) 669 #ifndef DISABLE_DEBUG_INFO
646 DtoDwarfStopPoint(loc.linnum); 670 if (global.params.symdebug)
671 DtoDwarfStopPoint(loc.linnum);
672 #endif
647 673
648 // create basic blocks 674 // create basic blocks
649 llvm::BasicBlock* oldend = p->scopeend(); 675 llvm::BasicBlock* oldend = p->scopeend();
650 676
651 llvm::BasicBlock* trybb = llvm::BasicBlock::Create(gIR->context(), "try", p->topfunc(), oldend); 677 llvm::BasicBlock* trybb = llvm::BasicBlock::Create(gIR->context(), "try", p->topfunc(), oldend);
696 void ThrowStatement::toIR(IRState* p) 722 void ThrowStatement::toIR(IRState* p)
697 { 723 {
698 Logger::println("ThrowStatement::toIR(): %s", loc.toChars()); 724 Logger::println("ThrowStatement::toIR(): %s", loc.toChars());
699 LOG_SCOPE; 725 LOG_SCOPE;
700 726
701 if (global.params.symdebug) 727 #ifndef DISABLE_DEBUG_INFO
702 DtoDwarfStopPoint(loc.linnum); 728 if (global.params.symdebug)
729 DtoDwarfStopPoint(loc.linnum);
730 #endif
703 731
704 assert(exp); 732 assert(exp);
705 DValue* e = exp->toElem(p); 733 DValue* e = exp->toElem(p);
706 734
735 #ifndef DISABLE_DEBUG_INFO
707 if (global.params.symdebug) DtoDwarfFuncEnd(gIR->func()->decl); 736 if (global.params.symdebug) DtoDwarfFuncEnd(gIR->func()->decl);
737 #endif
708 738
709 llvm::Function* fn = LLVM_D_GetRuntimeFunction(gIR->module, "_d_throw_exception"); 739 llvm::Function* fn = LLVM_D_GetRuntimeFunction(gIR->module, "_d_throw_exception");
710 //Logger::cout() << "calling: " << *fn << '\n'; 740 //Logger::cout() << "calling: " << *fn << '\n';
711 LLValue* arg = DtoBitCast(e->getRVal(), fn->getFunctionType()->getParamType(0)); 741 LLValue* arg = DtoBitCast(e->getRVal(), fn->getFunctionType()->getParamType(0));
712 //Logger::cout() << "arg: " << *arg << '\n'; 742 //Logger::cout() << "arg: " << *arg << '\n';
778 void SwitchStatement::toIR(IRState* p) 808 void SwitchStatement::toIR(IRState* p)
779 { 809 {
780 Logger::println("SwitchStatement::toIR(): %s", loc.toChars()); 810 Logger::println("SwitchStatement::toIR(): %s", loc.toChars());
781 LOG_SCOPE; 811 LOG_SCOPE;
782 812
783 if (global.params.symdebug) 813 #ifndef DISABLE_DEBUG_INFO
784 DtoDwarfStopPoint(loc.linnum); 814 if (global.params.symdebug)
815 DtoDwarfStopPoint(loc.linnum);
816 #endif
785 817
786 llvm::BasicBlock* oldend = gIR->scopeend(); 818 llvm::BasicBlock* oldend = gIR->scopeend();
787 819
788 // clear data from previous passes... :/ 820 // clear data from previous passes... :/
789 for (int i=0; i<cases->dim; ++i) 821 for (int i=0; i<cases->dim; ++i)
949 981
950 // if no statements, there's nothing to do 982 // if no statements, there's nothing to do
951 if (!statements || !statements->dim) 983 if (!statements || !statements->dim)
952 return; 984 return;
953 985
954 if (global.params.symdebug) 986 #ifndef DISABLE_DEBUG_INFO
955 DtoDwarfStopPoint(loc.linnum); 987 if (global.params.symdebug)
988 DtoDwarfStopPoint(loc.linnum);
989 #endif
956 990
957 // DMD doesn't fold stuff like continue/break, and since this isn't really a loop 991 // DMD doesn't fold stuff like continue/break, and since this isn't really a loop
958 // we have to keep track of each statement and jump to the next/end on continue/break 992 // we have to keep track of each statement and jump to the next/end on continue/break
959 993
960 llvm::BasicBlock* oldend = gIR->scopeend(); 994 llvm::BasicBlock* oldend = gIR->scopeend();
1015 void ForeachStatement::toIR(IRState* p) 1049 void ForeachStatement::toIR(IRState* p)
1016 { 1050 {
1017 Logger::println("ForeachStatement::toIR(): %s", loc.toChars()); 1051 Logger::println("ForeachStatement::toIR(): %s", loc.toChars());
1018 LOG_SCOPE; 1052 LOG_SCOPE;
1019 1053
1020 if (global.params.symdebug) 1054 #ifndef DISABLE_DEBUG_INFO
1021 DtoDwarfStopPoint(loc.linnum); 1055 if (global.params.symdebug)
1056 DtoDwarfStopPoint(loc.linnum);
1057 #endif
1022 1058
1023 //assert(arguments->dim == 1); 1059 //assert(arguments->dim == 1);
1024 assert(value != 0); 1060 assert(value != 0);
1025 assert(aggr != 0); 1061 assert(aggr != 0);
1026 assert(func != 0); 1062 assert(func != 0);
1147 void ForeachRangeStatement::toIR(IRState* p) 1183 void ForeachRangeStatement::toIR(IRState* p)
1148 { 1184 {
1149 Logger::println("ForeachRangeStatement::toIR(): %s", loc.toChars()); 1185 Logger::println("ForeachRangeStatement::toIR(): %s", loc.toChars());
1150 LOG_SCOPE; 1186 LOG_SCOPE;
1151 1187
1152 if (global.params.symdebug) 1188 #ifndef DISABLE_DEBUG_INFO
1153 DtoDwarfStopPoint(loc.linnum); 1189 if (global.params.symdebug)
1190 DtoDwarfStopPoint(loc.linnum);
1191 #endif
1154 1192
1155 // evaluate lwr/upr 1193 // evaluate lwr/upr
1156 assert(lwr->type->isintegral()); 1194 assert(lwr->type->isintegral());
1157 LLValue* lower = lwr->toElem(p)->getRVal(); 1195 LLValue* lower = lwr->toElem(p)->getRVal();
1158 assert(upr->type->isintegral()); 1196 assert(upr->type->isintegral());
1296 void GotoStatement::toIR(IRState* p) 1334 void GotoStatement::toIR(IRState* p)
1297 { 1335 {
1298 Logger::println("GotoStatement::toIR(): %s", loc.toChars()); 1336 Logger::println("GotoStatement::toIR(): %s", loc.toChars());
1299 LOG_SCOPE; 1337 LOG_SCOPE;
1300 1338
1301 if (global.params.symdebug) 1339 #ifndef DISABLE_DEBUG_INFO
1302 DtoDwarfStopPoint(loc.linnum); 1340 if (global.params.symdebug)
1341 DtoDwarfStopPoint(loc.linnum);
1342 #endif
1303 1343
1304 llvm::BasicBlock* oldend = gIR->scopeend(); 1344 llvm::BasicBlock* oldend = gIR->scopeend();
1305 llvm::BasicBlock* bb = llvm::BasicBlock::Create(gIR->context(), "aftergoto", p->topfunc(), oldend); 1345 llvm::BasicBlock* bb = llvm::BasicBlock::Create(gIR->context(), "aftergoto", p->topfunc(), oldend);
1306 1346
1307 DtoGoto(loc, label->ident, enclosingFinally); 1347 DtoGoto(loc, label->ident, enclosingFinally);
1314 void GotoDefaultStatement::toIR(IRState* p) 1354 void GotoDefaultStatement::toIR(IRState* p)
1315 { 1355 {
1316 Logger::println("GotoDefaultStatement::toIR(): %s", loc.toChars()); 1356 Logger::println("GotoDefaultStatement::toIR(): %s", loc.toChars());
1317 LOG_SCOPE; 1357 LOG_SCOPE;
1318 1358
1319 if (global.params.symdebug) 1359 #ifndef DISABLE_DEBUG_INFO
1320 DtoDwarfStopPoint(loc.linnum); 1360 if (global.params.symdebug)
1361 DtoDwarfStopPoint(loc.linnum);
1362 #endif
1321 1363
1322 llvm::BasicBlock* oldend = gIR->scopeend(); 1364 llvm::BasicBlock* oldend = gIR->scopeend();
1323 llvm::BasicBlock* bb = llvm::BasicBlock::Create(gIR->context(), "aftergotodefault", p->topfunc(), oldend); 1365 llvm::BasicBlock* bb = llvm::BasicBlock::Create(gIR->context(), "aftergotodefault", p->topfunc(), oldend);
1324 1366
1325 assert(!p->scopereturned()); 1367 assert(!p->scopereturned());
1336 void GotoCaseStatement::toIR(IRState* p) 1378 void GotoCaseStatement::toIR(IRState* p)
1337 { 1379 {
1338 Logger::println("GotoCaseStatement::toIR(): %s", loc.toChars()); 1380 Logger::println("GotoCaseStatement::toIR(): %s", loc.toChars());
1339 LOG_SCOPE; 1381 LOG_SCOPE;
1340 1382
1341 if (global.params.symdebug) 1383 #ifndef DISABLE_DEBUG_INFO
1342 DtoDwarfStopPoint(loc.linnum); 1384 if (global.params.symdebug)
1385 DtoDwarfStopPoint(loc.linnum);
1386 #endif
1343 1387
1344 llvm::BasicBlock* oldend = gIR->scopeend(); 1388 llvm::BasicBlock* oldend = gIR->scopeend();
1345 llvm::BasicBlock* bb = llvm::BasicBlock::Create(gIR->context(), "aftergotocase", p->topfunc(), oldend); 1389 llvm::BasicBlock* bb = llvm::BasicBlock::Create(gIR->context(), "aftergotocase", p->topfunc(), oldend);
1346 1390
1347 assert(!p->scopereturned()); 1391 assert(!p->scopereturned());
1361 void WithStatement::toIR(IRState* p) 1405 void WithStatement::toIR(IRState* p)
1362 { 1406 {
1363 Logger::println("WithStatement::toIR(): %s", loc.toChars()); 1407 Logger::println("WithStatement::toIR(): %s", loc.toChars());
1364 LOG_SCOPE; 1408 LOG_SCOPE;
1365 1409
1366 if (global.params.symdebug) 1410 #ifndef DISABLE_DEBUG_INFO
1367 DtoDwarfStopPoint(loc.linnum); 1411 if (global.params.symdebug)
1412 DtoDwarfStopPoint(loc.linnum);
1413 #endif
1368 1414
1369 assert(exp); 1415 assert(exp);
1370 assert(body); 1416 assert(body);
1371 1417
1372 // with(..) can either be used with expressions or with symbols 1418 // with(..) can either be used with expressions or with symbols
1391 void SynchronizedStatement::toIR(IRState* p) 1437 void SynchronizedStatement::toIR(IRState* p)
1392 { 1438 {
1393 Logger::println("SynchronizedStatement::toIR(): %s", loc.toChars()); 1439 Logger::println("SynchronizedStatement::toIR(): %s", loc.toChars());
1394 LOG_SCOPE; 1440 LOG_SCOPE;
1395 1441
1396 if (global.params.symdebug) 1442 #ifndef DISABLE_DEBUG_INFO
1397 DtoDwarfStopPoint(loc.linnum); 1443 if (global.params.symdebug)
1444 DtoDwarfStopPoint(loc.linnum);
1445 #endif
1398 1446
1399 // enter lock 1447 // enter lock
1400 if (exp) 1448 if (exp)
1401 { 1449 {
1402 llsync = exp->toElem(p)->getRVal(); 1450 llsync = exp->toElem(p)->getRVal();
1428 void VolatileStatement::toIR(IRState* p) 1476 void VolatileStatement::toIR(IRState* p)
1429 { 1477 {
1430 Logger::println("VolatileStatement::toIR(): %s", loc.toChars()); 1478 Logger::println("VolatileStatement::toIR(): %s", loc.toChars());
1431 LOG_SCOPE; 1479 LOG_SCOPE;
1432 1480
1433 if (global.params.symdebug) 1481 #ifndef DISABLE_DEBUG_INFO
1434 DtoDwarfStopPoint(loc.linnum); 1482 if (global.params.symdebug)
1483 DtoDwarfStopPoint(loc.linnum);
1484 #endif
1435 1485
1436 // mark in-volatile 1486 // mark in-volatile
1437 // FIXME 1487 // FIXME
1438 1488
1439 // has statement 1489 // has statement