projects/ldc: gen/toir.cpp comparison

comparison gen/toir.cpp @ 173:db9890b3fb64 trunk

[svn r189] moving IR data back into DMD frontend nodes

author	ChristianK
date	Tue, 06 May 2008 07:56:03 +0200
parents	68a7dd38c03c
children	c44e6a711885

comparison

equal deleted inserted replaced

-:68a7dd38c03c
+:db9890b3fb64
 Logger::println("vdtype = %s", vd->type->toChars());
 // referenced by nested delegate?
 if (vd->nestedref) {
 Logger::println("has nestedref set");
-assert(gIR->irDsymbol[vd].irLocal);
+assert(vd->ir.irLocal);
-gIR->irDsymbol[vd].irLocal->value = gIR->irDsymbol[p->func()->decl].irFunc->nestedVar;
+vd->ir.irLocal->value = p->func()->decl->ir.irFunc->nestedVar;
-assert(gIR->irDsymbol[vd].irLocal->value);
+assert(vd->ir.irLocal->value);
-assert(gIR->irDsymbol[vd].irLocal->nestedIndex >= 0);
+assert(vd->ir.irLocal->nestedIndex >= 0);
 }
 // normal stack variable
 else {
 // allocate storage on the stack
 const llvm::Type* lltype = DtoType(vd->type);
 llvm::AllocaInst* allocainst = new llvm::AllocaInst(lltype, vd->toChars(), p->topallocapoint());
 //allocainst->setAlignment(vd->type->alignsize()); // TODO
-assert(!gIR->irDsymbol[vd].irLocal);
+assert(!vd->ir.irLocal);
-gIR->irDsymbol[vd].irLocal = new IrLocal(vd);
+vd->ir.irLocal = new IrLocal(vd);
-gIR->irDsymbol[vd].irLocal->value = allocainst;
+vd->ir.irLocal->value = allocainst;
 }
-Logger::cout() << "llvm value for decl: " << *gIR->irDsymbol[vd].irLocal->value << '\n';
+Logger::cout() << "llvm value for decl: " << *vd->ir.irLocal->value << '\n';
 DValue* ie = DtoInitializer(vd->init);
 }
-return new DVarValue(vd, gIR->irDsymbol[vd].getIrValue(), true);
+return new DVarValue(vd, vd->ir.getIrValue(), true);
 }
 // struct declaration
 else if (StructDeclaration* s = declaration->isStructDeclaration())
 {
 Logger::println("StructDeclaration");
 // _arguments
 if (vd->ident == Id::_arguments)
 {
 Logger::println("Id::_arguments");
-/*if (!gIR->irDsymbol[vd].getIrValue())
+/*if (!vd->ir.getIrValue())
-gIR->irDsymbol[vd].getIrValue() = p->func()->decl->irFunc->_arguments;
+vd->ir.getIrValue() = p->func()->decl->irFunc->_arguments;
-assert(gIR->irDsymbol[vd].getIrValue());
+assert(vd->ir.getIrValue());
-return new DVarValue(vd, gIR->irDsymbol[vd].getIrValue(), true);*/
+return new DVarValue(vd, vd->ir.getIrValue(), true);*/
-llvm::Value* v = gIR->irDsymbol[p->func()->decl].irFunc->_arguments;
+llvm::Value* v = p->func()->decl->ir.irFunc->_arguments;
 assert(v);
 return new DVarValue(vd, v, true);
 }
 // _argptr
 else if (vd->ident == Id::_argptr)
 {
 Logger::println("Id::_argptr");
-/*if (!gIR->irDsymbol[vd].getIrValue())
+/*if (!vd->ir.getIrValue())
-gIR->irDsymbol[vd].getIrValue() = p->func()->decl->irFunc->_argptr;
+vd->ir.getIrValue() = p->func()->decl->irFunc->_argptr;
-assert(gIR->irDsymbol[vd].getIrValue());
+assert(vd->ir.getIrValue());
-return new DVarValue(vd, gIR->irDsymbol[vd].getIrValue(), true);*/
+return new DVarValue(vd, vd->ir.getIrValue(), true);*/
-llvm::Value* v = gIR->irDsymbol[p->func()->decl].irFunc->_argptr;
+llvm::Value* v = p->func()->decl->ir.irFunc->_argptr;
 assert(v);
 return new DVarValue(vd, v, true);
 }
 // _dollar
 else if (vd->ident == Id::dollar)
 // typeinfo
 else if (TypeInfoDeclaration* tid = vd->isTypeInfoDeclaration())
 {
 Logger::println("TypeInfoDeclaration");
 DtoForceDeclareDsymbol(tid);
-assert(gIR->irDsymbol[tid].getIrValue());
+assert(tid->ir.getIrValue());
 const llvm::Type* vartype = DtoType(type);
 llvm::Value* m;
-if (gIR->irDsymbol[tid].getIrValue()->getType() != getPtrToType(vartype))
+if (tid->ir.getIrValue()->getType() != getPtrToType(vartype))
-m = p->ir->CreateBitCast(gIR->irDsymbol[tid].getIrValue(), vartype, "tmp");
+m = p->ir->CreateBitCast(tid->ir.getIrValue(), vartype, "tmp");
 else
-m = gIR->irDsymbol[tid].getIrValue();
+m = tid->ir.getIrValue();
 return new DVarValue(vd, m, true);
 }
 // classinfo
 else if (ClassInfoDeclaration* cid = vd->isClassInfoDeclaration())
 {
 Logger::println("ClassInfoDeclaration: %s", cid->cd->toChars());
 DtoDeclareClassInfo(cid->cd);
-assert(gIR->irDsymbol[cid->cd].irStruct->classInfo);
+assert(cid->cd->ir.irStruct->classInfo);
-return new DVarValue(vd, gIR->irDsymbol[cid->cd].irStruct->classInfo, true);
+return new DVarValue(vd, cid->cd->ir.irStruct->classInfo, true);
 }
 // nested variable
 else if (vd->nestedref) {
 Logger::println("nested variable");
 return new DVarValue(vd, DtoNestedVariable(vd), true);
 }
 // function parameter
 else if (vd->isParameter()) {
 Logger::println("function param");
-if (vd->isRef() || vd->isOut() || DtoIsPassedByRef(vd->type) || llvm::isa<llvm::AllocaInst>(gIR->irDsymbol[vd].getIrValue())) {
+if (vd->isRef() || vd->isOut() || DtoIsPassedByRef(vd->type) || llvm::isa<llvm::AllocaInst>(vd->ir.getIrValue())) {
-return new DVarValue(vd, gIR->irDsymbol[vd].getIrValue(), true);
+return new DVarValue(vd, vd->ir.getIrValue(), true);
 }
-else if (llvm::isa<llvm::Argument>(gIR->irDsymbol[vd].getIrValue())) {
+else if (llvm::isa<llvm::Argument>(vd->ir.getIrValue())) {
-return new DImValue(type, gIR->irDsymbol[vd].getIrValue());
+return new DImValue(type, vd->ir.getIrValue());
 }
 else assert(0);
 }
 else {
 // take care of forward references of global variables
 if (vd->isDataseg() || (vd->storage_class & STCextern)) {
 vd->toObjFile();
 DtoConstInitGlobal(vd);
 }
-if (!gIR->irDsymbol[vd].getIrValue() || DtoType(vd->type)->isAbstract()) {
+if (!vd->ir.getIrValue() || DtoType(vd->type)->isAbstract()) {
 Logger::println("global variable not resolved :/ %s", vd->toChars());
 Logger::cout() << *DtoType(vd->type) << '\n';
 assert(0);
 }
-return new DVarValue(vd, gIR->irDsymbol[vd].getIrValue(), true);
+return new DVarValue(vd, vd->ir.getIrValue(), true);
 }
 }
 else if (FuncDeclaration* fdecl = var->isFuncDeclaration())
 {
 Logger::println("FuncDeclaration");
 if (fdecl->llvmInternal != LLVMva_arg) {// && fdecl->llvmValue == 0)
 DtoForceDeclareDsymbol(fdecl);
 }
-return new DFuncValue(fdecl, gIR->irDsymbol[fdecl].irFunc->func);
+return new DFuncValue(fdecl, fdecl->ir.irFunc->func);
 }
 else if (SymbolDeclaration* sdecl = var->isSymbolDeclaration())
 {
 // this seems to be the static initialiser for structs
 Type* sdecltype = DtoDType(sdecl->type);
 Logger::print("Sym: type=%s\n", sdecltype->toChars());
 assert(sdecltype->ty == Tstruct);
 TypeStruct* ts = (TypeStruct*)sdecltype;
 assert(ts->sym);
 DtoForceConstInitDsymbol(ts->sym);
-assert(gIR->irDsymbol[ts->sym].irStruct->init);
+assert(ts->sym->ir.irStruct->init);
-return new DVarValue(type, gIR->irDsymbol[ts->sym].irStruct->init, true);
+return new DVarValue(type, ts->sym->ir.irStruct->init, true);
 }
 else
 {
 assert(0 && "Unimplemented VarExp type");
 }
 Type* sdecltype = DtoDType(sdecl->type);
 Logger::print("Sym: type=%s\n", sdecltype->toChars());
 assert(sdecltype->ty == Tstruct);
 TypeStruct* ts = (TypeStruct*)sdecltype;
 DtoForceConstInitDsymbol(ts->sym);
-assert(gIR->irDsymbol[ts->sym].irStruct->constInit);
+assert(ts->sym->ir.irStruct->constInit);
-return gIR->irDsymbol[ts->sym].irStruct->constInit;
+return ts->sym->ir.irStruct->constInit;
 }
 else if (TypeInfoDeclaration* ti = var->isTypeInfoDeclaration())
 {
 DtoForceDeclareDsymbol(ti);
-assert(gIR->irDsymbol[ti].getIrValue());
+assert(ti->ir.getIrValue());
 const llvm::Type* vartype = DtoType(type);
-llvm::Constant* m = isaConstant(gIR->irDsymbol[ti].getIrValue());
+llvm::Constant* m = isaConstant(ti->ir.getIrValue());
 assert(m);
-if (gIR->irDsymbol[ti].getIrValue()->getType() != getPtrToType(vartype))
+if (ti->ir.getIrValue()->getType() != getPtrToType(vartype))
 m = llvm::ConstantExpr::getBitCast(m, vartype);
 return m;
 }
 assert(0 && "Unsupported const VarExp kind");
 return NULL;
 DtoAnnotation(argexp->toChars());
 DtoVariadicArgument(argexp, DtoGEPi(mem,0,k,"tmp"));
 }
 // build type info array
-assert(gIR->irDsymbol[Type::typeinfo].irStruct->constInit);
+assert(Type::typeinfo->ir.irStruct->constInit);
 const llvm::Type* typeinfotype = DtoType(Type::typeinfo->type);
 const llvm::ArrayType* typeinfoarraytype = llvm::ArrayType::get(typeinfotype,vtype->getNumElements());
 llvm::Value* typeinfomem = new llvm::AllocaInst(typeinfoarraytype,"_arguments_storage",p->topallocapoint());
 Logger::cout() << "_arguments storage: " << *typeinfomem << '\n';
 for (int i=begin,k=0; i<arguments->dim; i++,k++)
 {
 Expression* argexp = (Expression*)arguments->data[i];
 TypeInfoDeclaration* tidecl = argexp->type->getTypeInfoDeclaration();
 DtoForceDeclareDsymbol(tidecl);
-assert(gIR->irDsymbol[tidecl].getIrValue());
+assert(tidecl->ir.getIrValue());
-vtypeinfos.push_back(gIR->irDsymbol[tidecl].getIrValue());
+vtypeinfos.push_back(tidecl->ir.getIrValue());
 llvm::Value* v = p->ir->CreateBitCast(vtypeinfos[k], typeinfotype, "tmp");
 p->ir->CreateStore(v, DtoGEPi(typeinfomem,0,k,"tmp"));
 }
 // put data in d-array
 if (VarDeclaration* vd = var->isVarDeclaration())
 {
 Logger::println("VarDeclaration");
 // handle forward reference
-if (!gIR->irDsymbol[vd].declared && vd->isDataseg()) {
+if (!vd->ir.declared && vd->isDataseg()) {
 vd->toObjFile(); // TODO
 }
-assert(gIR->irDsymbol[vd].getIrValue());
+assert(vd->ir.getIrValue());
 Type* t = DtoDType(type);
 Type* tnext = DtoDType(t->next);
 Type* vdtype = DtoDType(vd->type);
-llvm::Value* llvalue = vd->nestedref ? DtoNestedVariable(vd) : gIR->irDsymbol[vd].getIrValue();
+llvm::Value* llvalue = vd->nestedref ? DtoNestedVariable(vd) : vd->ir.getIrValue();
 llvm::Value* varmem = 0;
 if (vdtype->ty == Tstruct && !(t->ty == Tpointer && t->next == vdtype)) {
 Logger::println("struct");
 TypeStruct* vdt = (TypeStruct*)vdtype;
 Logger::println("is func");
 //Logger::println("FuncDeclaration");
 FuncDeclaration* fd = fv->func;
 assert(fd);
 DtoForceDeclareDsymbol(fd);
-return new DFuncValue(fd, gIR->irDsymbol[fd].irFunc->func);
+return new DFuncValue(fd, fd->ir.irFunc->func);
 }
 else if (DImValue* im = v->isIm()) {
 Logger::println("is immediate");
 return v;
 }
 //unsigned cc = (unsigned)-1;
 // super call
 if (e1->op == TOKsuper) {
 DtoForceDeclareDsymbol(fdecl);
-funcval = gIR->irDsymbol[fdecl].irFunc->func;
+funcval = fdecl->ir.irFunc->func;
 assert(funcval);
 }
 // normal virtual call
 else if (fdecl->isAbstract() || (!fdecl->isFinal() && fdecl->isVirtual())) {
 assert(fdecl->vtblIndex > 0);
 //cc = DtoCallingConv(fdecl->linkage);
 }
 // static call
 else {
 DtoForceDeclareDsymbol(fdecl);
-funcval = gIR->irDsymbol[fdecl].irFunc->func;
+funcval = fdecl->ir.irFunc->func;
 assert(funcval);
 //assert(funcval->getType() == DtoType(fdecl->type));
 }
 return new DFuncValue(fdecl, funcval, vthis2);
 }
 Logger::print("ThisExp::toElem: %s | %s\n", toChars(), type->toChars());
 LOG_SCOPE;
 if (VarDeclaration* vd = var->isVarDeclaration()) {
 llvm::Value* v;
-v = gIR->irDsymbol[p->func()->decl].irFunc->thisVar;
+v = p->func()->decl->ir.irFunc->thisVar;
 if (llvm::isa<llvm::AllocaInst>(v))
 v = new llvm::LoadInst(v, "tmp", p->scopebb());
 return new DThisValue(vd, v);
 }
 if (ts->isZeroInit()) {
 DtoStructZeroInit(emem);
 }
 else {
 assert(ts->sym);
-DtoStructCopy(emem,gIR->irDsymbol[ts->sym].irStruct->init);
+DtoStructCopy(emem,ts->sym->ir.irStruct->init);
 }
 }
 return new DImValue(type, emem, inplace);
 }
 DValue* u = e1->toElem(p);
 llvm::Value* uval;
 if (DFuncValue* f = u->isFunc()) {
 //assert(f->vthis);
 //uval = f->vthis;
-llvm::Value* nestvar = gIR->irDsymbol[p->func()->decl].irFunc->nestedVar;
+llvm::Value* nestvar = p->func()->decl->ir.irFunc->nestedVar;
 if (nestvar)
 uval = nestvar;
 else
 uval = llvm::ConstantPointerNull::get(int8ptrty);
 }
 else if (func->toParent()->isInterfaceDeclaration())
 assert(0 && "TODO delegate to interface method");
 else
 {
 DtoForceDeclareDsymbol(func);
-castfptr = gIR->irDsymbol[func].irFunc->func;
+castfptr = func->ir.irFunc->func;
 }
 castfptr = DtoBitCast(castfptr, fptr->getType()->getContainedType(0));
 DtoStore(castfptr, fptr);
 temp = true;
 }
 llvm::Value* context = DtoGEPi(lval,0,0,"tmp",p->scopebb());
 const llvm::PointerType* pty = isaPointer(context->getType()->getContainedType(0));
-llvm::Value* llvmNested = gIR->irDsymbol[p->func()->decl].irFunc->nestedVar;
+llvm::Value* llvmNested = p->func()->decl->ir.irFunc->nestedVar;
 if (llvmNested == NULL) {
 llvm::Value* nullcontext = llvm::ConstantPointerNull::get(pty);
 p->ir->CreateStore(nullcontext, context);
 }
 else {
 p->ir->CreateStore(nestedcontext, context);
 }
 llvm::Value* fptr = DtoGEPi(lval,0,1,"tmp",p->scopebb());
-assert(gIR->irDsymbol[fd].irFunc->func);
+assert(fd->ir.irFunc->func);
-llvm::Value* castfptr = new llvm::BitCastInst(gIR->irDsymbol[fd].irFunc->func,fptr->getType()->getContainedType(0),"tmp",p->scopebb());
+llvm::Value* castfptr = new llvm::BitCastInst(fd->ir.irFunc->func,fptr->getType()->getContainedType(0),"tmp",p->scopebb());
 new llvm::StoreInst(castfptr, fptr, p->scopebb());
 if (temp)
 return new DVarValue(type, lval, true);
 else
 // num elements in literal
 unsigned n = elements->dim;
 // unions might have different types for each literal
-if (gIR->irDsymbol[sd].irStruct->hasUnions) {
+if (sd->ir.irStruct->hasUnions) {
 // build the type of the literal
 std::vector<const llvm::Type*> tys;
 for (unsigned i=0; i<n; ++i) {
 Expression* vx = (Expression*)elements->data[i];
 if (!vx) continue;

Mercurial > projects > ldc

comparison gen/toir.cpp @ 173:db9890b3fb64 trunk