projects/ldc: gen/toir.cpp comparison

comparison gen/toir.cpp @ 486:a34078905d01

Added pragma(llvmdc, "string") for misc per-module compiler configuration, currently "string" can only be "verbose" which forces -vv for module it appears in. Reimplemented support for nested functions/class using a new approach. Added error on taking address of intrinsic. Fixed problems with the ->syntaxCopy of TypeFunction delegate exp. Removed DtoDType and replaced all uses with ->toBasetype() instead. Removed unused inplace stuff. Fixed a bunch of issues in the runtime unittests, not complete yet. Added mini tests.

author	Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
date	Sun, 10 Aug 2008 08:37:38 +0200
parents	50f6e2337a6b
children	d7b2e8777e2b

comparison

equal deleted inserted replaced

-:50f6e2337a6b
+:a34078905d01
 return new DVarValue(type, vd, cid->cd->ir.irStruct->classInfo, true);
 }
 // nested variable
 else if (vd->nestedref) {
 Logger::println("nested variable");
-return DtoNestedVariable(type, vd);
+return DtoNestedVariable(loc, type, vd);
 }
 // function parameter
 else if (vd->isParameter()) {
 Logger::println("function param");
 FuncDeclaration* fd = vd->toParent2()->isFuncDeclaration();
 if (fd && fd != p->func()->decl) {
 Logger::println("nested parameter");
-return DtoNestedVariable(type, vd);
+return DtoNestedVariable(loc, type, vd);
 }
 else if (vd->isRef() || vd->isOut() || DtoIsPassedByRef(vd->type) || llvm::isa<llvm::AllocaInst>(vd->ir.getIrValue())) {
 return new DVarValue(type, vd, vd->ir.getIrValue(), true);
 }
 else if (llvm::isa<llvm::Argument>(vd->ir.getIrValue())) {
 return new DFuncValue(fdecl, func);
 }
 else if (SymbolDeclaration* sdecl = var->isSymbolDeclaration())
 {
 // this seems to be the static initialiser for structs
-Type* sdecltype = DtoDType(sdecl->type);
+Type* sdecltype = sdecl->type->toBasetype();
 Logger::print("Sym: type=%s\n", sdecltype->toChars());
 assert(sdecltype->ty == Tstruct);
 TypeStruct* ts = (TypeStruct*)sdecltype;
 assert(ts->sym);
 DtoForceConstInitDsymbol(ts->sym);
 Logger::print("VarExp::toConstElem: %s | %s\n", toChars(), type->toChars());
 LOG_SCOPE;
 if (SymbolDeclaration* sdecl = var->isSymbolDeclaration())
 {
 // this seems to be the static initialiser for structs
-Type* sdecltype = DtoDType(sdecl->type);
+Type* sdecltype = sdecl->type->toBasetype();
 Logger::print("Sym: type=%s\n", sdecltype->toChars());
 assert(sdecltype->ty == Tstruct);
 TypeStruct* ts = (TypeStruct*)sdecltype;
 DtoForceConstInitDsymbol(ts->sym);
 assert(ts->sym->ir.irStruct->constInit);
 LLConstant* RealExp::toConstElem(IRState* p)
 {
 Logger::print("RealExp::toConstElem: %s | %s\n", toChars(), type->toChars());
 LOG_SCOPE;
-Type* t = DtoDType(type);
+Type* t = type->toBasetype();
 return DtoConstFP(t, value);
 }
 //////////////////////////////////////////////////////////////////////////////////////////
 Logger::print("ComplexExp::toElem(): %s | %s\n", toChars(), type->toChars());
 LOG_SCOPE;
 LLConstant* c = toConstElem(p);
 if (c->isNullValue()) {
-Type* t = DtoDType(type);
+Type* t = type->toBasetype();
 if (t->ty == Tcomplex32)
 c = DtoConstFP(Type::tfloat32, 0);
 else if (t->ty == Tcomplex64)
 c = DtoConstFP(Type::tfloat64, 0);
 else if (t->ty == Tcomplex80)
 DValue* StringExp::toElem(IRState* p)
 {
 Logger::print("StringExp::toElem: %s | %s\n", toChars(), type->toChars());
 LOG_SCOPE;
-Type* dtype = DtoDType(type);
+Type* dtype = type->toBasetype();
-Type* cty = DtoDType(dtype->next);
+Type* cty = dtype->next->toBasetype();
 const LLType* ct = DtoTypeNotVoid(cty);
 //printf("ct = %s\n", type->next->toChars());
 const LLArrayType* at = LLArrayType::get(ct,len+1);
 LLConstant* StringExp::toConstElem(IRState* p)
 {
 Logger::print("StringExp::toConstElem: %s | %s\n", toChars(), type->toChars());
 LOG_SCOPE;
-Type* t = DtoDType(type);
+Type* t = type->toBasetype();
-Type* cty = DtoDType(t->next);
+Type* cty = t->next->toBasetype();
 bool nullterm = (t->ty != Tsarray);
 size_t endlen = nullterm ? len+1 : len;
 const LLType* ct = DtoType(cty);
 DtoAssign(loc, l, r);
 if (l->isSlice() || l->isComplex())
 return l;
+#if 0
+if (type->toBasetype()->ty == Tstruct && e2->type->isintegral())
+{
+// handle struct = 0;
+return l;
+}
+else
+{
+return r;
+}
+#else
 return r;
+#endif
 }
 //////////////////////////////////////////////////////////////////////////////////////////
 DValue* AddExp::toElem(IRState* p)
 LOG_SCOPE;
 DValue* l = e1->toElem(p);
 DValue* r = e2->toElem(p);
-Type* t = DtoDType(type);
+Type* t = type->toBasetype();
-Type* e1type = DtoDType(e1->type);
+Type* e1type = e1->type->toBasetype();
-Type* e1next = e1type->next ? DtoDType(e1type->next) : NULL;
+Type* e1next = e1type->next ? e1type->next->toBasetype() : NULL;
-Type* e2type = DtoDType(e2->type);
+Type* e2type = e2->type->toBasetype();
 if (e1type != e2type) {
 if (llvmFieldIndex) {
 assert(e1type->ty == Tpointer && e1next && e1next->ty == Tstruct);
 Logger::println("add to AddrExp of struct");
 LOG_SCOPE;
 DValue* l = e1->toElem(p);
 DValue* r = e2->toElem(p);
-Type* t = DtoDType(type);
+Type* t = type->toBasetype();
 DValue* res;
-if (DtoDType(e1->type)->ty == Tpointer) {
+if (e1->type->toBasetype()->ty == Tpointer) {
 LLValue* gep = llvm::GetElementPtrInst::Create(l->getRVal(),r->getRVal(),"tmp",p->scopebb());
 res = new DImValue(type, gep);
 }
 else if (t->iscomplex()) {
 res = DtoComplexAdd(loc, e1->type, l, r);
 LOG_SCOPE;
 DValue* l = e1->toElem(p);
 DValue* r = e2->toElem(p);
-Type* t = DtoDType(type);
+Type* t = type->toBasetype();
-Type* t1 = DtoDType(e1->type);
+Type* t1 = e1->type->toBasetype();
-Type* t2 = DtoDType(e2->type);
+Type* t2 = e2->type->toBasetype();
 if (t1->ty == Tpointer && t2->ty == Tpointer) {
 LLValue* lv = l->getRVal();
 LLValue* rv = r->getRVal();
 Logger::cout() << "lv: " << *lv << " rv: " << *rv << '\n';
 LOG_SCOPE;
 DValue* l = e1->toElem(p);
 DValue* r = e2->toElem(p);
-Type* t = DtoDType(type);
+Type* t = type->toBasetype();
 DValue* res;
-if (DtoDType(e1->type)->ty == Tpointer) {
+if (e1->type->toBasetype()->ty == Tpointer) {
 Logger::println("ptr");
 LLValue* tmp = r->getRVal();
 LLValue* zero = llvm::ConstantInt::get(tmp->getType(),0,false);
 tmp = llvm::BinaryOperator::createSub(zero,tmp,"tmp",p->scopebb());
 tmp = llvm::GetElementPtrInst::Create(l->getRVal(),tmp,"tmp",p->scopebb());
 else if (fndecl->llvmInternal == LLVMalloca) {
 Expression* exp = (Expression*)arguments->data[0];
 DValue* expv = exp->toElem(p);
 if (expv->getType()->toBasetype()->ty != Tint32)
 expv = DtoCast(loc, expv, Type::tint32);
-return new DImValue(type, DtoAlloca(LLType::Int8Ty, expv->getRVal(), ".alloca"));
+return new DImValue(type, p->ir->CreateAlloca(LLType::Int8Ty, expv->getRVal(), ".alloca"));
 }
 }
 return DtoCallFunction(loc, type, fnval, arguments);
 }
 LLConstant* AddrExp::toConstElem(IRState* p)
 {
 assert(e1->op == TOKvar);
 VarExp* vexp = (VarExp*)e1;
+if (vexp->var->needThis())
+{
+error("need 'this' to access %s", vexp->var->toChars());
+fatal();
+}
 // global variable
 if (VarDeclaration* vd = vexp->var->isVarDeclaration())
 {
 LLConstant* llc = llvm::dyn_cast<LLConstant>(vd->ir.getIrValue());
 assert(llc);
 Logger::print("DotVarExp::toElem: %s | %s\n", toChars(), type->toChars());
 LOG_SCOPE;
 DValue* l = e1->toElem(p);
-Type* t = DtoDType(type);
+Type* t = type->toBasetype();
-Type* e1type = DtoDType(e1->type);
+Type* e1type = e1->type->toBasetype();
 //Logger::println("e1type=%s", e1type->toChars());
 //Logger::cout() << *DtoType(e1type) << '\n';
 if (VarDeclaration* vd = var->isVarDeclaration()) {
 LLValue* arrptr;
 if (e1type->ty == Tpointer) {
 assert(e1type->next->ty == Tstruct);
 TypeStruct* ts = (TypeStruct*)e1type->next;
+Logger::println("Struct member offset:%d", vd->offset);
+LLValue* src = l->getRVal();
+DStructIndexVector vdoffsets;
+arrptr = DtoIndexStruct(src, ts->sym, vd->type, vd->offset, vdoffsets);
+}
+// happens for tuples
+else if (e1type->ty == Tstruct) {
+TypeStruct* ts = (TypeStruct*)e1type;
 Logger::println("Struct member offset:%d", vd->offset);
 LLValue* src = l->getRVal();
 DStructIndexVector vdoffsets;
 assert(fdecl->vtblIndex > 0);
 assert(e1type->ty == Tclass);
 LLValue* zero = llvm::ConstantInt::get(LLType::Int32Ty, 0, false);
 LLValue* vtblidx = llvm::ConstantInt::get(LLType::Int32Ty, (size_t)fdecl->vtblIndex, false);
-//Logger::cout() << "vthis: " << *vthis << '\n';
+Logger::cout() << "vthis: " << *vthis << '\n';
 funcval = DtoGEP(vthis, zero, zero);
 funcval = DtoLoad(funcval);
 funcval = DtoGEP(funcval, zero, vtblidx, toChars());
 funcval = DtoLoad(funcval);
 #if OPAQUE_VTBLS
 // this seems to happen for dmd generated assert statements like:
 //      assert(this, "null this");
 // FIXME: check for TOKthis in AssertExp instead
 if (!var)
 {
-LLValue* v = p->func()->thisVar;
+LLValue* v = p->func()->thisArg;
 assert(v);
 return new DVarValue(type, v, true);
 }
 // regular this expr
 else if (VarDeclaration* vd = var->isVarDeclaration()) {
 LLValue* v;
 if (vd->toParent2() != p->func()->decl) {
 Logger::println("nested this exp");
-return DtoNestedVariable(type, vd);
+return DtoNestedVariable(loc, type, vd);
 }
 else {
 Logger::println("normal this exp");
-v = p->func()->decl->ir.irFunc->thisVar;
+v = p->func()->thisArg;
 }
 return new DVarValue(type, vd, v, true);
 }
 // anything we're not yet handling ?
 Logger::print("IndexExp::toElem: %s | %s\n", toChars(), type->toChars());
 LOG_SCOPE;
 DValue* l = e1->toElem(p);
-Type* e1type = DtoDType(e1->type);
+Type* e1type = e1->type->toBasetype();
 p->arrays.push_back(l); // if $ is used it must be an array so this is fine.
 DValue* r = e2->toElem(p);
 p->arrays.pop_back();
 LOG_SCOPE;
 DValue* l = e1->toElem(p);
 DValue* r = e2->toElem(p);
-Type* t = DtoDType(e1->type);
+Type* t = e1->type->toBasetype();
-Type* e2t = DtoDType(e2->type);
+Type* e2t = e2->type->toBasetype();
 assert(DtoType(t) == DtoType(e2t));
 LLValue* eval = 0;
 if (t->isintegral() || t->ty == Tpointer)
 LOG_SCOPE;
 DValue* l = e1->toElem(p);
 DValue* r = e2->toElem(p);
-Type* t = DtoDType(e1->type);
+Type* t = e1->type->toBasetype();
-Type* e2t = DtoDType(e2->type);
+Type* e2t = e2->type->toBasetype();
 //assert(t == e2t);
 LLValue* eval = 0;
 if (t->isintegral() || t->ty == Tpointer)
 DValue* r = e2->toElem(p);
 LLValue* val = l->getRVal();
 LLValue* post = 0;
-Type* e1type = DtoDType(e1->type);
+Type* e1type = e1->type->toBasetype();
-Type* e2type = DtoDType(e2->type);
+Type* e2type = e2->type->toBasetype();
 if (e1type->isintegral())
 {
 assert(e2type->isintegral());
 LLValue* one = llvm::ConstantInt::get(val->getType(), 1, !e2type->isunsigned());
 else
 assert(post);
 DtoStore(post,l->getLVal());
-return new DImValue(type,val,true);
+return new DImValue(type,val);
 }
 //////////////////////////////////////////////////////////////////////////////////////////
 DValue* NewExp::toElem(IRState* p)
 {
 Logger::print("NewExp::toElem: %s | %s\n", toChars(), type->toChars());
 LOG_SCOPE;
 assert(newtype);
-Type* ntype = DtoDType(newtype);
+Type* ntype = newtype->toBasetype();
 // new class
 if (ntype->ty == Tclass) {
 Logger::println("new class");
-return DtoNewClass((TypeClass*)ntype, this);
+return DtoNewClass(loc, (TypeClass*)ntype, this);
 }
 // new dynamic array
 else if (ntype->ty == Tarray)
 {
 Logger::println("new dynamic array: %s", newtype->toChars());
 }
 else {
 assert(ts->sym);
 DtoAggrCopy(mem,ts->sym->ir.irStruct->init);
 }
-return new DImValue(type, mem, false);
+return new DImValue(type, mem);
 }
 // new basic type
 else
 {
 // allocate
 Expression* exp = newtype->defaultInit(loc);
 DValue* iv = exp->toElem(gIR);
 DtoAssign(loc, &tmpvar, iv);
 // return as pointer-to
-return new DImValue(type, mem, false);
+return new DImValue(type, mem);
 }
 assert(0);
 }
 {
 Logger::print("DeleteExp::toElem: %s | %s\n", toChars(), type->toChars());
 LOG_SCOPE;
 DValue* dval = e1->toElem(p);
-Type* et = DtoDType(e1->type);
+Type* et = e1->type->toBasetype();
 // simple pointer
 if (et->ty == Tpointer)
 {
 LLValue* rval = dval->getRVal();
 LLValue* lval = DtoAlloca(DtoType(type), "tmpdelegate");
 DValue* u = e1->toElem(p);
 LLValue* uval;
 if (DFuncValue* f = u->isFunc()) {
 assert(f->func);
-LLValue* contextptr = DtoNestedContext(f->func->toParent2()->isFuncDeclaration());
+LLValue* contextptr;
-if (!contextptr)
+if (p->func()->decl == f->func)
-uval = LLConstant::getNullValue(getVoidPtrType());
+contextptr = p->func()->thisArg;
 else
-uval = DtoBitCast(contextptr, getVoidPtrType());
+contextptr = DtoNestedContext(loc, f->func);
+uval = DtoBitCast(contextptr, getVoidPtrType());
 }
 else {
 DValue* src = u;
 if (ClassDeclaration* cd = u->getType()->isClassHandle())
 {
 DValue* CondExp::toElem(IRState* p)
 {
 Logger::print("CondExp::toElem: %s | %s\n", toChars(), type->toChars());
 LOG_SCOPE;
-Type* dtype = DtoDType(type);
+Type* dtype = type->toBasetype();
 const LLType* resty = DtoType(dtype);
 // allocate a temporary for the final result. failed to come up with a better way :/
 llvm::BasicBlock* entryblock = &p->topfunc()->front();
 LLValue* resval = DtoAlloca(resty,"condtmp");
 if (type->iscomplex()) {
 return DtoComplexNeg(loc, type, l);
 }
 LLValue* val = l->getRVal();
-Type* t = DtoDType(type);
+Type* t = type->toBasetype();
 LLValue* zero = 0;
 if (t->isintegral())
 zero = llvm::ConstantInt::get(val->getType(), 0, true);
 else if (t->isfloating()) {
 DValue* CatExp::toElem(IRState* p)
 {
 Logger::print("CatExp::toElem: %s | %s\n", toChars(), type->toChars());
 LOG_SCOPE;
-Type* t = DtoDType(type);
+Type* t = type->toBasetype();
-bool arrNarr = DtoDType(e1->type) == DtoDType(e2->type);
+bool arrNarr = e1->type->toBasetype() == e2->type->toBasetype();
 // array ~ array
 if (arrNarr)
 {
 return DtoCatArrays(type, e1, e2);
 Logger::print("CatAssignExp::toElem: %s | %s\n", toChars(), type->toChars());
 LOG_SCOPE;
 DValue* l = e1->toElem(p);
-Type* e1type = DtoDType(e1->type);
+Type* e1type = e1->type->toBasetype();
-Type* elemtype = DtoDType(e1type->next);
+Type* elemtype = e1type->next->toBasetype();
-Type* e2type = DtoDType(e2->type);
+Type* e2type = e2->type->toBasetype();
 if (e2type == elemtype) {
 DSliceValue* slice = DtoCatAssignElement(l,e2);
 DtoAssign(loc, l, slice);
 }
 const LLType* dgty = DtoType(type);
 LLValue* lval = DtoAlloca(dgty,"dgstorage");
 LLValue* context = DtoGEPi(lval,0,0);
-const LLPointerType* pty = isaPointer(context->getType()->getContainedType(0));
+LLValue* cval;
-LLValue* llvmNested = p->func()->decl->ir.irFunc->nestedVar;
+IrFunction* irfn = p->func();
-if (llvmNested == NULL) {
+if (irfn->nestedVar)
-LLValue* nullcontext = llvm::ConstantPointerNull::get(pty);
+cval = irfn->nestedVar;
-DtoStore(nullcontext, context);
+else if (irfn->nestArg)
-}
+cval = irfn->nestArg;
-else {
+else
-LLValue* nestedcontext = DtoBitCast(llvmNested, pty);
+cval = getNullPtr(getVoidPtrType());
-DtoStore(nestedcontext, context);
+cval = DtoBitCast(cval, context->getType()->getContainedType(0));
-}
+DtoStore(cval, context);
 LLValue* fptr = DtoGEPi(lval,0,1,"tmp",p->scopebb());
 assert(fd->ir.irFunc->func);
 LLValue* castfptr = DtoBitCast(fd->ir.irFunc->func, fptr->getType()->getContainedType(0));
 DtoStore(castfptr, fptr);
 // is dynamic ?
 bool dyn = (arrayType->ty == Tarray);
 // length
 size_t len = elements->dim;
-// store into slice?
-bool sliceInPlace = false;
 // llvm target type
 const LLType* llType = DtoType(arrayType);
 Logger::cout() << (dyn?"dynamic":"static") << " array literal with length " << len << " of D type: '" << arrayType->toChars() << "' has llvm type: '" << *llType << "'\n";
 LLValue* elemAddr = DtoGEPi(dstMem,0,i,"tmp",p->scopebb());
 // emulate assignment
 DVarValue* vv = new DVarValue(expr->type, elemAddr, true);
 DValue* e = expr->toElem(p);
-DImValue* im = e->isIm();
+DtoAssign(loc, vv, e);
-if (!im || !im->inPlace()) {
-DtoAssign(loc, vv, e);
-}
 }
 // return storage directly ?
-if (!dyn || (dyn && sliceInPlace))
+if (!dyn)
-return new DImValue(type, dstMem, false);
+return new DImValue(type, dstMem);
 // wrap in a slice
 return new DSliceValue(type, DtoConstSize_t(len), DtoGEPi(dstMem,0,0,"tmp"));
 }
 //////////////////////////////////////////////////////////////////////////////////////////
 Logger::cout() << "getting index " << j << " of " << *sptr << '\n';
 LLValue* arrptr = DtoGEPi(sptr,0,j);
 DValue* darrptr = new DVarValue(vx->type, arrptr, true);
 DValue* ve = vx->toElem(p);
+DtoAssign(loc, darrptr, ve);
-if (!ve->inPlace())
-DtoAssign(loc, darrptr, ve);
 j++;
 }
 return new DImValue(type, sptr);
 {
 Expression* vx = (Expression*)elements->data[i];
 vals[i] = vx->toConstElem(p);
 }
-assert(DtoDType(type)->ty == Tstruct);
+assert(type->toBasetype()->ty == Tstruct);
 const LLType* t = DtoType(type);
 const LLStructType* st = isaStruct(t);
 return llvm::ConstantStruct::get(st,vals);
 }
 assert(keys);
 assert(values);
 assert(keys->dim == values->dim);
-Type* aatype = DtoDType(type);
+Type* aatype = type->toBasetype();
 Type* vtype = aatype->next;
 const LLType* aalltype = DtoType(type);
 // it should be possible to avoid the temporary in some cases
 LLValue* tmp = DtoAlloca(aalltype,"aaliteral");

Mercurial > projects > ldc

comparison gen/toir.cpp @ 486:a34078905d01