projects/ldc: gen/statements.cpp comparison

comparison gen/statements.cpp @ 309:d59c363fccad trunk

[svn r330] Implemented synchronized statements. Changed the tryfinally handlers to a more generalized EnclosingHandler. Changed ClassInfoS to be mutable so they can be used as locks. Added new BB after throw ala return/break etc.

author	lindquist
date	Sat, 28 Jun 2008 11:37:53 +0200
parents	6b62e8cdf970
children	9967a3270837

comparison

equal deleted inserted replaced

-:6b62e8cdf970
+:d59c363fccad
 p->exps.pop_back();
 if (!e->inPlace())
 DtoAssign(rvar, e);
-DtoFinallyBlocks(enclosingtryfinally, NULL);
+DtoEnclosingHandlers(enclosinghandler, NULL);
-if (f->inVolatile) {
-// store-load barrier
-DtoMemoryBarrier(false, false, true, false);
-}
 if (global.params.symdebug) DtoDwarfFuncEnd(f->decl);
 llvm::ReturnInst::Create(p->scopebb());
 }
 {
 v = gIR->ir->CreateBitCast(v, p->topfunc()->getReturnType(), "tmp");
 Logger::cout() << "return value after cast: " << *v << '\n';
 }
-DtoFinallyBlocks(enclosingtryfinally, NULL);
+DtoEnclosingHandlers(enclosinghandler, NULL);
-if (gIR->func()->inVolatile) {
-// store-load barrier
-DtoMemoryBarrier(false, false, true, false);
-}
 if (global.params.symdebug) DtoDwarfFuncEnd(p->func()->decl);
 llvm::ReturnInst::Create(v, p->scopebb());
 }
 }
 else
 {
 assert(p->topfunc()->getReturnType() == LLType::VoidTy);
-DtoFinallyBlocks(enclosingtryfinally, NULL);
+DtoEnclosingHandlers(enclosinghandler, NULL);
-if (gIR->func()->inVolatile) {
-// store-load barrier
-DtoMemoryBarrier(false, false, true, false);
-}
 if (global.params.symdebug) DtoDwarfFuncEnd(p->func()->decl);
 llvm::ReturnInst::Create(p->scopebb());
 }
 // rewrite scope
 gIR->scope() = IRScope(whilebodybb,endbb);
 // while body code
-p->loopbbs.push_back(IRLoopScope(this,enclosingtryfinally,whilebb,endbb));
+p->loopbbs.push_back(IRLoopScope(this,enclosinghandler,whilebb,endbb));
 body->toIR(p);
 p->loopbbs.pop_back();
 // loop
 if (!gIR->scopereturned())
 // replace current scope
 gIR->scope() = IRScope(dowhilebb,endbb);
 // do-while body code
-p->loopbbs.push_back(IRLoopScope(this,enclosingtryfinally,dowhilebb,endbb));
+p->loopbbs.push_back(IRLoopScope(this,enclosinghandler,dowhilebb,endbb));
 body->toIR(p);
 p->loopbbs.pop_back();
 // create the condition
 DValue* cond_e = condition->toElem(p);
 // move into the for condition block, ie. start the loop
 assert(!gIR->scopereturned());
 llvm::BranchInst::Create(forbb, gIR->scopebb());
-p->loopbbs.push_back(IRLoopScope(this,enclosingtryfinally,forincbb,endbb));
+p->loopbbs.push_back(IRLoopScope(this,enclosinghandler,forincbb,endbb));
 // replace current scope
 gIR->scope() = IRScope(forbb,forbodybb);
 // create the condition
 DtoDwarfStopPoint(loc.linnum);
 if (ident != 0) {
 Logger::println("ident = %s", ident->toChars());
-DtoFinallyBlocks(enclosingtryfinally, target->enclosingtryfinally);
+DtoEnclosingHandlers(enclosinghandler, target->enclosinghandler);
 // get the loop statement the label refers to
 Statement* targetLoopStatement = target->statement;
 ScopeStatement* tmp;
 while(tmp = targetLoopStatement->isScopeStatement())
 }
 }
 assert(found);
 }
 else {
-DtoFinallyBlocks(enclosingtryfinally, p->loopbbs.back().enclosingtryfinally);
+DtoEnclosingHandlers(enclosinghandler, p->loopbbs.back().enclosinghandler);
 llvm::BranchInst::Create(p->loopbbs.back().end, p->scopebb());
 }
 // the break terminated this basicblock, start a new one
 llvm::BasicBlock* oldend = gIR->scopeend();
 DtoDwarfStopPoint(loc.linnum);
 if (ident != 0) {
 Logger::println("ident = %s", ident->toChars());
-DtoFinallyBlocks(enclosingtryfinally, target->enclosingtryfinally);
+DtoEnclosingHandlers(enclosinghandler, target->enclosinghandler);
 // get the loop statement the label refers to
 Statement* targetLoopStatement = target->statement;
 ScopeStatement* tmp;
 while(tmp = targetLoopStatement->isScopeStatement())
 }
 }
 assert(0);
 }
 else {
-DtoFinallyBlocks(enclosingtryfinally, gIR->loopbbs.back().enclosingtryfinally);
+DtoEnclosingHandlers(enclosinghandler, gIR->loopbbs.back().enclosinghandler);
 llvm::BranchInst::Create(gIR->loopbbs.back().begin, gIR->scopebb());
 }
 }
 //////////////////////////////////////////////////////////////////////////////
 //Logger::cout() << "calling: " << *fn << '\n';
 LLValue* arg = DtoBitCast(e->getRVal(), fn->getFunctionType()->getParamType(0));
 //Logger::cout() << "arg: " << *arg << '\n';
 gIR->ir->CreateCall(fn, arg, "");
 gIR->ir->CreateUnreachable();
+// need a block after the throw for now
+llvm::BasicBlock* oldend = gIR->scopeend();
+llvm::BasicBlock* bb = llvm::BasicBlock::Create("afterthrow", p->topfunc(), oldend);
+p->scope() = IRScope(bb,oldend);
 }
 //////////////////////////////////////////////////////////////////////////////
 // used to build the sorted list of cases
 // do switch body
 assert(body);
 p->scope() = IRScope(bodybb, endbb);
-p->loopbbs.push_back(IRLoopScope(this,enclosingtryfinally,p->scopebb(),endbb));
+p->loopbbs.push_back(IRLoopScope(this,enclosinghandler,p->scopebb(),endbb));
 body->toIR(p);
 p->loopbbs.pop_back();
 if (!p->scopereturned())
 llvm::BranchInst::Create(endbb, p->scopebb());
 llvm::BasicBlock* oldend = gIR->scopeend();
 llvm::BasicBlock* endbb = llvm::BasicBlock::Create("unrolledend", p->topfunc(), oldend);
 p->scope() = IRScope(p->scopebb(),endbb);
-p->loopbbs.push_back(IRLoopScope(this,enclosingtryfinally,p->scopebb(),endbb));
+p->loopbbs.push_back(IRLoopScope(this,enclosinghandler,p->scopebb(),endbb));
 for (int i=0; i<statements->dim; ++i)
 {
 Statement* s = (Statement*)statements->data[i];
 s->toIR(p);
 DtoAssign(dst, src);
 value->ir.irLocal->value = valvar;
 }
 // emit body
-p->loopbbs.push_back(IRLoopScope(this,enclosingtryfinally,nextbb,endbb));
+p->loopbbs.push_back(IRLoopScope(this,enclosinghandler,nextbb,endbb));
 body->toIR(p);
 p->loopbbs.pop_back();
 if (!p->scopereturned())
 llvm::BranchInst::Create(nextbb, p->scopebb());
 assert(tf == NULL);
 llvm::BasicBlock* oldend = gIR->scopeend();
 llvm::BasicBlock* bb = llvm::BasicBlock::Create("aftergoto", p->topfunc(), oldend);
-DtoGoto(&loc, label->ident, enclosingtryfinally);
+DtoGoto(&loc, label->ident, enclosinghandler);
 p->scope() = IRScope(bb,oldend);
 }
 //////////////////////////////////////////////////////////////////////////////
 llvm::BasicBlock* bb = llvm::BasicBlock::Create("aftergotodefault", p->topfunc(), oldend);
 assert(!p->scopereturned());
 assert(sw->sdefault->bodyBB);
-DtoFinallyBlocks(enclosingtryfinally, sw->enclosingtryfinally);
+DtoEnclosingHandlers(enclosinghandler, sw->enclosinghandler);
 llvm::BranchInst::Create(sw->sdefault->bodyBB, p->scopebb());
 p->scope() = IRScope(bb,oldend);
 }
 if (!cs->bodyBB)
 {
 cs->bodyBB = llvm::BasicBlock::Create("goto_case", p->topfunc(), p->scopeend());
 }
-DtoFinallyBlocks(enclosingtryfinally, sw->enclosingtryfinally);
+DtoEnclosingHandlers(enclosinghandler, sw->enclosinghandler);
 llvm::BranchInst::Create(cs->bodyBB, p->scopebb());
 p->scope() = IRScope(bb,oldend);
 }
 body->toIR(p);
 }
 //////////////////////////////////////////////////////////////////////////////
+static LLConstant* generate_unique_critical_section()
+{
+const LLType* Mty = DtoMutexType();
+return new llvm::GlobalVariable(Mty, false, llvm::GlobalValue::InternalLinkage, LLConstant::getNullValue(Mty), ".uniqueCS", gIR->module);
+}
 void SynchronizedStatement::toIR(IRState* p)
 {
 Logger::println("SynchronizedStatement::toIR(): %s", loc.toChars());
 LOG_SCOPE;
-Logger::attention(loc, "synchronized is currently ignored. only the body will be emitted");
+if (global.params.symdebug)
+DtoDwarfStopPoint(loc.linnum);
-if (global.params.symdebug)
-DtoDwarfStopPoint(loc.linnum);
+// enter lock
+if (exp)
+{
+llsync = exp->toElem(p)->getRVal();
+DtoEnterMonitor(llsync);
+}
+else
+{
+llsync = generate_unique_critical_section();
+DtoEnterCritical(llsync);
+}
+// emit body
 body->toIR(p);
-}
+// exit lock
-//////////////////////////////////////////////////////////////////////////////
+// no point in a unreachable unlock, terminating statements must insert this themselves.
+if (p->scopereturned())
-/* this has moved to asmstmt.cpp
+return;
-void AsmStatement::toIR(IRState* p)
+else if (exp)
-{
+DtoLeaveMonitor(llsync);
-Logger::println("AsmStatement::toIR(): %s", loc.toChars());
+else
-LOG_SCOPE;
+DtoLeaveCritical(llsync);
-//    error("%s: inline asm is not yet implemented", loc.toChars());
+}
-//    fatal();
-assert(!asmcode && !asmalign && !refparam && !naked && !regs);
-Token* t = tokens;
-assert(t);
-std::string asmstr;
-do {
-Logger::println("token: %s", t->toChars());
-asmstr.append(t->toChars());
-asmstr.append(" ");
-} while (t = t->next);
-Logger::println("asm expr = '%s'", asmstr.c_str());
-// create function type
-std::vector<const LLType*> args;
-const llvm::FunctionType* fty = llvm::FunctionType::get(DtoSize_t(), args, false);
-// create inline asm callee
-llvm::InlineAsm* inasm = llvm::InlineAsm::get(fty, asmstr, "r,r", false);
-assert(0);
-}
-*/
 //////////////////////////////////////////////////////////////////////////////
 void VolatileStatement::toIR(IRState* p)
 {
 Logger::println("VolatileStatement::toIR(): %s", loc.toChars());
 if (global.params.symdebug)
 DtoDwarfStopPoint(loc.linnum);
 // mark in-volatile
-bool old = gIR->func()->inVolatile;
+// FIXME
-gIR->func()->inVolatile = true;
 // has statement
 if (statement != NULL)
 {
 // load-store
 DtoMemoryBarrier(false, true, false, false);
 // do statement
 statement->toIR(p);
-// no point in a unreachable barrier, terminating statements should insert this themselves.
+// no point in a unreachable barrier, terminating statements must insert this themselves.
 if (statement->fallOffEnd())
 {
 // store-load
 DtoMemoryBarrier(false, false, true, false);
 }
 // load-store & store-load
 DtoMemoryBarrier(false, true, true, false);
 }
 // restore volatile state
-gIR->func()->inVolatile = old;
+// FIXME
 }
 //////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////

Mercurial > projects > ldc

comparison gen/statements.cpp @ 309:d59c363fccad trunk