Changeset 1650:40bd4a0d4870

dmd/expression.h

--- Revision 1630:44b145be2ef5
+++ Revision 1650:40bd4a0d4870
 struct TemplateInstance;
 struct TemplateDeclaration;
 struct ClassDeclaration;
 struct HdrGenState;
 struct BinExp;
+struct AssignExp;
 struct InterState;
 struct OverloadSet;
 enum TOK;
 …
     virtual DValue* toElem(IRState* irs);
     virtual llvm::Constant *toConstElem(IRState *irs);
     virtual void cacheLvalue(IRState* irs);
     llvm::Value* cachedLvalue;
+    virtual AssignExp* isAssignExp() { return NULL; }
 #endif
 };
 struct IntegerExp : Expression
+{
 …
 #endif
 #if IN_LLVM
     DValue* toElem(IRState* irs);
 #endif
+    AssignExp* isAssignExp() { return this; }
 };
 #if IN_DMD
 #define ASSIGNEXP_TOELEM    elem *toElem(IRState *irs);
 #elif IN_LLVM

dmd/statement.h

--- Revision 1630:44b145be2ef5
+++ Revision 1650:40bd4a0d4870
     virtual DeclarationStatement *isDeclarationStatement() { return NULL; }
     virtual CompoundStatement *isCompoundStatement() { return NULL; }
     virtual ReturnStatement *isReturnStatement() { return NULL; }
     virtual IfStatement *isIfStatement() { return NULL; }
     virtual CaseStatement* isCaseStatement() { return NULL; }
+    virtual LabelStatement* isLabelStatement() { return NULL; }
 #if IN_LLVM
     virtual void toNakedIR(IRState *irs);
     virtual AsmBlockStatement* endsWithAsm();
 #endif
 …
     void toIR(IRState *irs);
     // LDC
     bool asmLabel;       // for labels inside inline assembler
     void toNakedIR(IRState *irs);
+    LabelStatement* isLabelStatement() { return this; }
 };
 struct LabelDsymbol : Dsymbol
+{
     LabelStatement *statement;

gen/arrays.cpp

--- Revision 1643:8f121883bce8
+++ Revision 1650:40bd4a0d4870
             mismatch = true;
+    }
     LLConstant* constarr;
     if (mismatch)
-        constarr = LLConstantStruct::get(gIR->context(), initvals);
+        constarr = LLConstantStruct::get(gIR->context(), initvals, false); // FIXME should this pack?
     else
         constarr = LLConstantArray::get(LLArrayType::get(llelemty, arrlen), initvals);
 //     std::cout << "constarr: " << *constarr << std::endl;
 …
 //////////////////////////////////////////////////////////////////////////////////////////
 LLConstant* DtoConstSlice(LLConstant* dim, LLConstant* ptr)
+{
     LLConstant* values[2] = { dim, ptr };
-    return LLConstantStruct::get(gIR->context(), values, 2);
+    return LLConstantStruct::get(gIR->context(), values, 2, false);
+}
 //////////////////////////////////////////////////////////////////////////////////////////
 static bool isInitialized(Type* et) {
     // Strip static array types from element type

gen/asmstmt.cpp

--- Revision 1571:8d086d552909
+++ Revision 1650:40bd4a0d4870
     // get asm block
     IRAsmBlock* asmblock = irs->asmBlock;
     assert(asmblock);
+    #ifndef DISABLE_DEBUG_INFO
     // debug info
     if (global.params.symdebug)
         DtoDwarfStopPoint(loc.linnum);
+    #endif
     if (! asmcode)
     return;
     static std::string i_cns = "i";
 …
         default: assert(0); break;
+        }
         break;
     case Arg_FrameRelative:
 // FIXME
-llvm::cout << "asm fixme Arg_FrameRelative" << std::endl;
+assert(0 && "asm fixme Arg_FrameRelative");
+assert(0);
 /*      if (arg->expr->op == TOKvar)
         arg_val = ((VarExp *) arg->expr)->var->toSymbol()->Stree;
         else
         assert(0);
         if ( getFrameRelativeValue(arg_val, & var_frame_offset) ) {
 …
         if (arg->mode != Mode_Input)
         clobbers_mem = true;
         break;*/
     case Arg_LocalSize:
 // FIXME
-llvm::cout << "asm fixme Arg_LocalSize" << std::endl;
+assert(0 && "asm fixme Arg_LocalSize");
+assert(0);
 /*      var_frame_offset = cfun->x_frame_offset;
         if (var_frame_offset < 0)
         var_frame_offset = - var_frame_offset;
         arg_val = irs->integerConstant( var_frame_offset );*/
         goto do_integer;

gen/cl_helpers.cpp

Revision 1103:b30fe7e1dbb9		Revision 1650:40bd4a0d4870
15	if (isupper(c))	15	if (isupper(c))
16	return tolower(c);	16	return tolower(c);
17	return c;	17	return c;
18	}	18	}
19		19
20	bool FlagParser::parse(cl::Option &O, ~~const char *ArgName, const std::string &~~Arg, bool &Val) {	20	bool FlagParser::parse(cl::Option &O, llvm::StringRef ArgName, llvm::StringRef Arg, bool &Val) {
21	// Make a std::string out of it to make comparisons easier	21	// Make a std::string out of it to make comparisons easier
22	// (and avoid repeated conversion)	22	// (and avoid repeated conversion)
23	~~std::string~~ argname = ArgName;	23	llvm::StringRef argname = ArgName;
24		24
25	typedef std::vector<std::pair<std::string, bool> >::iterator It;	25	typedef std::vector<std::pair<std::string, bool> >::iterator It;
26	for (It I = switches.begin(), E = switches.end(); I != E; ++I) {	26	for (It I = switches.begin(), E = switches.end(); I != E; ++I) {
27	~~std::string~~ name = I->first;	27	llvm::StringRef name = I->first;
28	if (name == argname	28	if (name == argname
29	\|\| (name.~~length() < argname.length~~()	29	\|\| (name.size() < argname.size()
30	&& argname.substr(0, name.~~length~~()) == name	30	&& argname.substr(0, name.size()) == name
31	&& argname[name.~~length~~()] == '=')) {	31	&& argname[name.size()] == '=')) {
32		32
33	if (!cl::parser<bool>::parse(O, ArgName, Arg, Val)) {	33	if (!cl::parser<bool>::parse(O, ArgName, Arg, Val)) {
34	Val = (Val == I->second);	34	Val = (Val == I->second);
35	return false;	35	return false;
36	}	36	}
37	// Invalid option value	37	// Invalid option value
…		…
39	}	39	}
40	}	40	}
41	return true;	41	return true;
42	}	42	}
43		43
44	void FlagParser::getExtraOptionNames(~~std::vector~~<const char*> &Names) {	44	void FlagParser::getExtraOptionNames(llvm::SmallVectorImpl<const char*> &Names) {
45	typedef std::vector<std::pair<std::string, bool> >::iterator It;	45	typedef std::vector<std::pair<std::string, bool> >::iterator It;
46	for (It I = switches.begin() + 1, E = switches.end(); I != E; ++I) {	46	for (It I = switches.begin() + 1, E = switches.end(); I != E; ++I) {
47	Names.push_back(I->first.~~c_str~~());	47	Names.push_back(I->first.data());
48	}	48	}
49	}	49	}
50		50
51		51
52	MultiSetter::MultiSetter(bool invert, bool* p, ...) {	52	MultiSetter::MultiSetter(bool invert, bool* p, ...) {

gen/cl_helpers.h

--- Revision 1200:3171f67ad006
+++ Revision 1650:40bd4a0d4870
         void initialize(Opt &O) {
             std::string Name = O.ArgStr;
             switches.push_back(make_pair("enable-" + Name, true));
             switches.push_back(make_pair("disable-" + Name, false));
             // Replace <foo> with -enable-<foo>
-            O.ArgStr = switches[0].first.c_str();
+            O.ArgStr = switches[0].first.data();
+        }
-        bool parse(cl::Option &O, const char *ArgName, const std::string &ArgValue, bool &Val);
+        bool parse(cl::Option &O, llvm::StringRef ArgName, llvm::StringRef ArgValue, bool &Val);
-        void getExtraOptionNames(std::vector<const char*> &Names);
+        void getExtraOptionNames(llvm::SmallVectorImpl<const char*> &Names);
     };
     /// Helper class for options that set multiple flags
     class MultiSetter {
         std::vector<bool*> locations;

gen/configfile.cpp

--- Revision 1537:ee6b20e7aedb
+++ Revision 1650:40bd4a0d4870
         std::cerr << "Error failed to locate the configuration file: " << filename << std::endl;
         return false;
+    }
     // save config file path for -v output
-    pathstr = p.toString();
+    pathstr = p.str();
     try
+    {
         // read the cfg
         cfg->readFile(p.c_str());

gen/functions.cpp

--- Revision 1607:207a8a438dea
+++ Revision 1650:40bd4a0d4870
+    {
         DtoDefineNakedFunction(fd);
         return;
+    }
+    #ifndef DISABLE_DEBUG_INFO
     // debug info
-    if (global.params.symdebug) {
+    if (global.params.symdebug)
         fd->ir.irFunc->diSubprogram = DtoDwarfSubProgram(fd);
+    #endif
     Type* t = fd->type->toBasetype();
     TypeFunction* f = (TypeFunction*)t;
     assert(f->irtype);
 …
     // create alloca point
     // this gets erased when the function is complete, so alignment etc does not matter at all
     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
     // this hack makes sure the frame pointer elimination optimization is disabled.
     // this this eliminates a bunch of inline asm related issues.
     if (fd->inlineAsm)
+    {
 …
         assert(!fd->vthis->ir.irLocal);
         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
     #if DMDV1
         if (fd->vthis->nestedref)
+        {
             fd->nestedVars.insert(fd->vthis);
 …
                 // set the arg var value to the alloca
                 irloc->value = mem;
+            }
+            #ifndef DISABLE_DEBUG_INFO
             if (global.params.symdebug && !(isaArgument(irloc->value) && !isaArgument(irloc->value)->hasByValAttr()) && !refout)
                 DtoDwarfLocalVariable(irloc->value, vd);
+            #endif
+        }
+    }
 // need result variable? (nested)
 #if DMDV1
 …
     } else if (!gIR->scopereturned()) {
         // llvm requires all basic blocks to end with a TerminatorInst but DMD does not put a return statement
         // 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
         if (func->getReturnType() == LLType::getVoidTy(gIR->context())) {
             llvm::ReturnInst::Create(gIR->context(), gIR->scopebb());
+        }
         else if (!fd->isMain()) {
             AsmBlockStatement* asmb = fd->fbody->endsWithAsm();

gen/linker.cpp

--- Revision 1600:a60e7d1ce3ee
+++ Revision 1650:40bd4a0d4870
     std::string errstr;
     // find gcc for linking
     llvm::sys::Path gcc = getGcc();
     // get a string version for argv[0]
-    std::string gccStr = gcc.toString();
+    const char* gccStr = gcc.c_str();
     // build arguments
     std::vector<const char*> args;
     // first the program name ??
-    args.push_back(gccStr.c_str());
+    args.push_back(gccStr);
     // object files
     for (int i = 0; i < global.params.objfiles->dim; i++)
+    {
         char *p = (char *)global.params.objfiles->data[i];
 …
     std::vector<const char*>::const_iterator I = args.begin(), E = args.end();
     Stream logstr = Logger::cout();
     for (; I != E; ++I)
         if (*I)
             logstr << "'" << *I << "'" << " ";
-    logstr << "\n" << std::flush;
+    logstr << "\n"; // FIXME where's flush ?
     // terminate args list
     args.push_back(NULL);
 …
     assert(gExePath.isValid());
     // build arguments
     std::vector<const char*> args;
     // args[0] should be the name of the executable
-    args.push_back(gExePath.toString().c_str());
+    args.push_back(gExePath.c_str());
     // Skip first argument to -run; it's a D source file.
     for (size_t i = 1, length = opts::runargs.size(); i < length; i++)
+    {
         args.push_back(opts::runargs[i].c_str());
+    }

gen/llvmhelpers.cpp

--- Revision 1643:8f121883bce8
+++ Revision 1650:40bd4a0d4870
     args.push_back(c);
     // call
     gIR->CreateCallOrInvoke(fn, args.begin(), args.end());
+    #ifndef DISABLE_DEBUG_INFO
     // end debug info
     if (global.params.symdebug)
         DtoDwarfFuncEnd(gIR->func()->decl);
+    #endif
     // after assert is always unreachable
     gIR->ir->CreateUnreachable();
+}
 …
 void DtoEnclosingHandlers(Loc loc, Statement* target)
+{
     // labels are a special case: they are not required to enclose the current scope
     // for them we use the enclosing scope handler as a reference point
-    LabelStatement* lblstmt = dynamic_cast<LabelStatement*>(target);
+    LabelStatement* lblstmt = target ? target->isLabelStatement() : 0;
     if (lblstmt)
         target = lblstmt->enclosingScopeExit;
     // figure out up until what handler we need to emit
     FuncGen::TargetScopeVec::reverse_iterator targetit = gIR->func()->gen->targetScopes.rbegin();
 …
+    {
         return new DNullValue(type, LLConstant::getNullValue(lltype));
+    }
     // unknown
-    llvm::cout << "unsupported: null value for " << type->toChars() << '\n';
+    error("unsupported: null value for %s", type->toChars());
     assert(0);
     return 0;
+}
 …
 #endif
+        }
         gvar->setInitializer(initVal);
+        #ifndef DISABLE_DEBUG_INFO
         // do debug info
         if (global.params.symdebug)
+        {
             LLGlobalVariable* gv = DtoDwarfGlobalVariable(gvar, vd).getGV();
             // keep a reference so GDCE doesn't delete it !
             gIR->usedArray.push_back(llvm::ConstantExpr::getBitCast(gv, getVoidPtrType()));
+        }
+        #endif
+    }
+}
 /****************************************************************************************/
 /*////////////////////////////////////////////////////////////////////////////////////////
 …
                     vd->ir.irLocal = new IrLocal(vd);
                 ExpInitializer* ex = vd->init->isExpInitializer();
                 assert(ex && "ref vars must have expression initializer");
                 assert(ex->exp);
-                AssignExp* as = dynamic_cast<AssignExp*>(ex->exp);
+                AssignExp* as = ex->exp->isAssignExp();
                 assert(as && "ref vars must be initialized by an assign exp");
                 vd->ir.irLocal->value = as->e2->toElem(gIR)->getLVal();
+            }
             // referenced by nested delegate?
 …
                     allocainst = DtoAlloca(vd->type, vd->toChars());
                 //allocainst->setAlignment(vd->type->alignsize()); // TODO
                 vd->ir.irLocal->value = allocainst;
+                #ifndef DISABLE_DEBUG_INFO
                 if (global.params.symdebug)
                     DtoDwarfLocalVariable(allocainst, vd);
+                #endif
+            }
             else
+            {
                 assert(vd->ir.irLocal->value);
+            }
 …
     // alloca if necessary
     LLValue* allocaval = NULL;
     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
+    }
     // referenced by nested function?
 #if DMDV2
     if (var->nestedrefs.dim)
 #else
     if (var->nestedref)

gen/llvmhelpers.h

--- Revision 1643:8f121883bce8
+++ Revision 1650:40bd4a0d4870
 ////////////////////////////////////////////
 // gen/tocall.cpp stuff below
 ////////////////////////////////////////////
 /// convert DMD calling conv to LLVM
-unsigned DtoCallingConv(Loc loc, LINK l);
+llvm::CallingConv::ID DtoCallingConv(Loc loc, LINK l);
 ///
 TypeFunction* DtoTypeFunction(DValue* fnval);
 ///

gen/logger.cpp

--- Revision 1502:2292878925f4
+++ Revision 1650:40bd4a0d4870
 #include "llvm/Support/CommandLine.h"
 #include "llvm/GlobalValue.h"
 #include "llvm/Support/Casting.h"
-#include "llvm/Support/raw_ostream.h"
+#include "llvm/Support/raw_os_ostream.h"
 #include "llvm/Assembly/Writer.h"
 #include "gen/logger.h"
 #include "gen/irstate.h"
 …
 void Stream::writeValue(std::ostream& OS, const llvm::Value& V) {
     // Constants don't always get their types pretty-printed.
     // (Only treat non-global constants like this, so that e.g. global variables
     // still get their initializers printed)
+    llvm::raw_os_ostream raw(OS);
     if (llvm::isa<llvm::Constant>(V) && !llvm::isa<llvm::GlobalValue>(V))
-        llvm::WriteAsOperand(OS, &V, true, gIR->module);
+        llvm::WriteAsOperand(raw, &V, true, gIR->module);
     else
-        OS << V;
+        V.print(raw);
+}
 namespace Logger
+{
     static std::string indent_str;

gen/logger.h

--- Revision 1502:2292878925f4
+++ Revision 1650:40bd4a0d4870
 public:
     Stream() : OS(0) {}
     Stream(std::ostream* S) : OS(S) {}
     Stream(std::ostream& S) : OS(&S) {}
+    /*
     Stream operator << (std::ios_base &(*Func)(std::ios_base&)) {
       if (OS) *OS << Func;
       return *this;
+    }
+    */
     Stream operator << (std::ostream &(*Func)(std::ostream&)) {
-      if (OS) *OS << Func;
+      if (OS) Func(*OS);
       return *this;
+    }
     template<typename Ty>
     Stream& operator << (const Ty& Thing) {

gen/main.cpp

--- Revision 1645:1d2d1aa16841
+++ Revision 1650:40bd4a0d4870
         for (unsigned i = 0; i != mAttrs.size(); ++i)
         Features.AddFeature(mAttrs[i]);
         FeaturesStr = Features.getString();
+    }
-    std::auto_ptr<llvm::TargetMachine> target(theTarget->createTargetMachine(triple, FeaturesStr));
+    // FIXME
-    assert(target.get() && "Could not allocate target machine!");
+    //std::auto_ptr<llvm::TargetMachine> target(theTarget->createTargetMachine(triple, FeaturesStr));
-    gTargetMachine = target.get();
+    //assert(target.get() && "Could not allocate target machine!");
-    gTargetData = gTargetMachine->getTargetData();
+    //gTargetMachine = target.get();
+    llvm::TargetMachine* target = theTarget->createTargetMachine(triple, FeaturesStr);
+    gTargetMachine = target;
+    gTargetData = target->getTargetData();
     // get final data layout
     std::string datalayout = gTargetData->getStringRepresentation();
     global.params.dataLayout = datalayout.c_str();

gen/optimizer.cpp

--- Revision 1576:4551475bc6b6
+++ Revision 1650:40bd4a0d4870
     // -O1
     if (optimizeLevel >= 1)
+    {
         //addPass(pm, createStripDeadPrototypesPass());
         addPass(pm, createGlobalDCEPass());
-        addPass(pm, createRaiseAllocationsPass());
+        addPass(pm, createPromoteMemoryToRegisterPass());
         addPass(pm, createCFGSimplificationPass());
         if (optimizeLevel == 1)
             addPass(pm, createPromoteMemoryToRegisterPass());
         else
             addPass(pm, createScalarReplAggregatesPass());
 …
         addPass(pm, createInstructionCombiningPass());
         addPass(pm, createJumpThreadingPass());
         addPass(pm, createCFGSimplificationPass());
         addPass(pm, createScalarReplAggregatesPass());
         addPass(pm, createInstructionCombiningPass());
-        addPass(pm, createCondPropagationPass());
+        addPass(pm, createConstantPropagationPass());
         addPass(pm, createReassociatePass());
         addPass(pm, createLoopRotatePass());
         addPass(pm, createLICMPass());
         addPass(pm, createLoopUnswitchPass());
 …
         addPass(pm, createGVNPass());
         addPass(pm, createMemCpyOptPass());
         addPass(pm, createSCCPPass());
         addPass(pm, createInstructionCombiningPass());
-        addPass(pm, createCondPropagationPass());
+        addPass(pm, createConstantPropagationPass());
         addPass(pm, createDeadStoreEliminationPass());
         addPass(pm, createAggressiveDCEPass());
         addPass(pm, createCFGSimplificationPass());
         addPass(pm, createDeadTypeEliminationPass());

gen/passes/SimplifyDRuntimeCalls.cpp

--- Revision 1571:8d086d552909
+++ Revision 1650:40bd4a0d4870
 #define DEBUG_TYPE "simplify-drtcalls"
 #include "Passes.h"
+#include "llvm/Function.h"
 #include "llvm/Pass.h"
 #include "llvm/Intrinsics.h"
 #include "llvm/Support/IRBuilder.h"
 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/ValueTracking.h"

gen/statements.cpp

--- Revision 1647:638a823ace45
+++ Revision 1650:40bd4a0d4870
 void ReturnStatement::toIR(IRState* p)
+{
     Logger::println("ReturnStatement::toIR(): %s", loc.toChars());
     LOG_SCOPE;
-    if (global.params.symdebug)
+    #ifndef DISABLE_DEBUG_INFO
-        DtoDwarfStopPoint(loc.linnum);
+    if (global.params.symdebug)
+        DtoDwarfStopPoint(loc.linnum);
+    #endif
     // is there a return value expression?
     if (exp || (!exp && (p->topfunc() == p->mainFunc)) )
+    {
         // if the functions return type is void this means that
         // we are returning through a pointer argument
 …
             DtoAssign(loc, rvar, e);
             // emit scopes
             DtoEnclosingHandlers(loc, NULL);
+            #ifndef DISABLE_DEBUG_INFO
             // emit dbg end function
             if (global.params.symdebug) DtoDwarfFuncEnd(f->decl);
+            #endif
             // emit ret
             llvm::ReturnInst::Create(gIR->context(), p->scopebb());
+        }
 …
                     Logger::cout() << "return value after cast: " << *v << '\n';
+            }
             DtoEnclosingHandlers(loc, NULL);
+            #ifndef DISABLE_DEBUG_INFO
             if (global.params.symdebug) DtoDwarfFuncEnd(p->func()->decl);
+            #endif
             llvm::ReturnInst::Create(gIR->context(), v, p->scopebb());
+        }
+    }
     // no return value expression means it's a void function
     else
+    {
         assert(p->topfunc()->getReturnType() == LLType::getVoidTy(gIR->context()));
         DtoEnclosingHandlers(loc, NULL);
+        #ifndef DISABLE_DEBUG_INFO
         if (global.params.symdebug) DtoDwarfFuncEnd(p->func()->decl);
+        #endif
         llvm::ReturnInst::Create(gIR->context(), p->scopebb());
+    }
     // the return terminated this basicblock, start a new one
     llvm::BasicBlock* oldend = gIR->scopeend();
 …
 void ExpStatement::toIR(IRState* p)
+{
     Logger::println("ExpStatement::toIR(): %s", loc.toChars());
     LOG_SCOPE;
-    if (global.params.symdebug)
+    #ifndef DISABLE_DEBUG_INFO
-        DtoDwarfStopPoint(loc.linnum);
+    if (global.params.symdebug)
+        DtoDwarfStopPoint(loc.linnum);
+    #endif
     if (exp) {
         if (global.params.llvmAnnotate)
             DtoAnnotation(exp->toChars());
         elem* e;
 …
 void IfStatement::toIR(IRState* p)
+{
     Logger::println("IfStatement::toIR(): %s", loc.toChars());
     LOG_SCOPE;
-    if (global.params.symdebug)
+    #ifndef DISABLE_DEBUG_INFO
-        DtoDwarfStopPoint(loc.linnum);
+    if (global.params.symdebug)
+        DtoDwarfStopPoint(loc.linnum);
+    #endif
     if (match)
         DtoRawVarDeclaration(match);
     DValue* cond_e = condition->toElem(p);
 …
 void WhileStatement::toIR(IRState* p)
+{
     Logger::println("WhileStatement::toIR(): %s", loc.toChars());
     LOG_SCOPE;
-    if (global.params.symdebug)
+    #ifndef DISABLE_DEBUG_INFO
-        DtoDwarfStopPoint(loc.linnum);
+    if (global.params.symdebug)
+        DtoDwarfStopPoint(loc.linnum);
+    #endif
     // create while blocks
     llvm::BasicBlock* oldend = gIR->scopeend();
     llvm::BasicBlock* whilebb = llvm::BasicBlock::Create(gIR->context(), "whilecond", gIR->topfunc(), oldend);
     llvm::BasicBlock* whilebodybb = llvm::BasicBlock::Create(gIR->context(), "whilebody", gIR->topfunc(), oldend);
 …
 void DoStatement::toIR(IRState* p)
+{
     Logger::println("DoStatement::toIR(): %s", loc.toChars());
     LOG_SCOPE;
-    if (global.params.symdebug)
+    #ifndef DISABLE_DEBUG_INFO
-        DtoDwarfStopPoint(loc.linnum);
+    if (global.params.symdebug)
+        DtoDwarfStopPoint(loc.linnum);
+    #endif
     // create while blocks
     llvm::BasicBlock* oldend = gIR->scopeend();
     llvm::BasicBlock* dowhilebb = llvm::BasicBlock::Create(gIR->context(), "dowhile", gIR->topfunc(), oldend);
     llvm::BasicBlock* condbb = llvm::BasicBlock::Create(gIR->context(), "dowhilecond", gIR->topfunc(), oldend);
 …
 void ForStatement::toIR(IRState* p)
+{
     Logger::println("ForStatement::toIR(): %s", loc.toChars());
     LOG_SCOPE;
-    if (global.params.symdebug)
+    #ifndef DISABLE_DEBUG_INFO
-        DtoDwarfStopPoint(loc.linnum);
+    if (global.params.symdebug)
+        DtoDwarfStopPoint(loc.linnum);
+    #endif
     // create for blocks
     llvm::BasicBlock* oldend = gIR->scopeend();
     llvm::BasicBlock* forbb = llvm::BasicBlock::Create(gIR->context(), "forcond", gIR->topfunc(), oldend);
     llvm::BasicBlock* forbodybb = llvm::BasicBlock::Create(gIR->context(), "forbody", gIR->topfunc(), oldend);
 …
     // don't emit two terminators in a row
     // happens just before DMD generated default statements if the last case terminates
     if (p->scopereturned())
         return;
-    if (global.params.symdebug)
+    #ifndef DISABLE_DEBUG_INFO
-        DtoDwarfStopPoint(loc.linnum);
+    if (global.params.symdebug)
+        DtoDwarfStopPoint(loc.linnum);
+    #endif
     if (ident != 0) {
         Logger::println("ident = %s", ident->toChars());
         DtoEnclosingHandlers(loc, target);
 …
 void ContinueStatement::toIR(IRState* p)
+{
     Logger::println("ContinueStatement::toIR(): %s", loc.toChars());
     LOG_SCOPE;
-    if (global.params.symdebug)
+    #ifndef DISABLE_DEBUG_INFO
-        DtoDwarfStopPoint(loc.linnum);
+    if (global.params.symdebug)
+        DtoDwarfStopPoint(loc.linnum);
+    #endif
     if (ident != 0) {
         Logger::println("ident = %s", ident->toChars());
         DtoEnclosingHandlers(loc, target);
 …
 void TryFinallyStatement::toIR(IRState* p)
+{
     Logger::println("TryFinallyStatement::toIR(): %s", loc.toChars());
     LOG_SCOPE;
-    if (global.params.symdebug)
+    #ifndef DISABLE_DEBUG_INFO
-        DtoDwarfStopPoint(loc.linnum);
+    if (global.params.symdebug)
+        DtoDwarfStopPoint(loc.linnum);
+    #endif
     // if there's no finalbody or no body, things are simple
     if (!finalbody) {
         if (body)
             body->toIR(p);
 …
 void TryCatchStatement::toIR(IRState* p)
+{
     Logger::println("TryCatchStatement::toIR(): %s", loc.toChars());
     LOG_SCOPE;
-    if (global.params.symdebug)
+    #ifndef DISABLE_DEBUG_INFO
-        DtoDwarfStopPoint(loc.linnum);
+    if (global.params.symdebug)
+        DtoDwarfStopPoint(loc.linnum);
+    #endif
     // create basic blocks
     llvm::BasicBlock* oldend = p->scopeend();
     llvm::BasicBlock* trybb = llvm::BasicBlock::Create(gIR->context(), "try", p->topfunc(), oldend);
 …
 void ThrowStatement::toIR(IRState* p)
+{
     Logger::println("ThrowStatement::toIR(): %s", loc.toChars());
     LOG_SCOPE;
-    if (global.params.symdebug)
+    #ifndef DISABLE_DEBUG_INFO
-        DtoDwarfStopPoint(loc.linnum);
+    if (global.params.symdebug)
+        DtoDwarfStopPoint(loc.linnum);
+    #endif
     assert(exp);
     DValue* e = exp->toElem(p);
+    #ifndef DISABLE_DEBUG_INFO
     if (global.params.symdebug) DtoDwarfFuncEnd(gIR->func()->decl);
+    #endif
     llvm::Function* fn = LLVM_D_GetRuntimeFunction(gIR->module, "_d_throw_exception");
     //Logger::cout() << "calling: " << *fn << '\n';
     LLValue* arg = DtoBitCast(e->getRVal(), fn->getFunctionType()->getParamType(0));
     //Logger::cout() << "arg: " << *arg << '\n';
 …
 void SwitchStatement::toIR(IRState* p)
+{
     Logger::println("SwitchStatement::toIR(): %s", loc.toChars());
     LOG_SCOPE;
-    if (global.params.symdebug)
+    #ifndef DISABLE_DEBUG_INFO
-        DtoDwarfStopPoint(loc.linnum);
+    if (global.params.symdebug)
+        DtoDwarfStopPoint(loc.linnum);
+    #endif
     llvm::BasicBlock* oldend = gIR->scopeend();
     // clear data from previous passes... :/
     for (int i=0; i<cases->dim; ++i)
 …
     // if no statements, there's nothing to do
     if (!statements || !statements->dim)
         return;
-    if (global.params.symdebug)
+    #ifndef DISABLE_DEBUG_INFO
-        DtoDwarfStopPoint(loc.linnum);
+    if (global.params.symdebug)
+        DtoDwarfStopPoint(loc.linnum);
+    #endif
     // 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
     llvm::BasicBlock* oldend = gIR->scopeend();
 …
 void ForeachStatement::toIR(IRState* p)
+{
     Logger::println("ForeachStatement::toIR(): %s", loc.toChars());
     LOG_SCOPE;
-    if (global.params.symdebug)
+    #ifndef DISABLE_DEBUG_INFO
-        DtoDwarfStopPoint(loc.linnum);
+    if (global.params.symdebug)
+        DtoDwarfStopPoint(loc.linnum);
+    #endif
     //assert(arguments->dim == 1);
     assert(value != 0);
     assert(aggr != 0);
     assert(func != 0);
 …
 void ForeachRangeStatement::toIR(IRState* p)
+{
     Logger::println("ForeachRangeStatement::toIR(): %s", loc.toChars());
     LOG_SCOPE;
-    if (global.params.symdebug)
+    #ifndef DISABLE_DEBUG_INFO
-        DtoDwarfStopPoint(loc.linnum);
+    if (global.params.symdebug)
+        DtoDwarfStopPoint(loc.linnum);
+    #endif
     // evaluate lwr/upr
     assert(lwr->type->isintegral());
     LLValue* lower = lwr->toElem(p)->getRVal();
     assert(upr->type->isintegral());
 …
 void GotoStatement::toIR(IRState* p)
+{
     Logger::println("GotoStatement::toIR(): %s", loc.toChars());
     LOG_SCOPE;
-    if (global.params.symdebug)
+    #ifndef DISABLE_DEBUG_INFO
-        DtoDwarfStopPoint(loc.linnum);
+    if (global.params.symdebug)
+        DtoDwarfStopPoint(loc.linnum);
+    #endif
     llvm::BasicBlock* oldend = gIR->scopeend();
     llvm::BasicBlock* bb = llvm::BasicBlock::Create(gIR->context(), "aftergoto", p->topfunc(), oldend);
     DtoGoto(loc, label->ident, enclosingFinally);
 …
 void GotoDefaultStatement::toIR(IRState* p)
+{
     Logger::println("GotoDefaultStatement::toIR(): %s", loc.toChars());
     LOG_SCOPE;
-    if (global.params.symdebug)
+    #ifndef DISABLE_DEBUG_INFO
-        DtoDwarfStopPoint(loc.linnum);
+    if (global.params.symdebug)
+        DtoDwarfStopPoint(loc.linnum);
+    #endif
     llvm::BasicBlock* oldend = gIR->scopeend();
     llvm::BasicBlock* bb = llvm::BasicBlock::Create(gIR->context(), "aftergotodefault", p->topfunc(), oldend);
     assert(!p->scopereturned());
 …
 void GotoCaseStatement::toIR(IRState* p)
+{
     Logger::println("GotoCaseStatement::toIR(): %s", loc.toChars());
     LOG_SCOPE;
-    if (global.params.symdebug)
+    #ifndef DISABLE_DEBUG_INFO
-        DtoDwarfStopPoint(loc.linnum);
+    if (global.params.symdebug)
+        DtoDwarfStopPoint(loc.linnum);
+    #endif
     llvm::BasicBlock* oldend = gIR->scopeend();
     llvm::BasicBlock* bb = llvm::BasicBlock::Create(gIR->context(), "aftergotocase", p->topfunc(), oldend);
     assert(!p->scopereturned());
 …
 void WithStatement::toIR(IRState* p)
+{
     Logger::println("WithStatement::toIR(): %s", loc.toChars());
     LOG_SCOPE;
-    if (global.params.symdebug)
+    #ifndef DISABLE_DEBUG_INFO
-        DtoDwarfStopPoint(loc.linnum);
+    if (global.params.symdebug)
+        DtoDwarfStopPoint(loc.linnum);
+    #endif
     assert(exp);
     assert(body);
     // with(..) can either be used with expressions or with symbols
 …
 void SynchronizedStatement::toIR(IRState* p)
+{
     Logger::println("SynchronizedStatement::toIR(): %s", loc.toChars());
     LOG_SCOPE;
-    if (global.params.symdebug)
+    #ifndef DISABLE_DEBUG_INFO
-        DtoDwarfStopPoint(loc.linnum);
+    if (global.params.symdebug)
+        DtoDwarfStopPoint(loc.linnum);
+    #endif
     // enter lock
     if (exp)
+    {
         llsync = exp->toElem(p)->getRVal();
 …
 void VolatileStatement::toIR(IRState* p)
+{
     Logger::println("VolatileStatement::toIR(): %s", loc.toChars());
     LOG_SCOPE;
-    if (global.params.symdebug)
+    #ifndef DISABLE_DEBUG_INFO
-        DtoDwarfStopPoint(loc.linnum);
+    if (global.params.symdebug)
+        DtoDwarfStopPoint(loc.linnum);
+    #endif
     // mark in-volatile
     // FIXME
     // has statement

gen/tocall.cpp

--- Revision 1607:207a8a438dea
+++ Revision 1650:40bd4a0d4870
     return 0;
+}
 //////////////////////////////////////////////////////////////////////////////////////////
-unsigned DtoCallingConv(Loc loc, LINK l)
+llvm::CallingConv::ID DtoCallingConv(Loc loc, LINK l)
+{
     if (l == LINKc || l == LINKcpp || l == LINKintrinsic)
         return llvm::CallingConv::C;
     else if (l == LINKd || l == LINKdefault)
+    {
 …
     // put data in d-array
     std::vector<LLConstant*> pinits;
     pinits.push_back(DtoConstSize_t(vtype->getNumElements()));
     pinits.push_back(llvm::ConstantExpr::getBitCast(typeinfomem, getPtrToType(typeinfotype)));
     const LLType* tiarrty = DtoType(Type::typeinfo->type->arrayOf());
-    tiinits = LLConstantStruct::get(gIR->context(), pinits);
+    tiinits = LLConstantStruct::get(gIR->context(), pinits, false);
     LLValue* typeinfoarrayparam = new llvm::GlobalVariable(*gIR->module, tiarrty,
         true, llvm::GlobalValue::InternalLinkage, tiinits, "._arguments.array");
     llvm::AttributeWithIndex Attr;
     // specify arguments
 …
     bool thiscall = tf->fty.arg_this;
     bool delegatecall = (calleeType->toBasetype()->ty == Tdelegate);
     bool nestedcall = tf->fty.arg_nest;
     bool dvarargs = (tf->linkage == LINKd && tf->varargs == 1);
-    unsigned callconv = DtoCallingConv(loc, tf->linkage);
+    llvm::CallingConv::ID callconv = DtoCallingConv(loc, tf->linkage);
     // get callee llvm value
     LLValue* callable = DtoCallableValue(fnval);
     const LLFunctionType* callableTy = DtoExtractFunctionType(callable->getType());
     assert(callableTy);

gen/todebug.cpp

--- Revision 1571:8d086d552909
+++ Revision 1650:40bd4a0d4870
 #include "gen/utils.h"
 #include "ir/irmodule.h"
 using namespace llvm::dwarf;
+#ifndef DISABLE_DEBUG_INFO
 #define DBG_NULL    ( LLConstant::getNullValue(DBG_TYPE) )
 #define DBG_TYPE    ( getPtrToType(llvm::StructType::get(gIR->context(),NULL,NULL)) )
 #define DBG_CAST(X) ( llvm::ConstantExpr::getBitCast(X, DBG_TYPE) )
 …
         ln, // line no
 , // col no
         gIR->scopebb()
     );
+}
+#endif

gen/todebug.h

--- Revision 946:1714836f2c0b
+++ Revision 1650:40bd4a0d4870
 #ifndef LDC_GEN_TODEBUG_H
 #define LDC_GEN_TODEBUG_H
+#ifndef DISABLE_DEBUG_INFO
 void RegisterDwarfSymbols(llvm::Module* mod);
 /**
  * Emit the Dwarf compile_unit global for a Module m.
 …
  * @param vd
  * @return
  */
 llvm::DIGlobalVariable DtoDwarfGlobalVariable(LLGlobalVariable* ll, VarDeclaration* vd);
+#endif // DISABLE_DEBUG_INFO
 #endif // LDC_GEN_TODEBUG_H

gen/tollvm.cpp

Revision 1644:9176437d98be		Revision 1650:40bd4a0d4870
360	if (ptrTy == valTy)	360	if (ptrTy == valTy)
361	{	361	{
362	return val;	362	return val;
363	}	363	}
364	// ptr is integer pointer	364	// ptr is integer pointer
365	else if (ptrTy->isInteger())	365	else if (ptrTy->isIntegerTy())
366	{	366	{
367	// val is integer	367	// val is integer
368	assert(valTy->isInteger());	368	assert(valTy->isInteger());
369	const LLIntegerType* pt = llvm::cast<const LLIntegerType>(ptrTy);	369	const LLIntegerType* pt = llvm::cast<const LLIntegerType>(ptrTy);
370	const LLIntegerType* vt = llvm::cast<const LLIntegerType>(valTy);	370	const LLIntegerType* vt = llvm::cast<const LLIntegerType>(valTy);

gen/toobj.cpp

--- Revision 1575:299a6b634178
+++ Revision 1650:40bd4a0d4870
 #include "gen/llvm.h"
 #include "llvm/Analysis/Verifier.h"
 #include "llvm/Bitcode/ReaderWriter.h"
 #include "llvm/Module.h"
-#include "llvm/ModuleProvider.h"
 #include "llvm/PassManager.h"
 #include "llvm/LinkAllPasses.h"
 #include "llvm/System/Program.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FormattedStream.h"
 #include "llvm/Target/TargetMachine.h"
+#include "llvm/CodeGen/MachineCodeEmitter.h"
 #include "mars.h"
 #include "module.h"
 #include "mtype.h"
 #include "declaration.h"
 …
         Logger::cout() << "Final data layout: " << global.params.dataLayout << '\n';
     // allocate the target abi
     gABI = TargetABI::getTarget();
+    #ifndef DISABLE_DEBUG_INFO
     // debug info
     if (global.params.symdebug) {
         RegisterDwarfSymbols(ir.module);
         DtoDwarfCompileUnit(this);
+    }
+    #endif
     // handle invalid 'objectÃž module
     if (!ClassDeclaration::object) {
         error("is missing 'class Object'");
         fatal();
 …
     if (global.params.output_bc) {
         LLPath bcpath = LLPath(filename);
         bcpath.eraseSuffix();
         bcpath.appendSuffix(std::string(global.bc_ext));
         Logger::println("Writing LLVM bitcode to: %s\n", bcpath.c_str());
-        std::ofstream bos(bcpath.c_str(), std::ios::binary);
+        std::string errinfo;
-        if (bos.fail())
+        llvm::raw_fd_ostream bos(bcpath.c_str(), errinfo, llvm::raw_fd_ostream::F_Binary);
+        if (bos.has_error())
+        {
-            error("cannot write LLVM bitcode, failed to open file '%s'", bcpath.c_str());
+            error("cannot write LLVM bitcode file '%s': %s", bcpath.c_str(), errinfo.c_str());
             fatal();
+        }
         llvm::WriteBitcodeToFile(m, bos);
+    }
 …
     if (global.params.output_ll) {
         LLPath llpath = LLPath(filename);
         llpath.eraseSuffix();
         llpath.appendSuffix(std::string(global.ll_ext));
         Logger::println("Writing LLVM asm to: %s\n", llpath.c_str());
-        std::ofstream aos(llpath.c_str());
+        std::string errinfo;
-        if (aos.fail())
+        llvm::raw_fd_ostream aos(llpath.c_str(), errinfo);
+        if (aos.has_error())
+        {
-            error("cannot write LLVM asm, failed to open file '%s'", llpath.c_str());
+            error("cannot write LLVM asm file '%s': %s", llpath.c_str(), errinfo.c_str());
             fatal();
+        }
         m->print(aos, NULL);
+    }
 …
             spath.createTemporaryFileOnDisk();
+        }
         Logger::println("Writing native asm to: %s\n", spath.c_str());
         std::string err;
+        {
-            llvm::raw_fd_ostream out(spath.c_str(), false, true, err);
+            llvm::raw_fd_ostream out(spath.c_str(), err);
             if (err.empty())
+            {
                 write_asm_to_file(*gTargetMachine, *m, out);
+            }
             else
 …
 void write_asm_to_file(llvm::TargetMachine &Target, llvm::Module& m, llvm::raw_fd_ostream& out)
+{
     using namespace llvm;
     // Build up all of the passes that we want to do to the module.
-    ExistingModuleProvider Provider(&m);
+    FunctionPassManager Passes(&m);
+    FunctionPassManager Passes(&Provider);
     if (const TargetData *TD = Target.getTargetData())
         Passes.add(new TargetData(*TD));
     else
         Passes.add(new TargetData(&m));
-    // Ask the target to add backend passes as necessary.
-    MachineCodeEmitter *MCE = 0;
     // Last argument is enum CodeGenOpt::Level OptLevel
     // debug info doesn't work properly with OptLevel != None!
     CodeGenOpt::Level LastArg = CodeGenOpt::Default;
     if (global.params.symdebug || !optimize())
         LastArg = CodeGenOpt::None;
     else if (optLevel() >= 3)
         LastArg = CodeGenOpt::Aggressive;
     llvm::formatted_raw_ostream fout(out);
-    FileModel::Model mod = Target.addPassesToEmitFile(Passes, fout, TargetMachine::AssemblyFile, LastArg);
+    if (Target.addPassesToEmitFile(Passes, fout, TargetMachine::CGFT_AssemblyFile, LastArg))
-    assert(mod == FileModel::AsmFile);
+        assert(0 && "no support for asm output");
+    bool err = Target.addPassesToEmitFileFinish(Passes, MCE, LastArg);
+    assert(!err);
     Passes.doInitialization();
     // Run our queue of passes all at once now, efficiently.
     for (llvm::Module::iterator I = m.begin(), E = m.end(); I != E; ++I)
 …
             Passes.run(*I);
     Passes.doFinalization();
     // release module from module provider so we can delete it ourselves
-    std::string Err;
+    //std::string Err;
-    llvm::Module* rmod = Provider.releaseModule(&Err);
+    //llvm::Module* rmod = Provider.releaseModule(&Err);
-    assert(rmod);
+    //assert(rmod);
+}
 /* ================================================================== */
 // uses gcc to make an obj out of an assembly file
 …
     // Note:
     //  We can't just assemble and link the file with the system assembler
     //  and linker because we don't know where to put the _start symbol.
     //  GCC mysteriously knows how to do it.
     std::vector<std::string> args;
-    args.push_back(gcc.toString());
+    args.push_back(gcc.str());
     args.push_back("-fno-strict-aliasing");
     args.push_back("-O3");
     args.push_back("-c");
     args.push_back("-xassembler");
-    args.push_back(asmpath.toString());
+    args.push_back(asmpath.str());
     args.push_back("-o");
-    args.push_back(objpath.toString());
+    args.push_back(objpath.str());
     //FIXME: only use this if needed?
     args.push_back("-fpic");
     //FIXME: enforce 64 bit
 …
     llvm::BasicBlock* bb = llvm::BasicBlock::Create(gIR->context(), "entry", fn);
     IRBuilder<> builder(bb);
     // debug info
+    #ifndef DISABLE_DEBUG_INFO
     LLGlobalVariable* subprog;
     if(global.params.symdebug) {
         subprog = DtoDwarfSubProgramInternal(name.c_str(), name.c_str()).getGV();
         builder.CreateCall(gIR->module->getFunction("llvm.dbg.func.start"), DBG_CAST(subprog));
+    }
+    #endif
     for (size_t i=0; i<n; i++) {
         llvm::Function* f = gIR->ctors[i]->ir.irFunc->func;
         llvm::CallInst* call = builder.CreateCall(f,"");
         call->setCallingConv(DtoCallingConv(0, LINKd));
+    }
     // debug info end
+    #ifndef DISABLE_DEBUG_INFO
     if(global.params.symdebug)
         builder.CreateCall(gIR->module->getFunction("llvm.dbg.region.end"), DBG_CAST(subprog));
+    #endif
     builder.CreateRetVoid();
     return fn;
+}
 …
     fn->setCallingConv(DtoCallingConv(0, LINKd));
     llvm::BasicBlock* bb = llvm::BasicBlock::Create(gIR->context(), "entry", fn);
     IRBuilder<> builder(bb);
+    #ifndef DISABLE_DEBUG_INFO
     // debug info
     LLGlobalVariable* subprog;
     if(global.params.symdebug) {
         subprog = DtoDwarfSubProgramInternal(name.c_str(), name.c_str()).getGV();
         builder.CreateCall(gIR->module->getFunction("llvm.dbg.func.start"), DBG_CAST(subprog));
+    }
+    #endif
     for (size_t i=0; i<n; i++) {
         llvm::Function* f = gIR->dtors[i]->ir.irFunc->func;
         llvm::CallInst* call = builder.CreateCall(f,"");
         call->setCallingConv(DtoCallingConv(0, LINKd));
+    }
+    #ifndef DISABLE_DEBUG_INFO
     // debug info end
     if(global.params.symdebug)
         builder.CreateCall(gIR->module->getFunction("llvm.dbg.region.end"), DBG_CAST(subprog));
+    #endif
     builder.CreateRetVoid();
     return fn;
+}
 …
     fn->setCallingConv(DtoCallingConv(0, LINKd));
     llvm::BasicBlock* bb = llvm::BasicBlock::Create(gIR->context(), "entry", fn);
     IRBuilder<> builder(bb);
+    #ifndef DISABLE_DEBUG_INFO
     // debug info
     LLGlobalVariable* subprog;
     if(global.params.symdebug) {
         subprog = DtoDwarfSubProgramInternal(name.c_str(), name.c_str()).getGV();
         builder.CreateCall(gIR->module->getFunction("llvm.dbg.func.start"), DBG_CAST(subprog));
+    }
+    #endif
     for (size_t i=0; i<n; i++) {
         llvm::Function* f = gIR->unitTests[i]->ir.irFunc->func;
         llvm::CallInst* call = builder.CreateCall(f,"");
         call->setCallingConv(DtoCallingConv(0, LINKd));
+    }
+    #ifndef DISABLE_DEBUG_INFO
     // debug info end
     if(global.params.symdebug)
         builder.CreateCall(gIR->module->getFunction("llvm.dbg.region.end"), DBG_CAST(subprog));
+    #endif
     builder.CreateRetVoid();
     return fn;
+}
 …
     // make the function insert this moduleinfo as the beginning of the _Dmodule_ref linked list
     llvm::BasicBlock* bb = llvm::BasicBlock::Create(gIR->context(), "moduleinfoCtorEntry", ctor);
     IRBuilder<> builder(bb);
     // debug info
+    #ifndef DISABLE_DEBUG_INFO
     LLGlobalVariable* subprog;
     if(global.params.symdebug) {
         subprog = DtoDwarfSubProgramInternal(fname.c_str(), fname.c_str()).getGV();
         builder.CreateCall(gIR->module->getFunction("llvm.dbg.func.start"), DBG_CAST(subprog));
+    }
+    #endif
     // get current beginning
     LLValue* curbeg = builder.CreateLoad(mref, "current");
     // put current beginning as the next of this one
 …
     builder.CreateStore(curbeg, gep);
     // replace beginning
     builder.CreateStore(thismref, mref);
+    #ifndef DISABLE_DEBUG_INFO
     // debug info end
     if(global.params.symdebug)
         builder.CreateCall(gIR->module->getFunction("llvm.dbg.region.end"), DBG_CAST(subprog));
+    #endif
     // return
     builder.CreateRetVoid();
     return ctor;

ir/irclass.cpp

--- Revision 1571:8d086d552909
+++ Revision 1650:40bd4a0d4870
         // offset
         LLConstant* off = DtoConstSize_t(it->offset);
         // create Interface struct
         LLConstant* inits[3] = { ci, vtb, off };
-        LLConstant* entry = LLConstantStruct::get(gIR->context(), inits, 3);
+        LLConstant* entry = LLConstantStruct::get(gIR->context(), inits, 3, false);
         constants.push_back(entry);
+    }
     // create Interface[N]
     const llvm::ArrayType* array_type = llvm::ArrayType::get(

ir/irlandingpad.cpp

--- Revision 1584:f4c56ed32238
+++ Revision 1650:40bd4a0d4870
             selectorargs.insert(selectorargs.begin(), it->catchType->ir.irStruct->getClassInfoSymbol());
+        }
+    }
     // if there's a finally, the eh table has to have a 0 action
     if(hasFinally)
-        selectorargs.push_back(DtoConstSize_t(0));//LLConstantInt::get(LLType::getInt32Ty(gIR->context()), 0));
+        selectorargs.push_back(DtoConstUint(0));
     // personality fn
     llvm::Function* personality_fn = LLVM_D_GetRuntimeFunction(gIR->module, "_d_eh_personality");
     LLValue* personality_fn_arg = gIR->ir->CreateBitCast(personality_fn, getPtrToType(LLType::getInt8Ty(gIR->context())));
     selectorargs.insert(selectorargs.begin(), personality_fn_arg);
 …
         const LLType* objectTy = DtoType(ClassDeclaration::object->type);
         gIR->ir->CreateStore(gIR->ir->CreateBitCast(eh_ptr, objectTy), catch_var);
+    }
     // eh_sel = llvm.eh.selector(eh_ptr, cast(byte*)&_d_eh_personality, <selectorargs>);
-    llvm::Function* eh_selector_fn;
+    llvm::Function* eh_selector_fn = GET_INTRINSIC_DECL(eh_selector);
+    if (global.params.is64bit)
+        eh_selector_fn = GET_INTRINSIC_DECL(eh_selector_i64);
+    else
+        eh_selector_fn = GET_INTRINSIC_DECL(eh_selector_i32);
     LLValue* eh_sel = gIR->ir->CreateCall(eh_selector_fn, selectorargs.begin(), selectorargs.end());
     // emit finallys and switches that branch to catches until there are no more catches
     // then simply branch to the finally chain
     llvm::SwitchInst* switchinst = NULL;
 …
                 switchinst = gIR->ir->CreateSwitch(eh_sel, llvm::BasicBlock::Create(gIR->context(), "switchdefault", gIR->topfunc(), gIR->scopeend()), infos.size());
                 gIR->scope() = IRScope(switchinst->getDefaultDest(), gIR->scopeend());
+            }
             // dubious comment
             // catches matched first get the largest switchval, so do size - unique int
-            llvm::ConstantInt* switchval = LLConstantInt::get(DtoSize_t(), catchToInt[rit->catchType]);
+            llvm::ConstantInt* switchval = DtoConstUint(catchToInt[rit->catchType]);
             // and make sure we don't add the same switchval twice, may happen with nested trys
             if(!switchinst->findCaseValue(switchval))
                 switchinst->addCase(switchval, rit->target);
+        }
+    }

ir/irtype.cpp

--- Revision 1571:8d086d552909
+++ Revision 1650:40bd4a0d4870
 #include "llvm/DerivedTypes.h"
+#include "llvm/LLVMContext.h"
 #include "mars.h"
 #include "mtype.h"
 #include "gen/irstate.h"
 #include "gen/logger.h"
 #include "ir/irtype.h"
+// This code uses llvm::getGlobalContext() as these functions are invoked before gIR is set.
+// ... thus it segfaults on gIR==NULL
 //////////////////////////////////////////////////////////////////////////////
 extern const llvm::Type* DtoType(Type* dt);
 extern const llvm::Type* DtoSize_t();
 …
 const llvm::Type * IrTypeBasic::basic2llvm(Type* t)
+{
     const llvm::Type* t2;
-    // FIXME: don't use getGlobalContext
+    llvm::LLVMContext& ctx = llvm::getGlobalContext();
     switch(t->ty)
+    {
     case Tvoid:
-        return llvm::Type::getVoidTy(llvm::getGlobalContext());
+        return llvm::Type::getVoidTy(ctx);
     case Tint8:
     case Tuns8:
     case Tchar:
-        return llvm::Type::getInt8Ty(llvm::getGlobalContext());
+        return llvm::Type::getInt8Ty(ctx);
     case Tint16:
     case Tuns16:
     case Twchar:
-        return llvm::Type::getInt16Ty(llvm::getGlobalContext());
+        return llvm::Type::getInt16Ty(ctx);
     case Tint32:
     case Tuns32:
     case Tdchar:
-        return llvm::Type::getInt32Ty(llvm::getGlobalContext());
+        return llvm::Type::getInt32Ty(ctx);
     case Tint64:
     case Tuns64:
-        return llvm::Type::getInt64Ty(llvm::getGlobalContext());
+        return llvm::Type::getInt64Ty(ctx);
     /*
     case Tint128:
     case Tuns128:
         return llvm::IntegerType::get(llvm::getGlobalContext(), 128);
     */
     case Tfloat32:
     case Timaginary32:
-        return llvm::Type::getFloatTy(llvm::getGlobalContext());
+        return llvm::Type::getFloatTy(ctx);
     case Tfloat64:
     case Timaginary64:
-        return llvm::Type::getDoubleTy(llvm::getGlobalContext());
+        return llvm::Type::getDoubleTy(ctx);
     case Tfloat80:
     case Timaginary80:
         // only x86 has 80bit float
         if (global.params.cpu == ARCHx86 || global.params.cpu == ARCHx86_64)
-            return llvm::Type::getX86_FP80Ty(llvm::getGlobalContext());
+            return llvm::Type::getX86_FP80Ty(ctx);
         // other platforms use 64bit reals
         else
-            return llvm::Type::getDoubleTy(llvm::getGlobalContext());
+            return llvm::Type::getDoubleTy(ctx);
     case Tcomplex32:
-        t2 = llvm::Type::getFloatTy(llvm::getGlobalContext());
+        t2 = llvm::Type::getFloatTy(ctx);
-        return llvm::StructType::get(llvm::getGlobalContext(), t2, t2, NULL);
+        return llvm::StructType::get(ctx, t2, t2, NULL);
     case Tcomplex64:
-        t2 = llvm::Type::getDoubleTy(llvm::getGlobalContext());
+        t2 = llvm::Type::getDoubleTy(ctx);
-        return llvm::StructType::get(llvm::getGlobalContext(), t2, t2, NULL);
+        return llvm::StructType::get(ctx, t2, t2, NULL);
     case Tcomplex80:
         t2 = (global.params.cpu == ARCHx86 || global.params.cpu == ARCHx86_64)
-            ? llvm::Type::getX86_FP80Ty(llvm::getGlobalContext())
+            ? llvm::Type::getX86_FP80Ty(ctx)
-            : llvm::Type::getDoubleTy(llvm::getGlobalContext());
+            : llvm::Type::getDoubleTy(ctx);
-        return llvm::StructType::get(llvm::getGlobalContext(), t2, t2, NULL);
+        return llvm::StructType::get(ctx, t2, t2, NULL);
     case Tbool:
-        return llvm::Type::getInt1Ty(llvm::getGlobalContext());
+        return llvm::Type::getInt1Ty(ctx);
+    }
     assert(0 && "not basic type");
     return NULL;
+}

ir/irvar.cpp

--- Revision 1571:8d086d552909
+++ Revision 1650:40bd4a0d4870
 #include "gen/llvm.h"
 #include "declaration.h"
+#include "gen/irstate.h"
 #include "ir/irvar.h"
 //////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 …
 //////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 IrGlobal::IrGlobal(VarDeclaration* v): IrVar(v),
-    type(llvm::OpaqueType::get(llvm::getGlobalContext()))
+    type(llvm::OpaqueType::get(gIR->context()))
+{
     constInit = NULL;
+}
 //////////////////////////////////////////////////////////////////////////////

tango-0.99.9.patch

--- Revision 1633:5c0cebff9be8
+++ Revision 1650:40bd4a0d4870
 Index: tango/core/rt/compiler/ldc/rt/lifetime.d
 ===================================================================
---- tango/core/rt/compiler/ldc/rt/lifetime.d    (revision 5368)
+--- tango/core/rt/compiler/ldc/rt/lifetime.d    (revision 5462)
 +++ tango/core/rt/compiler/ldc/rt/lifetime.d    (working copy)
 @@ -786,6 +786,7 @@
      return *cast(long*)px;
+ }
 …
 +/+
  /**
+  *
+Index: tango/core/rt/compiler/ldc/rt/eh.d
+===================================================================
+--- tango/core/rt/compiler/ldc/rt/eh.d  (revision 5462)
++++ tango/core/rt/compiler/ldc/rt/eh.d  (working copy)
+@@ -1,38 +1,34 @@
+ /**
+  * This module contains functions and structures required for
+- * exception handling.
++ * dwarf exception handling with llvm
+  */
+ module rt.eh;
+-import ldc.cstdarg;
+-import rt.compiler.util.console;
++//debug = EH_personality;
+-// debug = EH_personality;
+-
+ // current EH implementation works on x86
+ // if it has a working unwind runtime
+ version(X86) {
+     version(linux) version=X86_UNWIND;
+     version(darwin) version=X86_UNWIND;
+     version(solaris) version=X86_UNWIND;
+-    version(freebsd) version=X86_UNWIND;
+ }
+ version(X86_64) {
+     version(linux) version=X86_UNWIND;
+     version(darwin) version=X86_UNWIND;
+     version(solaris) version=X86_UNWIND;
+-    version(freebsd) version=X86_UNWIND;
+ }
+ //version = HP_LIBUNWIND;
+ private extern(C) void abort();
+ private extern(C) int printf(char*, ...);
+-private extern(C) int vprintf(char*, va_list va);
++//private extern(C) int vprintf(char*, va_list va);
+ // D runtime functions
+ extern(C) {
+-    int _d_isbaseof(ClassInfo oc, ClassInfo c);
++//    int _d_isbaseof(ClassInfo oc, ClassInfo c);
++    Object _d_dynamic_cast(Object o, ClassInfo c);
+ }
+ // libunwind headers
+@@ -74,16 +70,19 @@
+ // interface to HP's libunwind from http://www.nongnu.org/libunwind/
+ version(HP_LIBUNWIND)
+ {
++    // Haven't checked whether and how it has _Unwind_Get{Text,Data}RelBase
++    pragma (msg, "HP_LIBUNWIND interface is out of date and untested");
++
+     void __libunwind_Unwind_Resume(_Unwind_Exception *);
+     _Unwind_Reason_Code __libunwind_Unwind_RaiseException(_Unwind_Exception *);
+     ptrdiff_t __libunwind_Unwind_GetLanguageSpecificData(_Unwind_Context_Ptr
+             context);
+-    ptrdiff_t __libunwind_Unwind_GetIP(_Unwind_Context_Ptr context);
++    size_t __libunwind_Unwind_GetIP(_Unwind_Context_Ptr context);
+     ptrdiff_t __libunwind_Unwind_SetIP(_Unwind_Context_Ptr context,
+             ptrdiff_t new_value);
+     ptrdiff_t __libunwind_Unwind_SetGR(_Unwind_Context_Ptr context, int index,
+             ptrdiff_t new_value);
+-    ptrdiff_t __libunwind_Unwind_GetRegionStart(_Unwind_Context_Ptr context);
++    size_t __libunwind_Unwind_GetRegionStart(_Unwind_Context_Ptr context);
+     alias __libunwind_Unwind_Resume _Unwind_Resume;
+     alias __libunwind_Unwind_RaiseException _Unwind_RaiseException;
+@@ -94,27 +93,30 @@
+     alias __libunwind_Unwind_SetGR _Unwind_SetGR;
+     alias __libunwind_Unwind_GetRegionStart _Unwind_GetRegionStart;
+ }
+-else version(X86_UNWIND)
++else version(X86_UNWIND)
+ {
+     void _Unwind_Resume(_Unwind_Exception*);
+     _Unwind_Reason_Code _Unwind_RaiseException(_Unwind_Exception*);
+     ptrdiff_t _Unwind_GetLanguageSpecificData(_Unwind_Context_Ptr context);
+-    ptrdiff_t _Unwind_GetIP(_Unwind_Context_Ptr context);
++    size_t _Unwind_GetIP(_Unwind_Context_Ptr context);
+     ptrdiff_t _Unwind_SetIP(_Unwind_Context_Ptr context, ptrdiff_t new_value);
+     ptrdiff_t _Unwind_SetGR(_Unwind_Context_Ptr context, int index,
+             ptrdiff_t new_value);
+-    ptrdiff_t _Unwind_GetRegionStart(_Unwind_Context_Ptr context);
++    size_t _Unwind_GetRegionStart(_Unwind_Context_Ptr context);
++
++    size_t _Unwind_GetTextRelBase(_Unwind_Context_Ptr);
++    size_t _Unwind_GetDataRelBase(_Unwind_Context_Ptr);
+ }
+ else
+ {
+     // runtime calls these directly
+     void _Unwind_Resume(_Unwind_Exception*)
+     {
+-        console("_Unwind_Resume is not implemented on this platform.\n");
++        printf("_Unwind_Resume is not implemented on this platform.\n");
+     }
+     _Unwind_Reason_Code _Unwind_RaiseException(_Unwind_Exception*)
+     {
+-        console("_Unwind_RaiseException is not implemented on this platform.\n");
++        printf("_Unwind_RaiseException is not implemented on this platform.\n");
+         return _Unwind_Reason_Code.FATAL_PHASE1_ERROR;
+     }
+ }
+@@ -122,14 +124,161 @@
+ }
+ // error and exit
+-extern(C) private void fatalerror(char[] format)
++extern(C) private void fatalerror(char* format, ...)
+ {
+-  printf("Fatal error in EH code: %.*s\n", format.length, format.ptr);
++//  va_list args;
++//  va_start(args, format);
++  printf("Fatal error in EH code: ");
++//  vprintf(format, args);
++  printf("\n");
+   abort();
+ }
+-// helpers for reading certain DWARF data
++// DWARF EH encoding enum
++// See e.g. http://refspecs.freestandards.org/LSB_3.1.1/LSB-Core-generic/LSB-Core-generic/dwarfext.html
++private enum : ubyte {
++  DW_EH_PE_omit    = 0xff, // value is not present
++
++  // value format
++  DW_EH_PE_absptr  = 0x00, // literal pointer
++  DW_EH_PE_uleb128 = 0x01,
++  DW_EH_PE_udata2  = 0x02, // unsigned 2-byte
++  DW_EH_PE_udata4  = 0x03,
++  DW_EH_PE_udata8  = 0x04,
++  DW_EH_PE_sleb128 = 0x09,
++  DW_EH_PE_sdata2  = 0x0a,
++  DW_EH_PE_sdata4  = 0x0b,
++  DW_EH_PE_sdata8  = 0x0c,
++
++  // value meaning
++  DW_EH_PE_pcrel    = 0x10, // relative to program counter
++  DW_EH_PE_textrel  = 0x20, // relative to .text
++  DW_EH_PE_datarel  = 0x30, // relative to .got or .eh_frame_hdr
++  DW_EH_PE_funcrel  = 0x40, // relative to beginning of function
++  DW_EH_PE_aligned  = 0x50, // is an aligned void*
++
++  // value is a pointer to the actual value
++  // this is a mask on top of one of the above
++  DW_EH_PE_indirect = 0x80
++}
++
++// Helpers for reading DWARF data
++
++// Given an encoding and a context, return the base to which the encoding is
++// relative
++private size_t base_of_encoded(_Unwind_Context_Ptr context, ubyte encoding)
++{
++  if (encoding == DW_EH_PE_omit)
++    return 0;
++
++  switch (encoding & 0x70) // ignore DW_EH_PE_indirect
++  {
++    case DW_EH_PE_absptr, DW_EH_PE_pcrel, DW_EH_PE_aligned:
++      return 0;
++
++    case DW_EH_PE_textrel: return _Unwind_GetTextRelBase(context);
++    case DW_EH_PE_datarel: return _Unwind_GetDataRelBase(context);
++    case DW_EH_PE_funcrel: return _Unwind_GetRegionStart(context);
++
++    default: fatalerror("Unrecognized base for DWARF value");
++  }
++}
++
++// Only defined for fixed-size encodings
++private size_t size_of_encoded(ubyte encoding)
++{
++  if (encoding == DW_EH_PE_omit)
++    return 0;
++
++  switch (encoding & 0x07) // ignore leb128
++  {
++    case DW_EH_PE_absptr: return (void*).sizeof;
++    case DW_EH_PE_udata2: return 2;
++    case DW_EH_PE_udata4: return 4;
++    case DW_EH_PE_udata8: return 8;
++
++    default: fatalerror("Unrecognized fixed-size DWARF value encoding");
++  }
++}
++
++// Actual value readers below: read a value from the given ubyte* into the
++// output parameter and return the pointer incremented past the value.
++
++// Like read_encoded_with_base but gets the base from the given context
++private ubyte* read_encoded(_Unwind_Context_Ptr context, ubyte encoding, ubyte* p, out size_t val)
++{
++  return read_encoded_with_base(encoding, base_of_encoded(context, encoding), p, val);
++}
++
++private ubyte* read_encoded_with_base(ubyte encoding, size_t base, ubyte* p, out size_t val)
++{
++  if (encoding == DW_EH_PE_aligned)
++  {
++    auto a = cast(size_t)p;
++    a = (a + (void*).sizeof - 1) & -(void*).sizeof;
++    val = *cast(size_t*)a;
++    return cast(ubyte*)(a + (void*).sizeof);
++  }
++
++  union U
++  {
++    size_t ptr;
++    ushort udata2;
++    uint   udata4;
++    ulong  udata8;
++    short  sdata2;
++    int    sdata4;
++    long   sdata8;
++  }
++
++  auto u = cast(U*)p;
++
++  size_t result;
++
++  switch (encoding & 0x0f)
++  {
++    case DW_EH_PE_absptr:
++      result = u.ptr;
++      p += (void*).sizeof;
++      break;
++
++    case DW_EH_PE_uleb128:
++    {
++      p = get_uleb128(p, result);
++      break;
++    }
++    case DW_EH_PE_sleb128:
++    {
++      ptrdiff_t sleb128;
++      p = get_sleb128(p, sleb128);
++      result = cast(size_t)sleb128;
++      break;
++    }
++
++    case DW_EH_PE_udata2: result = cast(size_t)u.udata2; p += 2; break;
++    case DW_EH_PE_udata4: result = cast(size_t)u.udata4; p += 4; break;
++    case DW_EH_PE_udata8: result = cast(size_t)u.udata8; p += 8; break;
++    case DW_EH_PE_sdata2: result = cast(size_t)u.sdata2; p += 2; break;
++    case DW_EH_PE_sdata4: result = cast(size_t)u.sdata4; p += 4; break;
++    case DW_EH_PE_sdata8: result = cast(size_t)u.sdata8; p += 8; break;
++
++    default: fatalerror("Unrecognized DWARF value encoding format");
++  }
++  if (result)
++  {
++    if ((encoding & 0x70) == DW_EH_PE_pcrel)
++      result += cast(size_t)u;
++    else
++      result += base;
++
++    if (encoding & DW_EH_PE_indirect)
++      result = *cast(size_t*)result;
++  }
++  val = result;
++  return p;
++}
++
+ private ubyte* get_uleb128(ubyte* addr, ref size_t res)
+ {
+   res = 0;
+@@ -137,7 +286,7 @@
+   // read as long as high bit is set
+   while(*addr & 0x80) {
+-    res |= (*addr & 0x7f) << bitsize;
++    res |= (*addr & 0x7fU) << bitsize;
+     bitsize += 7;
+     addr += 1;
+     if(bitsize >= size_t.sizeof*8)
+@@ -153,12 +302,12 @@
+ private ubyte* get_sleb128(ubyte* addr, ref ptrdiff_t res)
+ {
+-  res = 0;
++  size_t tres = 0;
+   size_t bitsize = 0;
+   // read as long as high bit is set
+   while(*addr & 0x80) {
+-    res |= (*addr & 0x7f) << bitsize;
++    tres |= (*addr & 0x7fU) << bitsize;
+     bitsize += 7;
+     addr += 1;
+     if(bitsize >= size_t.sizeof*8)
+@@ -167,12 +316,14 @@
+   // read last
+   if(bitsize != 0 && *addr >= 1 << size_t.sizeof*8 - bitsize)
+     fatalerror("tried to read sleb128 that exceeded size of size_t");
+-  res |= (*addr) << bitsize;
++  tres |= (*addr) << bitsize;
+   // take care of sign
+-  if(bitsize < size_t.sizeof*8 && ((*addr) & 0x40))
+-    res |= cast(ptrdiff_t)(-1) ^ ((1 << (bitsize+7)) - 1);
++  if(bitsize < size_t.sizeof*8 && (*addr & 0x40U) != 0)
++    tres |= cast(size_t)(-1) ^ ((1 << (bitsize+7)) - 1);
++  res = cast(ptrdiff_t)tres;
++
+   return addr + 1;
+ }
+@@ -190,8 +341,7 @@
+ // the 8-byte string identifying the type of exception
+ // the first 4 are for vendor, the second 4 for language
+-//TODO: This may be the wrong way around
+-const char[8] _d_exception_class = "LLDCD1\0\0";
++const char[8] _d_exception_class = "LDC_D_10";
+ //
+@@ -201,118 +351,174 @@
+ version(X86_UNWIND)
+ {
++// Various stuff we need
++struct Region
++{
++  ubyte* callsite_table;
++  ubyte* action_table;
++
++  // Note: classinfo_table points past the end of the table
++  ubyte* classinfo_table;
++
++  size_t start;
++  size_t lpStart_base; // landing pad base
++
++  ubyte ttypeEnc;
++  size_t ttype_base; // typeinfo base
++
++  ubyte callSiteEnc;
++}
++
+ // the personality routine gets called by the unwind handler and is responsible for
+ // reading the EH tables and deciding what to do
+ extern(C) _Unwind_Reason_Code _d_eh_personality(int ver, _Unwind_Action actions, ulong exception_class, _Unwind_Exception* exception_info, _Unwind_Context_Ptr context)
+ {
++  debug(EH_personality) printf("Entering personality routine, context=%p\n", context);
+   // check ver: the C++ Itanium ABI only allows ver == 1
+   if(ver != 1)
++  {
++    debug(EH_personality) printf("eh version mismatch\n");
+     return _Unwind_Reason_Code.FATAL_PHASE1_ERROR;
++  }
+   // check exceptionClass
+   //TODO: Treat foreign exceptions with more respect
+-  if((cast(char*)&exception_class)[0..8] != _d_exception_class)
++  auto wanted_ec = *cast(ulong*)_d_exception_class.ptr;
++  if(exception_class != wanted_ec)
++  {
++    debug(EH_personality) printf("exception class mismatch %p vs %p\n", exception_class, wanted_ec);
+     return _Unwind_Reason_Code.FATAL_PHASE1_ERROR;
++  }
+   // find call site table, action table and classinfo table
+   // Note: callsite and action tables do not contain static-length
+   // data and will be parsed as needed
+-  // Note: classinfo_table points past the end of the table
+-  ubyte* callsite_table;
+-  ubyte* action_table;
+-  ClassInfo* classinfo_table;
+-  _d_getLanguageSpecificTables(context, callsite_table, action_table, classinfo_table);
+-  if (!callsite_table)
++
++  Region region;
++
++  _d_getLanguageSpecificTables(context, region);
++
++  // workaround. this should not happen
++  if (!region.callsite_table)
++  {
++    debug(EH_personality) printf("callsite_table is null\n");
+     return _Unwind_Reason_Code.CONTINUE_UNWIND;
++  }
++  debug(EH_personality) printf("yay, checking\n");
++  debug(EH_personality) printf("region.start = %p\n", region.start);
++
+   /*
+     find landing pad and action table index belonging to ip by walking
+     the callsite_table
+   */
+-  ubyte* callsite_walker = callsite_table;
++  ubyte* callsite_walker = region.callsite_table;
++  debug(EH_personality) printf("callsite table at: %p\n", region.callsite_table);
++  debug(EH_personality) printf("action table at: %p\n", region.action_table);
++  debug(EH_personality) printf("rtti table at %p\n", region.classinfo_table);
+   // get the instruction pointer
+   // will be used to find the right entry in the callsite_table
+   // -1 because it will point past the last instruction
+-  ptrdiff_t ip = _Unwind_GetIP(context) - 1;
++  debug(EH_personality) printf("check1\n");
++  size_t ip = _Unwind_GetIP(context) - 1;
++  debug(EH_personality) printf("check2\n");
+-  // address block_start is relative to
+-  ptrdiff_t region_start = _Unwind_GetRegionStart(context);
+-
+   // table entries
+-  uint block_start_offset, block_size;
+-  ptrdiff_t landing_pad;
++  size_t landing_pad;
+   size_t action_offset;
+   while(true) {
+     // if we've gone through the list and found nothing...
+-    if(callsite_walker >= action_table)
++    if(callsite_walker >= region.action_table)
++    {
++      debug(EH_personality) printf("found nothing\n");
+       return _Unwind_Reason_Code.CONTINUE_UNWIND;
++    }
+-    block_start_offset = *cast(uint*)callsite_walker;
+-    block_size = *(cast(uint*)callsite_walker + 1);
+-    landing_pad = *(cast(uint*)callsite_walker + 2);
+-    if(landing_pad)
+-      landing_pad += region_start;
+-    callsite_walker = get_uleb128(callsite_walker + 3*uint.sizeof, action_offset);
++    size_t block_start, block_size;
+-    debug(EH_personality_verbose) printf("ip=%llx %d %d %llx\n", ip, block_start_offset, block_size, landing_pad);
++    callsite_walker = read_encoded(null, region.callSiteEnc, callsite_walker, block_start);
++    callsite_walker = read_encoded(null, region.callSiteEnc, callsite_walker, block_size);
++    callsite_walker = read_encoded(null, region.callSiteEnc, callsite_walker, landing_pad);
++    callsite_walker = get_uleb128(callsite_walker, action_offset);
++    debug(EH_personality) printf("*block start offset = %p\n", block_start);
++    debug(EH_personality) printf(" block size = %p\n", block_size);
++    debug(EH_personality) printf(" landing pad = %p\n", landing_pad);
++    debug(EH_personality) printf(" ip=%p %p %p %p\n", ip, block_start, block_size, landing_pad);
++
+     // since the list is sorted, as soon as we're past the ip
+     // there's no handler to be found
+-    if(ip < region_start + block_start_offset)
++    if(ip < region.start + block_start)
++    {
++      debug(EH_personality) printf("found nothing2\n");
+       return _Unwind_Reason_Code.CONTINUE_UNWIND;
++    }
++    if(landing_pad)
++      landing_pad += region.lpStart_base;
++
+     // if we've found our block, exit
+-    if(ip < region_start + block_start_offset + block_size)
++    if(ip < region.start + block_start + block_size)
+       break;
+   }
+-  debug(EH_personality) printf("Found correct landing pad and actionOffset %d\n", action_offset);
++  debug(EH_personality) printf("Found correct landing pad %p and actionOffset %p\n", landing_pad, action_offset);
+   // now we need the exception's classinfo to find a handler
+   // the exception_info is actually a member of a larger _d_exception struct
+   // the runtime allocated. get that now
+-  _d_exception* exception_struct = cast(_d_exception*)(cast(ubyte*)exception_info - _d_exception.unwind_info.offsetof);
++  _d_exception* exception_struct = cast(_d_exception*)(cast(ubyte*)exception_info - size_t.sizeof); //_d_exception.unwind_info.offsetof);
+   // if there's no action offset and no landing pad, continue unwinding
+   if(!action_offset && !landing_pad)
+     return _Unwind_Reason_Code.CONTINUE_UNWIND;
+   // if there's no action offset but a landing pad, this is a cleanup handler
+-  else if(!action_offset && landing_pad)
+-    return _d_eh_install_finally_context(actions, landing_pad, exception_struct, context);
++  else if(!action_offset && landing_pad != 0)
++  {
++    debug(EH_personality) printf("installing finally context\n");
++    return _d_eh_install_finally_context(actions, cast(ptrdiff_t)landing_pad, exception_struct, context);
++  }
+   /*
+    walk action table chain, comparing classinfos using _d_isbaseof
+   */
+-  ubyte* action_walker = action_table + action_offset - 1;
++  ubyte* action_walker = region.action_table + action_offset - 1;
+-  ptrdiff_t ti_offset, next_action_offset;
+   while(true) {
++    ptrdiff_t ti_offset, next_action_offset;
++
+     action_walker = get_sleb128(action_walker, ti_offset);
+     // it is intentional that we not modify action_walker here
+     // next_action_offset is from current action_walker position
+     get_sleb128(action_walker, next_action_offset);
+     // negative are 'filters' which we don't use
+-    if(!(ti_offset >= 0))
++    if(ti_offset < 0)
+       fatalerror("Filter actions are unsupported");
+     // zero means cleanup, which we require to be the last action
+     if(ti_offset == 0) {
+-      if(!(next_action_offset == 0))
++      if(next_action_offset != 0)
+         fatalerror("Cleanup action must be last in chain");
+-      return _d_eh_install_finally_context(actions, landing_pad, exception_struct, context);
++      return _d_eh_install_finally_context(actions, cast(ptrdiff_t)landing_pad, exception_struct, context);
+     }
+     // get classinfo for action and check if the one in the
+     // exception structure is a base
+-    ClassInfo catch_ci = *(classinfo_table - ti_offset);
+-    debug(EH_personality) printf("Comparing catch %s to exception %s\n", catch_ci.name.ptr, exception_struct.exception_object.classinfo.name.ptr);
+-    if(_d_isbaseof(exception_struct.exception_object.classinfo, catch_ci))
+-      return _d_eh_install_catch_context(actions, ti_offset, landing_pad, exception_struct, context);
++    size_t typeinfo;
++    auto filter = cast(size_t)ti_offset * size_of_encoded(region.ttypeEnc);
++    read_encoded_with_base(region.ttypeEnc, region.ttype_base, region.classinfo_table - filter, typeinfo);
++    debug(EH_personality)
++      printf("classinfo at %zx (enc %zx (size %zx) base %zx ptr %zx)\n", typeinfo, region.ttypeEnc, size_of_encoded(region.ttypeEnc), region.ttype_base, region.classinfo_table - filter);
++
++    auto catch_ci = *cast(ClassInfo*)&typeinfo;
++    if(_d_dynamic_cast(exception_struct.exception_object, catch_ci) !is null)
++      return _d_eh_install_catch_context(actions, ti_offset, cast(ptrdiff_t)landing_pad, exception_struct, context);
++
+     // we've walked through all actions and found nothing...
+     if(next_action_offset == 0)
+       return _Unwind_Reason_Code.CONTINUE_UNWIND;
+@@ -356,6 +562,7 @@
+   }
+   fatalerror("reached unreachable");
++
+   return _Unwind_Reason_Code.FATAL_PHASE2_ERROR;
+ }
+@@ -370,56 +577,78 @@
+   _Unwind_SetGR(context, eh_exception_regno, cast(ptrdiff_t)exception_struct);
+   _Unwind_SetGR(context, eh_selector_regno, 0);
+   _Unwind_SetIP(context, landing_pad);
++
+   return _Unwind_Reason_Code.INSTALL_CONTEXT;
+ }
+-private void _d_getLanguageSpecificTables(_Unwind_Context_Ptr context, ref ubyte* callsite, ref ubyte* action, ref ClassInfo* ci)
++private void _d_getLanguageSpecificTables(_Unwind_Context_Ptr context, out Region region)
+ {
+-  ubyte* data = cast(ubyte*)_Unwind_GetLanguageSpecificData(context);
++  auto data = cast(ubyte*)_Unwind_GetLanguageSpecificData(context);
++
++  // workaround. this should not be 0...
+   if (!data)
+   {
+-    callsite = null;
+-    action = null;
+-    ci = null;
+-    return;
++      //printf("language specific data is null\n");
++      return;
+   }
+-  //TODO: Do proper DWARF reading here
+-  if(*data++ != 0xff)
+-    fatalerror("DWARF header has unexpected format 1");
++  region.start = _Unwind_GetRegionStart(context);
+-  if(*data++ != 0x00)
+-    fatalerror("DWARF header has unexpected format 2");
+-  size_t cioffset;
+-  data = get_uleb128(data, cioffset);
+-  ci = cast(ClassInfo*)(data + cioffset);
++  // Read the C++-style LSDA: this is implementation-defined by GCC but LLVM
++  // outputs the same kind of table
+-  if(*data++ != 0x03)
+-    fatalerror("DWARF header has unexpected format 3");
+-  size_t callsitelength;
+-  data = get_uleb128(data, callsitelength);
+-  action = data + callsitelength;
++  // Get @LPStart: landing pad offsets are relative to it
++  auto lpStartEnc = *data++;
++  if (lpStartEnc == DW_EH_PE_omit)
++    region.lpStart_base = region.start;
++  else
++    data = read_encoded(context, lpStartEnc, data, region.lpStart_base);
+-  callsite = data;
++  // Get @TType: the offset to the handler and typeinfo
++  region.ttypeEnc = *data++;
++  if (region.ttypeEnc == DW_EH_PE_omit)
++    // Not sure about this one...
++    fatalerror("@TType must not be omitted from DWARF header");
++
++  size_t ciOffset;
++  data = get_uleb128(data, ciOffset);
++  region.classinfo_table = data + ciOffset;
++
++  region.ttype_base = base_of_encoded(context, region.ttypeEnc);
++
++  // Get encoding and length of the call site table, which precedes the action
++  // table.
++  region.callSiteEnc = *data++;
++  if (region.callSiteEnc == DW_EH_PE_omit)
++    fatalerror("Call site table encoding must not be omitted from DWARF header");
++
++  size_t callSiteLength;
++  region.callsite_table = get_uleb128(data, callSiteLength);
++  region.action_table = region.callsite_table + callSiteLength;
+ }
+ } // end of x86 Linux specific implementation
+-
+-extern(C) void _d_throw_exception(Object e)
++// called to throw object
++extern(C)
++void _d_throw_exception(Object e)
+ {
++    //printf("throwing %p, rtti = %p\n", e, **cast(ClassRTTI***)e);
+     if (e !is null)
+     {
+         _d_exception* exc_struct = new _d_exception;
+         exc_struct.unwind_info.exception_class = *cast(ulong*)_d_exception_class.ptr;
+         exc_struct.exception_object = e;
+         _Unwind_Reason_Code ret = _Unwind_RaiseException(&exc_struct.unwind_info);
+-        console("_Unwind_RaiseException failed with reason code: ")(ret)("\n");
++        printf("Error: returned %d from raise exception.\n", ret);
++        //console("_Unwind_RaiseException failed with reason code: ")(ret)("\n");
+     }
+     abort();
+ }
+-extern(C) void _d_eh_resume_unwind(_d_exception* exception_struct)
++// called to resume unwinding
++extern(C)
++void _d_eh_resume_unwind(void* exception_struct)
+ {
+-  _Unwind_Resume(&exception_struct.unwind_info);
++    _Unwind_Resume(&(cast(_d_exception*)exception_struct).unwind_info);
+ }

Navigation

Legend:

dmd/expression.h

dmd/statement.h

gen/arrays.cpp

gen/asmstmt.cpp

gen/cl_helpers.cpp

gen/cl_helpers.h

gen/configfile.cpp

gen/functions.cpp

gen/linker.cpp

gen/llvmhelpers.cpp

gen/llvmhelpers.h

gen/logger.cpp

gen/logger.h

gen/main.cpp

gen/optimizer.cpp

gen/passes/SimplifyDRuntimeCalls.cpp

gen/statements.cpp

gen/tocall.cpp

gen/todebug.cpp

gen/todebug.h

gen/tollvm.cpp

gen/toobj.cpp

ir/irclass.cpp

ir/irlandingpad.cpp

ir/irtype.cpp

ir/irvar.cpp

tango-0.99.9.patch

Download in other formats: