projects/ldc: gen/llvmhelpers.cpp comparison

comparison gen/llvmhelpers.cpp @ 1650:40bd4a0d4870

Update to work with LLVM 2.7. Removed use of dyn_cast, llvm no compiles without exceptions and rtti by default. We do need exceptions for the libconfig stuff, but rtti isn't necessary (anymore). Debug info needs to be rewritten, as in LLVM 2.7 the format has completely changed. To have something to look at while rewriting, the old code has been wrapped inside #ifndef DISABLE_DEBUG_INFO , this means that you have to define this to compile at the moment. Updated tango 0.99.9 patch to include updated EH runtime code, which is needed for LLVM 2.7 as well.

author	Tomas Lindquist Olsen
date	Wed, 19 May 2010 12:42:32 +0200
parents	8f121883bce8
children

comparison

equal deleted inserted replaced

-:36da40ecbbe0
+: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?
 #if DMDV2
 if (vd->nestedrefs.dim) {
 #else
 if (vd->nestedref) {
 #endif
 Logger::println("has nestedref set");
 assert(vd->ir.irLocal);
 DtoNestedInit(vd);
 }
 // normal stack variable, allocate storage on the stack if it has not already been done
 else if(!vd->ir.irLocal && !vd->isRef()) {
 vd->ir.irLocal = new IrLocal(vd);
 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);
 }
 // we don't handle globals with this one
 assert(!var->isDataseg());
 // we don't handle aliases either
 assert(!var->aliassym);
 // 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)
 LOG_SCOPE;
 Logger::println("template instance: %s", ti->toChars());
 Logger::println("template declaration: %s", td->toChars());
 Logger::println("intrinsic name: %s", td->intrinsicName.c_str());
 // for now use the size in bits of the first template param in the instance
 assert(ti->tdtypes.dim == 1);
 Type* T = (Type*)ti->tdtypes.data[0];
 char prefix = T->isreal() ? 'f' : T->isintegral() ? 'i' : 0;
 fatal(); // or LLVM asserts
 }
 char tmp[21]; // probably excessive, but covers a uint64_t
 sprintf(tmp, "%lu", (unsigned long) gTargetData->getTypeSizeInBits(DtoType(T)));
 // replace # in name with bitsize
 name = td->intrinsicName;
 std::string needle("#");
 size_t pos;
 td->error("has an invalid intrinsic name: %s", name.c_str());
 }
 fatal(); // or LLVM asserts
 }
 }
 Logger::println("final intrinsic name: %s", name.c_str());
 }
 //////////////////////////////////////////////////////////////////////////////////////////
 bool mustDefineSymbol(Dsymbol* s)
 {
 if (FuncDeclaration* fd = s->isFuncDeclaration())
 {
 // we can't (and probably shouldn't?) define functions
 // that weren't semantic3'ed
 if (fd->semanticRun < 4)
 return false;
 	if (fd->isArrayOp)
 if (global.params.useAvailableExternally && fd->availableExternally) {
 // Emit extra functions if we're inlining.
 // These will get available_externally linkage,
 // so they shouldn't end up in object code.
 assert(fd->type->ty == Tfunction);
 TypeFunction* tf = (TypeFunction*) fd->type;
 // * If we define extra static constructors, static destructors
 //   and unittests they'll get registered to run, and we won't
 //   be calling them directly anyway.
 && !fd->isUnitTestDeclaration()
 && fd->canInline(true))
 {
 return true;
 }
 // This was only semantic'ed for inlining checks.
 // We won't be inlining this, so we only need to emit a declaration.
 return false;
 }
 }
 TemplateInstance* tinst = DtoIsTemplateInstance(s);
 if (tinst)
 {
 if (!opts::singleObj)
 return true;
 if (!tinst->emittedInModule)
 {
 gIR->seenTemplateInstances.insert(tinst);
 tinst->emittedInModule = gIR->dmodule;
 }
 return tinst->emittedInModule == gIR->dmodule;
 }
 return s->getModule() == gIR->dmodule;
 }
 //////////////////////////////////////////////////////////////////////////////////////////

Mercurial > projects > ldc

comparison gen/llvmhelpers.cpp @ 1650:40bd4a0d4870