D/ldc
1
0
Fork 0
mirror of https://github.com/xomboverlord/ldc.git synced 2026-01-11 18:33:14 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

Added emission of dwarf lexical blocks.

Browse Source 
Also, dropped support for DISABLE_DEBUG_INFO definition.
This commit is contained in:
Alexey Prokhin
2011-12-04 14:48:47 +04:00
parent cdeca718fc
commit 91f4e5d015
12 changed files with 221 additions and 194 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
CMakeLists.txt
View File

@@ -238,7 +238,6 @@ add_definitions(
-DIN_LLVM
-D_DH
-DOPAQUE_VTBLS
#-DDISABLE_DEBUG_INFO
)
if(UNIX)

9
gen/asmstmt.cpp
View File

@@ -211,14 +211,11 @@ AsmStatement::toIR(IRState * irs)
IRAsmBlock* asmblock = irs->asmBlock;
assert(asmblock);
#ifndef DISABLE_DEBUG_INFO
// debug info
if (global.params.symdebug)
DtoDwarfStopPoint(loc.linnum);
#endif
DtoDwarfStopPoint(loc.linnum);
if (! asmcode)
return;
if (!asmcode)
return;
static std::string i_cns = "i";
static std::string p_cns = "i";

5
gen/declarations.cpp
View File

@@ -174,11 +174,8 @@ void VarDeclaration::codegen(Ir* p)
ir.irGlobal->constInit = initVal;
gvar->setInitializer(initVal);
#ifndef DISABLE_DEBUG_INFO
// do debug info
if (global.params.symdebug)
DtoDwarfGlobalVariable(gvar, this);
#endif
DtoDwarfGlobalVariable(gvar, this);
}
}
}

20
gen/functions.cpp
View File

@@ -642,11 +642,8 @@ void DtoDefineFunction(FuncDeclaration* fd)
return;
}
#ifndef DISABLE_DEBUG_INFO
// debug info
if (global.params.symdebug)
fd->ir.irFunc->diSubprogram = DtoDwarfSubProgram(fd);
#endif
fd->ir.irFunc->diSubprogram = DtoDwarfSubProgram(fd);
Type* t = fd->type->toBasetype();
TypeFunction* f = (TypeFunction*)t;
@@ -685,10 +682,8 @@ void DtoDefineFunction(FuncDeclaration* fd)
llvm::Instruction* allocaPoint = new llvm::AllocaInst(LLType::getInt32Ty(gIR->context()), "alloca point", beginbb);
irfunction->allocapoint = allocaPoint;
#ifndef DISABLE_DEBUG_INFO
// debug info - after all allocas, but before any llvm.dbg.declare etc
if (global.params.symdebug) DtoDwarfFuncStart(fd);
#endif
DtoDwarfFuncStart(fd);
// this hack makes sure the frame pointer elimination optimization is disabled.
// this this eliminates a bunch of inline asm related issues.
@@ -716,10 +711,7 @@ void DtoDefineFunction(FuncDeclaration* fd)
fd->vthis->ir.irLocal = new IrLocal(fd->vthis);
fd->vthis->ir.irLocal->value = thismem;
#ifndef DISABLE_DEBUG_INFO
if (global.params.symdebug)
DtoDwarfLocalVariable(thismem, fd->vthis);
#endif
DtoDwarfLocalVariable(thismem, fd->vthis);
#if DMDV1
if (fd->vthis->nestedref)
@@ -780,10 +772,8 @@ void DtoDefineFunction(FuncDeclaration* fd)
irloc->value = mem;
}
#ifndef DISABLE_DEBUG_INFO
if (global.params.symdebug && !(isaArgument(irloc->value) && isaArgument(irloc->value)->hasByValAttr()) && !refout)
DtoDwarfLocalVariable(irloc->value, vd);
#endif
}
}
@@ -845,9 +835,7 @@ void DtoDefineFunction(FuncDeclaration* fd)
// in automatically, so we do it here.
// pass the previous block into this block
#ifndef DISABLE_DEBUG_INFO
if (global.params.symdebug) DtoDwarfFuncEnd(fd);
#endif
DtoDwarfFuncEnd(fd);
if (func->getReturnType() == LLType::getVoidTy(gIR->context())) {
llvm::ReturnInst::Create(gIR->context(), gIR->scopebb());
}

29
gen/llvmhelpers.cpp
View File

@@ -199,11 +199,8 @@ void DtoAssert(Module* M, Loc loc, DValue* msg)
// call
gIR->CreateCallOrInvoke(fn, args);
#ifndef DISABLE_DEBUG_INFO
// end debug info
if (global.params.symdebug)
DtoDwarfFuncEnd(gIR->func()->decl);
#endif
DtoDwarfFuncEnd(gIR->func()->decl);
// after assert is always unreachable
gIR->ir->CreateUnreachable();
@@ -515,12 +512,10 @@ void DtoAssign(Loc& loc, DValue* lhs, DValue* rhs, int op)
gIR->ir->CreateStore(r, l);
}
#ifndef DISABLE_DEBUG_INFO
DVarValue *var = lhs->isVar();
VarDeclaration *varDecl = var ? var->var : 0;
if (global.params.symdebug && varDecl && varDecl->debugVariable)
DtoDwarfValue(lhs->getRVal(), varDecl);
#endif
VarDeclaration *vd = var ? var->var : 0;
if (vd)
DtoDwarfValue(lhs->getRVal(), vd);
}
/****************************************************************************************/
@@ -934,11 +929,8 @@ void DtoConstInitGlobal(VarDeclaration* vd)
gvar->setInitializer(initVal);
#ifndef DISABLE_DEBUG_INFO
// do debug info
if (global.params.symdebug)
DtoDwarfGlobalVariable(gvar, vd);
#endif
DtoDwarfGlobalVariable(gvar, vd);
}
}
@@ -1062,10 +1054,7 @@ DValue* DtoDeclarationExp(Dsymbol* declaration)
//allocainst->setAlignment(vd->type->alignsize()); // TODO
vd->ir.irLocal->value = allocainst;
#ifndef DISABLE_DEBUG_INFO
if (global.params.symdebug)
DtoDwarfLocalVariable(allocainst, vd);
#endif
DtoDwarfLocalVariable(allocainst, vd);
}
else
{
@@ -1193,12 +1182,8 @@ LLValue* DtoRawVarDeclaration(VarDeclaration* var, LLValue* addr)
if (!addr && (!var->ir.irLocal || !var->ir.irLocal->value))
{
addr = DtoAlloca(var->type, var->toChars());
#ifndef DISABLE_DEBUG_INFO
// add debug info
if (global.params.symdebug)
DtoDwarfLocalVariable(addr, var);
#endif
DtoDwarfLocalVariable(addr, var);
}
// referenced by nested function?

8
gen/nested.cpp
View File

@@ -553,7 +553,7 @@ void DtoCreateNestedContext(FuncDeclaration* fd) {
// copy parent frame into beginning
if (nparelems)
{
LLValue* src = DtoLoad(irfunction->nestArg);
LLValue* src = irfunction->nestArg;
if (!src)
{
assert(irfunction->thisArg);
@@ -563,6 +563,8 @@ void DtoCreateNestedContext(FuncDeclaration* fd) {
assert(cd);
assert(cd->vthis);
src = DtoLoad(DtoGEPi(thisval, 0,cd->vthis->ir.irField->index, ".vthis"));
} else {
src = DtoLoad(src);
}
DtoMemCpy(nestedVars, src, DtoConstSize_t(nparelems*PTRSIZE),
getABITypeAlign(getVoidPtrType()));
@@ -615,7 +617,7 @@ void DtoCreateNestedContext(FuncDeclaration* fd) {
// copy parent frames into beginning
if (depth != 0) {
LLValue* src = DtoLoad(irfunction->nestArg);
LLValue* src = irfunction->nestArg;
if (!src) {
assert(irfunction->thisArg);
assert(fd->isMember2());
@@ -634,6 +636,8 @@ void DtoCreateNestedContext(FuncDeclaration* fd) {
else
#endif
src = DtoLoad(DtoGEPi(thisval, 0, cd->vthis->ir.irField->index, ".vthis"));
} else {
src = DtoLoad(src);
}
if (depth > 1) {
src = DtoBitCast(src, getVoidPtrType());

197
gen/statements.cpp
View File

@@ -52,10 +52,8 @@ void ReturnStatement::toIR(IRState* p)
Logger::println("ReturnStatement::toIR(): %s", loc.toChars());
LOG_SCOPE;
#ifndef DISABLE_DEBUG_INFO
if (global.params.symdebug)
DtoDwarfStopPoint(loc.linnum);
#endif
// emit dwarf stop point
DtoDwarfStopPoint(loc.linnum);
// is there a return value expression?
if (exp || (!exp && (p->topfunc() == p->mainFunc)) )
@@ -84,10 +82,8 @@ void ReturnStatement::toIR(IRState* p)
// emit scopes
DtoEnclosingHandlers(loc, NULL);
#ifndef DISABLE_DEBUG_INFO
// emit dbg end function
if (global.params.symdebug) DtoDwarfFuncEnd(f->decl);
#endif
DtoDwarfFuncEnd(f->decl);
// emit ret
llvm::ReturnInst::Create(gIR->context(), p->scopebb());
@@ -158,9 +154,7 @@ void ReturnStatement::toIR(IRState* p)
// emit scopes
DtoEnclosingHandlers(loc, NULL);
#ifndef DISABLE_DEBUG_INFO
if (global.params.symdebug) DtoDwarfFuncEnd(p->func()->decl);
#endif
DtoDwarfFuncEnd(p->func()->decl);
llvm::ReturnInst::Create(gIR->context(), v, p->scopebb());
}
}
@@ -169,10 +163,7 @@ void ReturnStatement::toIR(IRState* p)
{
assert(p->topfunc()->getReturnType() == LLType::getVoidTy(gIR->context()));
DtoEnclosingHandlers(loc, NULL);
#ifndef DISABLE_DEBUG_INFO
if (global.params.symdebug) DtoDwarfFuncEnd(p->func()->decl);
#endif
DtoDwarfFuncEnd(p->func()->decl);
llvm::ReturnInst::Create(gIR->context(), p->scopebb());
}
@@ -189,10 +180,8 @@ void ExpStatement::toIR(IRState* p)
Logger::println("ExpStatement::toIR(): %s", loc.toChars());
LOG_SCOPE;
#ifndef DISABLE_DEBUG_INFO
if (global.params.symdebug)
DtoDwarfStopPoint(loc.linnum);
#endif
// emit dwarf stop point
DtoDwarfStopPoint(loc.linnum);
if (exp) {
if (global.params.llvmAnnotate)
@@ -243,11 +232,8 @@ void IfStatement::toIR(IRState* p)
Logger::println("IfStatement::toIR(): %s", loc.toChars());
LOG_SCOPE;
#ifndef DISABLE_DEBUG_INFO
if (global.params.symdebug)
DtoDwarfStopPoint(loc.linnum);
#endif
// start a dwarf lexical block
DtoDwarfBlockStart(loc);
if (match)
DtoRawVarDeclaration(match);
@@ -271,8 +257,12 @@ void IfStatement::toIR(IRState* p)
gIR->scope() = IRScope(ifbb,elsebb);
// do scoped statements
if (ifbody)
if (ifbody) {
DtoDwarfBlockStart(ifbody->loc);
ifbody->toIR(p);
DtoDwarfBlockEnd();
}
if (!gIR->scopereturned()) {
llvm::BranchInst::Create(endbb,gIR->scopebb());
}
@@ -280,12 +270,17 @@ void IfStatement::toIR(IRState* p)
if (elsebody) {
//assert(0);
gIR->scope() = IRScope(elsebb,endbb);
DtoDwarfBlockStart(elsebody->loc);
elsebody->toIR(p);
if (!gIR->scopereturned()) {
llvm::BranchInst::Create(endbb,gIR->scopebb());
}
DtoDwarfBlockEnd();
}
// end the dwarf lexical block
DtoDwarfBlockEnd();
// rewrite the scope
gIR->scope() = IRScope(endbb,oldend);
}
@@ -318,8 +313,11 @@ void ScopeStatement::toIR(IRState* p)
else
p->scope().end = endbb;*/
if (statement)
if (statement) {
DtoDwarfBlockStart(statement->loc);
statement->toIR(p);
DtoDwarfBlockEnd();
}
/*p->scope().end = oldend;
Logger::println("Erasing scope endbb");
@@ -333,10 +331,8 @@ void WhileStatement::toIR(IRState* p)
Logger::println("WhileStatement::toIR(): %s", loc.toChars());
LOG_SCOPE;
#ifndef DISABLE_DEBUG_INFO
if (global.params.symdebug)
DtoDwarfStopPoint(loc.linnum);
#endif
// start a dwarf lexical block
DtoDwarfBlockStart(loc);
// create while blocks
llvm::BasicBlock* oldend = gIR->scopeend();
@@ -374,6 +370,9 @@ void WhileStatement::toIR(IRState* p)
// rewrite the scope
gIR->scope() = IRScope(endbb,oldend);
// end the dwarf lexical block
DtoDwarfBlockEnd();
}
//////////////////////////////////////////////////////////////////////////////
@@ -383,10 +382,8 @@ void DoStatement::toIR(IRState* p)
Logger::println("DoStatement::toIR(): %s", loc.toChars());
LOG_SCOPE;
#ifndef DISABLE_DEBUG_INFO
if (global.params.symdebug)
DtoDwarfStopPoint(loc.linnum);
#endif
// start a dwarf lexical block
DtoDwarfBlockStart(loc);
// create while blocks
llvm::BasicBlock* oldend = gIR->scopeend();
@@ -421,6 +418,9 @@ void DoStatement::toIR(IRState* p)
// rewrite the scope
gIR->scope() = IRScope(endbb,oldend);
// end the dwarf lexical block
DtoDwarfBlockEnd();
}
//////////////////////////////////////////////////////////////////////////////
@@ -430,10 +430,8 @@ void ForStatement::toIR(IRState* p)
Logger::println("ForStatement::toIR(): %s", loc.toChars());
LOG_SCOPE;
#ifndef DISABLE_DEBUG_INFO
if (global.params.symdebug)
DtoDwarfStopPoint(loc.linnum);
#endif
// start new dwarf lexical block
DtoDwarfBlockStart(loc);
// create for blocks
llvm::BasicBlock* oldend = gIR->scopeend();
@@ -444,7 +442,7 @@ void ForStatement::toIR(IRState* p)
// init
if (init != 0)
init->toIR(p);
init->toIR(p);
// move into the for condition block, ie. start the loop
assert(!gIR->scopereturned());
@@ -498,6 +496,9 @@ void ForStatement::toIR(IRState* p)
// rewrite the scope
gIR->scope() = IRScope(endbb,oldend);
// end the dwarf lexical block
DtoDwarfBlockEnd();
}
//////////////////////////////////////////////////////////////////////////////
@@ -512,10 +513,8 @@ void BreakStatement::toIR(IRState* p)
if (p->scopereturned())
return;
#ifndef DISABLE_DEBUG_INFO
if (global.params.symdebug)
DtoDwarfStopPoint(loc.linnum);
#endif
// emit dwarf stop point
DtoDwarfStopPoint(loc.linnum);
if (ident != 0) {
Logger::println("ident = %s", ident->toChars());
@@ -569,10 +568,8 @@ void ContinueStatement::toIR(IRState* p)
Logger::println("ContinueStatement::toIR(): %s", loc.toChars());
LOG_SCOPE;
#ifndef DISABLE_DEBUG_INFO
if (global.params.symdebug)
DtoDwarfStopPoint(loc.linnum);
#endif
// emit dwarf stop point
DtoDwarfStopPoint(loc.linnum);
if (ident != 0) {
Logger::println("ident = %s", ident->toChars());
@@ -637,19 +634,22 @@ void TryFinallyStatement::toIR(IRState* p)
Logger::println("TryFinallyStatement::toIR(): %s", loc.toChars());
LOG_SCOPE;
#ifndef DISABLE_DEBUG_INFO
if (global.params.symdebug)
DtoDwarfStopPoint(loc.linnum);
#endif
// emit dwarf stop point
DtoDwarfStopPoint(loc.linnum);
// if there's no finalbody or no body, things are simple
if (!finalbody) {
if (body)
if (body) {
DtoDwarfBlockStart(body->loc);
body->toIR(p);
DtoDwarfBlockEnd();
}
return;
}
if (!body) {
DtoDwarfBlockStart(finalbody->loc);
finalbody->toIR(p);
DtoDwarfBlockEnd();
return;
}
@@ -684,7 +684,9 @@ void TryFinallyStatement::toIR(IRState* p)
p->scope() = IRScope(trybb,finallybb);
assert(body);
DtoDwarfBlockStart(body->loc);
body->toIR(p);
DtoDwarfBlockEnd();
// terminate try BB
if (!p->scopereturned())
@@ -698,7 +700,9 @@ void TryFinallyStatement::toIR(IRState* p)
// do finally block
//
p->scope() = IRScope(finallybb,landingpadbb);
DtoDwarfBlockStart(finalbody->loc);
finalbody->toIR(p);
DtoDwarfBlockEnd();
// terminate finally
//TODO: isn't it an error to have a 'returned' finally block?
@@ -717,10 +721,8 @@ void TryCatchStatement::toIR(IRState* p)
Logger::println("TryCatchStatement::toIR(): %s", loc.toChars());
LOG_SCOPE;
#ifndef DISABLE_DEBUG_INFO
if (global.params.symdebug)
DtoDwarfStopPoint(loc.linnum);
#endif
// emit dwarf stop point
DtoDwarfStopPoint(loc.linnum);
// create basic blocks
llvm::BasicBlock* oldend = p->scopeend();
@@ -756,7 +758,9 @@ void TryCatchStatement::toIR(IRState* p)
p->scope() = IRScope(trybb,landingpadbb);
assert(body);
DtoDwarfBlockStart(body->loc);
body->toIR(p);
DtoDwarfBlockEnd();
if (!gIR->scopereturned())
llvm::BranchInst::Create(endbb, p->scopebb());
@@ -775,17 +779,13 @@ void ThrowStatement::toIR(IRState* p)
Logger::println("ThrowStatement::toIR(): %s", loc.toChars());
LOG_SCOPE;
#ifndef DISABLE_DEBUG_INFO
if (global.params.symdebug)
DtoDwarfStopPoint(loc.linnum);
#endif
// emit dwarf stop point
DtoDwarfStopPoint(loc.linnum);
assert(exp);
DValue* e = exp->toElemDtor(p);
#ifndef DISABLE_DEBUG_INFO
if (global.params.symdebug) DtoDwarfFuncEnd(gIR->func()->decl);
#endif
DtoDwarfFuncEnd(gIR->func()->decl);
llvm::Function* fn = LLVM_D_GetRuntimeFunction(gIR->module, "_d_throw_exception");
//Logger::cout() << "calling: " << *fn << '\n';
@@ -861,10 +861,8 @@ void SwitchStatement::toIR(IRState* p)
Logger::println("SwitchStatement::toIR(): %s", loc.toChars());
LOG_SCOPE;
#ifndef DISABLE_DEBUG_INFO
if (global.params.symdebug)
DtoDwarfStopPoint(loc.linnum);
#endif
// emit dwarf stop point
DtoDwarfStopPoint(loc.linnum);
llvm::BasicBlock* oldbb = gIR->scopebb();
llvm::BasicBlock* oldend = gIR->scopeend();
@@ -1041,7 +1039,9 @@ void CaseStatement::toIR(IRState* p)
p->scope() = IRScope(bodyBB, p->scopeend());
assert(statement);
DtoDwarfBlockStart(statement->loc);
statement->toIR(p);
DtoDwarfBlockEnd();
}
//////////////////////////////////////////////////////////////////////////////
@@ -1066,7 +1066,9 @@ void DefaultStatement::toIR(IRState* p)
p->scope() = IRScope(bodyBB, p->scopeend());
assert(statement);
DtoDwarfBlockStart(statement->loc);
statement->toIR(p);
DtoDwarfBlockEnd();
}
//////////////////////////////////////////////////////////////////////////////
@@ -1080,10 +1082,8 @@ void UnrolledLoopStatement::toIR(IRState* p)
if (!statements || !statements->dim)
return;
#ifndef DISABLE_DEBUG_INFO
if (global.params.symdebug)
DtoDwarfStopPoint(loc.linnum);
#endif
// start a dwarf lexical block
DtoDwarfBlockStart(loc);
// DMD doesn't fold stuff like continue/break, and since this isn't really a loop
// we have to keep track of each statement and jump to the next/end on continue/break
@@ -1139,6 +1139,9 @@ void UnrolledLoopStatement::toIR(IRState* p)
if (!p->scopereturned())
p->ir->CreateBr(endbb);
p->scope() = IRScope(endbb,oldend);
// end the dwarf lexical block
DtoDwarfBlockEnd();
}
//////////////////////////////////////////////////////////////////////////////
@@ -1148,10 +1151,8 @@ void ForeachStatement::toIR(IRState* p)
Logger::println("ForeachStatement::toIR(): %s", loc.toChars());
LOG_SCOPE;
#ifndef DISABLE_DEBUG_INFO
if (global.params.symdebug)
DtoDwarfStopPoint(loc.linnum);
#endif
// start a dwarf lexical block
DtoDwarfBlockStart(loc);
//assert(arguments->dim == 1);
assert(value != 0);
@@ -1266,6 +1267,9 @@ void ForeachStatement::toIR(IRState* p)
}
llvm::BranchInst::Create(condbb, p->scopebb());
// end the dwarf lexical block
DtoDwarfBlockEnd();
// end
p->scope() = IRScope(endbb,oldend);
}
@@ -1279,10 +1283,8 @@ void ForeachRangeStatement::toIR(IRState* p)
Logger::println("ForeachRangeStatement::toIR(): %s", loc.toChars());
LOG_SCOPE;
#ifndef DISABLE_DEBUG_INFO
if (global.params.symdebug)
DtoDwarfStopPoint(loc.linnum);
#endif
// start a dwarf lexical block
DtoDwarfBlockStart(loc);
// evaluate lwr/upr
assert(lwr->type->isintegral());
@@ -1371,6 +1373,9 @@ void ForeachRangeStatement::toIR(IRState* p)
// jump to condition
llvm::BranchInst::Create(condbb, p->scopebb());
// end the dwarf lexical block
DtoDwarfBlockEnd();
// END
p->scope() = IRScope(endbb,oldend);
}
@@ -1430,10 +1435,7 @@ void GotoStatement::toIR(IRState* p)
Logger::println("GotoStatement::toIR(): %s", loc.toChars());
LOG_SCOPE;
#ifndef DISABLE_DEBUG_INFO
if (global.params.symdebug)
DtoDwarfStopPoint(loc.linnum);
#endif
DtoDwarfStopPoint(loc.linnum);
llvm::BasicBlock* oldend = gIR->scopeend();
llvm::BasicBlock* bb = llvm::BasicBlock::Create(gIR->context(), "aftergoto", p->topfunc(), oldend);
@@ -1450,10 +1452,7 @@ void GotoDefaultStatement::toIR(IRState* p)
Logger::println("GotoDefaultStatement::toIR(): %s", loc.toChars());
LOG_SCOPE;
#ifndef DISABLE_DEBUG_INFO
if (global.params.symdebug)
DtoDwarfStopPoint(loc.linnum);
#endif
DtoDwarfStopPoint(loc.linnum);
llvm::BasicBlock* oldend = gIR->scopeend();
llvm::BasicBlock* bb = llvm::BasicBlock::Create(gIR->context(), "aftergotodefault", p->topfunc(), oldend);
@@ -1474,10 +1473,7 @@ void GotoCaseStatement::toIR(IRState* p)
Logger::println("GotoCaseStatement::toIR(): %s", loc.toChars());
LOG_SCOPE;
#ifndef DISABLE_DEBUG_INFO
if (global.params.symdebug)
DtoDwarfStopPoint(loc.linnum);
#endif
DtoDwarfStopPoint(loc.linnum);
llvm::BasicBlock* oldend = gIR->scopeend();
llvm::BasicBlock* bb = llvm::BasicBlock::Create(gIR->context(), "aftergotocase", p->topfunc(), oldend);
@@ -1501,10 +1497,7 @@ void WithStatement::toIR(IRState* p)
Logger::println("WithStatement::toIR(): %s", loc.toChars());
LOG_SCOPE;
#ifndef DISABLE_DEBUG_INFO
if (global.params.symdebug)
DtoDwarfStopPoint(loc.linnum);
#endif
DtoDwarfBlockStart(loc);
assert(exp);
@@ -1518,6 +1511,8 @@ void WithStatement::toIR(IRState* p)
if (body)
body->toIR(p);
DtoDwarfBlockEnd();
}
//////////////////////////////////////////////////////////////////////////////
@@ -1533,10 +1528,8 @@ void SynchronizedStatement::toIR(IRState* p)
Logger::println("SynchronizedStatement::toIR(): %s", loc.toChars());
LOG_SCOPE;
#ifndef DISABLE_DEBUG_INFO
if (global.params.symdebug)
DtoDwarfStopPoint(loc.linnum);
#endif
// emit dwarf stop point
DtoDwarfStopPoint(loc.linnum);
// enter lock
if (exp)
@@ -1552,7 +1545,9 @@ void SynchronizedStatement::toIR(IRState* p)
// emit body
p->func()->gen->targetScopes.push_back(IRTargetScope(this,new EnclosingSynchro(this),NULL,NULL));
DtoDwarfBlockStart(body->loc);
body->toIR(p);
DtoDwarfBlockEnd();
p->func()->gen->targetScopes.pop_back();
// exit lock
@@ -1572,10 +1567,8 @@ void VolatileStatement::toIR(IRState* p)
Logger::println("VolatileStatement::toIR(): %s", loc.toChars());
LOG_SCOPE;
#ifndef DISABLE_DEBUG_INFO
if (global.params.symdebug)
DtoDwarfStopPoint(loc.linnum);
#endif
// emit dwarf stop point
DtoDwarfStopPoint(loc.linnum);
// mark in-volatile
// FIXME

96
gen/todebug.cpp
View File

@@ -20,8 +20,6 @@
using namespace llvm::dwarf;
#ifndef DISABLE_DEBUG_INFO
//////////////////////////////////////////////////////////////////////////////////////////////////
// get the module the symbol is in, or - for template instances - the current module
@@ -44,12 +42,24 @@ static Module* getDefinedModule(Dsymbol* s)
//////////////////////////////////////////////////////////////////////////////////////////////////
static llvm::DIDescriptor getCurrentScope()
{
IrFunction *fn = gIR->func();
if (fn->diLexicalBlocks.empty()) {
assert((llvm::MDNode*)fn->diSubprogram != 0);
return fn->diSubprogram;
}
return fn->diLexicalBlocks.top();
}
//////////////////////////////////////////////////////////////////////////////////////////////////
static llvm::DIType dwarfTypeDescription_impl(Type* type, const char* c_name);
static llvm::DIType dwarfTypeDescription(Type* type, const char* c_name);
//////////////////////////////////////////////////////////////////////////////////////////////////
llvm::DIFile DtoDwarfFile(Loc loc)
static llvm::DIFile DtoDwarfFile(Loc loc)
{
llvm::SmallString<128> path(loc.filename ? loc.filename : "");
llvm::sys::fs::make_absolute(path);
@@ -307,7 +317,7 @@ static void dwarfDeclare(LLValue* var, llvm::DIVariable divar)
//////////////////////////////////////////////////////////////////////////////////////////////////
llvm::DIType dwarfArrayType(Type* type) {
static llvm::DIType dwarfArrayType(Type* type) {
LLType* T = DtoType(type);
Type* t = type->toBasetype();
@@ -363,6 +373,9 @@ static llvm::DIType dwarfTypeDescription(Type* type, const char* c_name)
void DtoDwarfLocalVariable(LLValue* ll, VarDeclaration* vd, llvm::ArrayRef<LLValue*> addr)
{
if (!global.params.symdebug)
return;
Logger::println("D to dwarf local variable");
LOG_SCOPE;
@@ -386,7 +399,7 @@ void DtoDwarfLocalVariable(LLValue* ll, VarDeclaration* vd, llvm::ArrayRef<LLVal
if (addr.empty()) {
vd->debugVariable = gIR->dibuilder.createLocalVariable(
tag, // tag
gIR->func()->diSubprogram, // context
getCurrentScope(), // scope
vd->toChars(), // name
DtoDwarfFile(vd->loc), // file
vd->loc.linnum, // line num
@@ -396,7 +409,7 @@ void DtoDwarfLocalVariable(LLValue* ll, VarDeclaration* vd, llvm::ArrayRef<LLVal
} else {
vd->debugVariable = gIR->dibuilder.createComplexVariable(
tag, // tag
gIR->func()->diSubprogram, // context
getCurrentScope(), // scope
vd->toChars(), // name
DtoDwarfFile(vd->loc), // file
vd->loc.linnum, // line num
@@ -414,6 +427,9 @@ void DtoDwarfLocalVariable(LLValue* ll, VarDeclaration* vd, llvm::ArrayRef<LLVal
void DtoDwarfCompileUnit(Module* m)
{
if (!global.params.symdebug)
return;
Logger::println("D to dwarf compile_unit");
LOG_SCOPE;
@@ -445,6 +461,9 @@ void DtoDwarfCompileUnit(Module* m)
llvm::DISubprogram DtoDwarfSubProgram(FuncDeclaration* fd)
{
if (!global.params.symdebug)
return llvm::DISubprogram();
Logger::println("D to dwarf subprogram");
LOG_SCOPE;
@@ -471,6 +490,9 @@ llvm::DISubprogram DtoDwarfSubProgram(FuncDeclaration* fd)
llvm::DISubprogram DtoDwarfSubProgramInternal(const char* prettyname, const char* mangledname)
{
if (!global.params.symdebug)
return llvm::DISubprogram();
Logger::println("D to dwarf subprogram");
LOG_SCOPE;
@@ -493,6 +515,9 @@ llvm::DISubprogram DtoDwarfSubProgramInternal(const char* prettyname, const char
llvm::DIGlobalVariable DtoDwarfGlobalVariable(LLGlobalVariable* ll, VarDeclaration* vd)
{
if (!global.params.symdebug)
return llvm::DIGlobalVariable();
Logger::println("D to dwarf global_variable");
LOG_SCOPE;
@@ -504,22 +529,23 @@ llvm::DIGlobalVariable DtoDwarfGlobalVariable(LLGlobalVariable* ll, VarDeclarati
void DtoDwarfFuncStart(FuncDeclaration* fd)
{
if (!global.params.symdebug)
return;
Logger::println("D to dwarf funcstart");
LOG_SCOPE;
assert((llvm::MDNode*)fd->ir.irFunc->diSubprogram != 0);
DtoDwarfStopPoint(fd->loc.linnum);
/* fd->ir.irFunc->diLexicalBlock = gIR->difactory.CreateLexicalBlock(
fd->ir.irFunc->diSubprogram, // context
DtoDwarfFile(fd->loc, DtoDwarfCompileUnit(getDefinedModule(fd))), // file
fd->loc.linnum
);*/
}
//////////////////////////////////////////////////////////////////////////////////////////////////
void DtoDwarfFuncEnd(FuncDeclaration* fd)
{
if (!global.params.symdebug)
return;
Logger::println("D to dwarf funcend");
LOG_SCOPE;
@@ -528,11 +554,49 @@ void DtoDwarfFuncEnd(FuncDeclaration* fd)
//////////////////////////////////////////////////////////////////////////////////////////////////
void DtoDwarfBlockStart(Loc loc)
{
if (!global.params.symdebug)
return;
Logger::println("D to dwarf block start");
LOG_SCOPE;
llvm::DILexicalBlock block = gIR->dibuilder.createLexicalBlock(
getCurrentScope(), // scope
DtoDwarfFile(loc), // file
loc.linnum, // line
0 // column
);
gIR->func()->diLexicalBlocks.push(block);
DtoDwarfStopPoint(loc.linnum);
}
//////////////////////////////////////////////////////////////////////////////////////////////////
void DtoDwarfBlockEnd()
{
if (!global.params.symdebug)
return;
Logger::println("D to dwarf block end");
LOG_SCOPE;
IrFunction *fn = gIR->func();
assert(!fn->diLexicalBlocks.empty());
fn->diLexicalBlocks.pop();
}
//////////////////////////////////////////////////////////////////////////////////////////////////
void DtoDwarfStopPoint(unsigned ln)
{
if (!global.params.symdebug)
return;
Logger::println("D to dwarf stoppoint at line %u", ln);
LOG_SCOPE;
llvm::DebugLoc loc = llvm::DebugLoc::get(ln, 0, gIR->func()->diSubprogram);
llvm::DebugLoc loc = llvm::DebugLoc::get(ln, 0, getCurrentScope());
gIR->ir->SetCurrentDebugLocation(loc);
}
@@ -540,6 +604,9 @@ void DtoDwarfStopPoint(unsigned ln)
void DtoDwarfValue(LLValue *val, VarDeclaration* vd)
{
if (!global.params.symdebug || !vd->debugVariable)
return;
llvm::Instruction *instr = gIR->dibuilder.insertDbgValueIntrinsic(val, 0, vd->debugVariable, gIR->scopebb());
instr->setDebugLoc(gIR->ir->getCurrentDebugLocation());
}
@@ -548,7 +615,8 @@ void DtoDwarfValue(LLValue *val, VarDeclaration* vd)
void DtoDwarfModuleEnd()
{
if (!global.params.symdebug)
return;
gIR->dibuilder.finalize();
}
#endif

22
gen/todebug.h
View File

@@ -1,8 +1,6 @@
#ifndef LDC_GEN_TODEBUG_H
#define LDC_GEN_TODEBUG_H
#ifndef DISABLE_DEBUG_INFO
#include "gen/tollvm.h"
#include "gen/irstate.h"
@@ -31,6 +29,8 @@ llvm::DISubprogram DtoDwarfSubProgramInternal(const char* prettyname, const char
void DtoDwarfFuncStart(FuncDeclaration* fd);
void DtoDwarfFuncEnd(FuncDeclaration* fd);
void DtoDwarfBlockStart(Loc loc);
void DtoDwarfBlockEnd();
void DtoDwarfStopPoint(unsigned ln);
@@ -57,6 +57,9 @@ void DtoDwarfModuleEnd();
template<typename T>
void dwarfOpOffset(T &addr, LLStructType *type, int index)
{
if (!global.params.symdebug)
return;
uint64_t offset = gTargetData->getStructLayout(type)->getElementOffset(index);
LLType *int64Ty = LLType::getInt64Ty(gIR->context());
addr.push_back(LLConstantInt::get(int64Ty, llvm::DIBuilder::OpPlus));
@@ -66,19 +69,22 @@ void dwarfOpOffset(T &addr, LLStructType *type, int index)
template<typename T>
void dwarfOpOffset(T &addr, LLValue *val, int index)
{
LLStructType *type = isaStruct(val->getType()->getContainedType(0));
assert(type);
dwarfOpOffset(addr, type, index);
if (!global.params.symdebug)
return;
LLStructType *type = isaStruct(val->getType()->getContainedType(0));
assert(type);
dwarfOpOffset(addr, type, index);
}
template<typename T>
void dwarfOpDeref(T &addr)
{
if (!global.params.symdebug)
return;
LLType *int64Ty = LLType::getInt64Ty(gIR->context());
addr.push_back(LLConstantInt::get(int64Ty, llvm::DIBuilder::OpDeref));
}
#endif // DISABLE_DEBUG_INFO
#endif // LDC_GEN_TODEBUG_H

23
gen/toobj.cpp
View File

@@ -115,11 +115,8 @@ llvm::Module* Module::genLLVMModule(llvm::LLVMContext& context, Ir* sir)
// allocate the target abi
gABI = TargetABI::getTarget();
#ifndef DISABLE_DEBUG_INFO
// debug info
if (global.params.symdebug)
DtoDwarfCompileUnit(this);
#endif
DtoDwarfCompileUnit(this);
// handle invalid 'objectø module
if (!ClassDeclaration::object) {
@@ -158,11 +155,8 @@ llvm::Module* Module::genLLVMModule(llvm::LLVMContext& context, Ir* sir)
}
}
// finilize debugging
#ifndef DISABLE_DEBUG_INFO
if (global.params.symdebug)
DtoDwarfModuleEnd();
#endif
// finilize debug info
DtoDwarfModuleEnd();
// generate ModuleInfo
genmoduleinfo();
@@ -355,10 +349,7 @@ static llvm::Function* build_module_function(const std::string &name, const std:
IRBuilder<> builder(bb);
// debug info
#ifndef DISABLE_DEBUG_INFO
if(global.params.symdebug)
DtoDwarfSubProgramInternal(name.c_str(), name.c_str());
#endif
DtoDwarfSubProgramInternal(name.c_str(), name.c_str());
// Call ctor's
typedef std::list<FuncDeclaration*>::const_iterator FuncIterator;
@@ -479,11 +470,7 @@ static LLFunction* build_module_reference_and_ctor(LLConstant* moduleinfo)
IRBuilder<> builder(bb);
// debug info
#ifndef DISABLE_DEBUG_INFO
llvm::DISubprogram subprog;
if(global.params.symdebug)
subprog = DtoDwarfSubProgramInternal(fname.c_str(), fname.c_str());
#endif
llvm::DISubprogram subprog = DtoDwarfSubProgramInternal(fname.c_str(), fname.c_str());
// get current beginning
LLValue* curbeg = builder.CreateLoad(mref, "current");

2
ir/irfunction.h
View File

@@ -99,7 +99,7 @@ struct IrFunction : IrBase
llvm::Value* _argptr;
llvm::DISubprogram diSubprogram;
llvm::DILexicalBlock diLexicalBlock;
std::stack<llvm::DILexicalBlock> diLexicalBlocks;
};
#endif

3
ir/irlandingpad.cpp
View File

@@ -5,6 +5,7 @@
#include "gen/logger.h"
#include "gen/classes.h"
#include "gen/llvmhelpers.h"
#include "gen/todebug.h"
#include "ir/irlandingpad.h"
IRLandingPadInfo::IRLandingPadInfo(Catch* catchstmt, llvm::BasicBlock* end)
@@ -12,6 +13,7 @@ IRLandingPadInfo::IRLandingPadInfo(Catch* catchstmt, llvm::BasicBlock* end)
{
target = llvm::BasicBlock::Create(gIR->context(), "catch", gIR->topfunc(), end);
gIR->scope() = IRScope(target,end);
DtoDwarfBlockStart(catchstmt->loc);
// assign storage to catch var
if(catchstmt->var) {
@@ -50,6 +52,7 @@ IRLandingPadInfo::IRLandingPadInfo(Catch* catchstmt, llvm::BasicBlock* end)
catchType = catchstmt->type->toBasetype()->isClassHandle();
assert(catchType);
catchType->codegen(Type::sir);
DtoDwarfBlockEnd();
}
IRLandingPadInfo::IRLandingPadInfo(Statement* finallystmt)