projects/ldc: gen/toir.cpp comparison

comparison gen/toir.cpp @ 585:fbb1a366cfbc

Complex number should now follow the D ABI on x86. They're also treated as first class values now. Big change.

author	Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
date	Tue, 09 Sep 2008 16:49:47 -0700
parents	f0c20d50d4b3
children	23538d0f0d5b

comparison

equal deleted inserted replaced

-:c7d7e2282ba3
+:fbb1a366cfbc
 // _arguments
 if (vd->ident == Id::_arguments && p->func()->_arguments)
 {
 Logger::println("Id::_arguments");
 LLValue* v = p->func()->_arguments;
-return new DVarValue(type, vd, v, true);
+return new DVarValue(type, vd, v);
 }
 // _argptr
 else if (vd->ident == Id::_argptr && p->func()->_argptr)
 {
 Logger::println("Id::_argptr");
 LLValue* v = p->func()->_argptr;
-return new DVarValue(type, vd, v, true);
+return new DVarValue(type, vd, v);
 }
 // _dollar
 else if (vd->ident == Id::dollar)
 {
 Logger::println("Id::dollar");
 assert(!p->arrays.empty());
 LLValue* tmp = DtoArrayLen(p->arrays.back());
-return new DVarValue(type, vd, tmp, false);
+return new DImValue(type, tmp);
 }
 // typeinfo
 else if (TypeInfoDeclaration* tid = vd->isTypeInfoDeclaration())
 {
 Logger::println("TypeInfoDeclaration");
 DtoForceDeclareDsymbol(tid);
 assert(tid->ir.getIrValue());
 const LLType* vartype = DtoType(type);
-LLValue* m;
+LLValue* m = tid->ir.getIrValue();
-if (tid->ir.getIrValue()->getType() != getPtrToType(vartype))
+if (m->getType() != getPtrToType(vartype))
-m = p->ir->CreateBitCast(tid->ir.getIrValue(), vartype, "tmp");
+m = p->ir->CreateBitCast(m, vartype, "tmp");
-else
+return new DImValue(type, m);
-m = tid->ir.getIrValue();
-return new DVarValue(type, vd, m, true);
 }
 // classinfo
 else if (ClassInfoDeclaration* cid = vd->isClassInfoDeclaration())
 {
 Logger::println("ClassInfoDeclaration: %s", cid->cd->toChars());
 DtoForceDeclareDsymbol(cid->cd);
 assert(cid->cd->ir.irStruct->classInfo);
-return new DVarValue(type, vd, cid->cd->ir.irStruct->classInfo, true);
+return new DVarValue(type, vd, cid->cd->ir.irStruct->classInfo);
 }
 // nested variable
 else if (vd->nestedref) {
 Logger::println("nested variable");
 return DtoNestedVariable(loc, type, vd);
 if (fd && fd != p->func()->decl) {
 Logger::println("nested parameter");
 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);
+return new DVarValue(type, vd, vd->ir.getIrValue());
 }
 else if (llvm::isa<llvm::Argument>(vd->ir.getIrValue())) {
 return new DImValue(type, vd->ir.getIrValue());
 }
 else assert(0);
 }
 else {
+Logger::println("a normal variable");
 // take care of forward references of global variables
 if (vd->isDataseg() || (vd->storage_class & STCextern)) {
 vd->toObjFile(0); // TODO: multiobj
 DtoConstInitGlobal(vd);
 }
 if (!vd->ir.isSet() || !vd->ir.getIrValue() || DtoType(vd->type)->isAbstract()) {
 error("global variable %s not resolved", vd->toChars());
 Logger::cout() << "unresolved global had type: " << *DtoType(vd->type) << '\n';
 fatal();
 }
-return new DVarValue(type, vd, vd->ir.getIrValue(), true);
+return new DVarValue(type, vd, vd->ir.getIrValue());
 }
 }
 else if (FuncDeclaration* fdecl = var->isFuncDeclaration())
 {
 Logger::println("FuncDeclaration");
 assert(sdecltype->ty == Tstruct);
 TypeStruct* ts = (TypeStruct*)sdecltype;
 assert(ts->sym);
 DtoForceConstInitDsymbol(ts->sym);
 assert(ts->sym->ir.irStruct->init);
-return new DVarValue(type, ts->sym->ir.irStruct->init, true);
+return new DVarValue(type, ts->sym->ir.irStruct->init);
 }
 else
 {
 assert(0 && "Unimplemented VarExp type");
 }
 DValue* ComplexExp::toElem(IRState* p)
 {
 Logger::print("ComplexExp::toElem(): %s | %s\n", toChars(), type->toChars());
 LOG_SCOPE;
 LLConstant* c = toConstElem(p);
+LLValue* res;
 if (c->isNullValue()) {
 Type* t = type->toBasetype();
 if (t->ty == Tcomplex32)
 c = DtoConstFP(Type::tfloat32, 0);
 c = DtoConstFP(Type::tfloat64, 0);
 else if (t->ty == Tcomplex80)
 c = DtoConstFP(Type::tfloat80, 0);
 else
 assert(0);
-return new DComplexValue(type, c, c);
+res = DtoAggrPair(DtoType(type), c, c);
 }
+else {
-return new DComplexValue(type, c->getOperand(0), c->getOperand(1));
+res = DtoAggrPair(DtoType(type), c->getOperand(0), c->getOperand(1));
+}
+return new DImValue(type, res);
 }
 //////////////////////////////////////////////////////////////////////////////////////////
 LLConstant* ComplexExp::toConstElem(IRState* p)
 if (dtype->ty == Tarray) {
 LLConstant* clen = llvm::ConstantInt::get(DtoSize_t(),len,false);
 LLValue* tmpmem = DtoAlloca(DtoType(dtype),"tempstring");
 DtoSetArray(tmpmem, clen, arrptr);
-return new DVarValue(type, tmpmem, true);
+return new DVarValue(type, tmpmem);
 }
 else if (dtype->ty == Tsarray) {
 const LLType* dstType = getPtrToType(LLArrayType::get(ct, len));
 LLValue* emem = (gvar->getType() == dstType) ? gvar : DtoBitCast(gvar, dstType);
-return new DVarValue(type, emem, true);
+return new DVarValue(type, emem);
 }
 else if (dtype->ty == Tpointer) {
 return new DImValue(type, arrptr);
 }
 if (e1->op == TOKarraylength)
 {
 Logger::println("performing array.length assignment");
 ArrayLengthExp *ale = (ArrayLengthExp *)e1;
 DValue* arr = ale->e1->toElem(p);
-DVarValue arrval(ale->e1->type, arr->getLVal(), true);
+DVarValue arrval(ale->e1->type, arr->getLVal());
 DValue* newlen = e2->toElem(p);
 DSliceValue* slice = DtoResizeDynArray(arrval.getType(), &arrval, newlen);
 DtoAssign(loc, &arrval, slice);
 return newlen;
 }
 DValue* l = e1->toElem(p);
 DValue* r = e2->toElem(p);
 DtoAssign(loc, l, r);
-if (l->isSlice() || l->isComplex())
+if (l->isSlice())
 return l;
 #if 0
 if (type->toBasetype()->ty == Tstruct && e2->type->isintegral())
 {
 Type* e1type = e1->type->toBasetype();
 Type* e1next = e1type->next ? e1type->next->toBasetype() : NULL;
 Type* e2type = e2->type->toBasetype();
 if (e1type != e2type) {
-if (llvmFieldIndex) {
+/*if (llvmFieldIndex) {
 assert(e1type->ty == Tpointer && e1next && e1next->ty == Tstruct);
 Logger::println("add to AddrExp of struct");
 assert(r->isConst());
 llvm::ConstantInt* cofs = llvm::cast<llvm::ConstantInt>(r->isConst()->c);
 TypeStruct* ts = (TypeStruct*)e1next;
 DStructIndexVector offsets;
 LLValue* v = DtoIndexStruct(l->getRVal(), ts->sym, t->next, cofs->getZExtValue(), offsets);
-return new DFieldValue(type, v, true);
+return new DFieldValue(type, v);
 }
-else if (e1type->ty == Tpointer) {
+else*/ if (e1type->ty == Tpointer) {
 Logger::println("add to pointer");
 if (r->isConst()) {
 llvm::ConstantInt* cofs = llvm::cast<llvm::ConstantInt>(r->isConst()->c);
 if (cofs->isZero()) {
 Logger::println("is zero");
 else if (DImValue* im = v->isIm()) {
 Logger::println("is immediate");
 return v;
 }
 Logger::println("is nothing special");
-return new DFieldValue(type, v->getLVal(), false);
+LLValue* lval = v->getLVal();
+Logger::cout() << "lval: " << *lval << '\n';
+return new DImValue(type, v->getLVal());
 }
 LLConstant* AddrExp::toConstElem(IRState* p)
 {
 assert(e1->op == TOKvar);
 Logger::println("PtrExp::toElem: %s | %s", toChars(), type->toChars());
 LOG_SCOPE;
 DValue* a = e1->toElem(p);
-// this should be deterministic but right now lvalue casts don't propagate lvalueness !?!
+// this is *so* ugly.. I'd really like to figure out some way to avoid this badness...
 LLValue* lv = a->getRVal();
 LLValue* v = lv;
-if (DtoCanLoad(v))
+Type* bt = type->toBasetype();
+// we can't load function pointers, but they aren't passed by reference either
+// FIXME: maybe a MayLoad function isn't a bad idea after all ...
+if (!DtoIsPassedByRef(bt) && bt->ty != Tfunction)
 v = DtoLoad(v);
-return new DLRValue(new DVarValue(type, lv, true), new DImValue(type, v));
+return new DLRValue(new DVarValue(type, lv), new DImValue(type, v));
 }
 //////////////////////////////////////////////////////////////////////////////////////////
 DValue* DotVarExp::toElem(IRState* p)
 }
 else
 assert(0);
 //Logger::cout() << "mem: " << *arrptr << '\n';
-return new DVarValue(type, vd, arrptr, true);
+return new DVarValue(type, vd, arrptr);
 }
 else if (FuncDeclaration* fdecl = var->isFuncDeclaration())
 {
 DtoResolveDsymbol(fdecl);
 // FIXME: check for TOKthis in AssertExp instead
 if (!var)
 {
 LLValue* v = p->func()->thisArg;
 assert(v);
-return new DVarValue(type, v, true);
+return new DVarValue(type, v);
 }
 // regular this expr
 else if (VarDeclaration* vd = var->isVarDeclaration()) {
 LLValue* v;
 if (vd->toParent2() != p->func()->decl) {
 }
 else {
 Logger::println("normal this exp");
 v = p->func()->thisArg;
 }
-return new DVarValue(type, vd, v, true);
+return new DVarValue(type, vd, v);
 }
 // anything we're not yet handling ?
 assert(0);
 return 0;
 }
 else {
 Logger::println("invalid index exp! e1type: %s", e1type->toChars());
 assert(0);
 }
-return new DVarValue(type, arrptr, true);
+return new DVarValue(type, arrptr);
 }
 //////////////////////////////////////////////////////////////////////////////////////////
 DValue* SliceExp::toElem(IRState* p)
 // new basic type
 else
 {
 // allocate
 LLValue* mem = DtoNew(newtype);
-DVarValue tmpvar(newtype, mem, true);
+DVarValue tmpvar(newtype, mem);
 // default initialize
 Expression* exp = newtype->defaultInit(loc);
 DValue* iv = exp->toElem(gIR);
 DtoAssign(loc, &tmpvar, iv);
 // simple pointer
 if (et->ty == Tpointer)
 {
 LLValue* rval = dval->getRVal();
 DtoDeleteMemory(rval);
-if (dval->isVar() && dval->isVar()->lval)
+if (dval->isVar())
 DtoStore(llvm::Constant::getNullValue(rval->getType()), dval->getLVal());
 }
 // class
 else if (et->ty == Tclass)
 {
 }
 if (!onstack) {
 LLValue* rval = dval->getRVal();
 DtoDeleteClass(rval);
 }
-if (dval->isVar() && dval->isVar()->lval) {
+if (dval->isVar()) {
 LLValue* lval = dval->getLVal();
 DtoStore(llvm::Constant::getNullValue(lval->getType()->getContainedType(0)), lval);
 }
 }
 // dyn array
 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");
-DVarValue* dvv = new DVarValue(type, resval, true);
+DVarValue* dvv = new DVarValue(type, resval);
 llvm::BasicBlock* oldend = p->scopeend();
 llvm::BasicBlock* condtrue = llvm::BasicBlock::Create("condtrue", gIR->topfunc(), oldend);
 llvm::BasicBlock* condfalse = llvm::BasicBlock::Create("condfalse", gIR->topfunc(), oldend);
 llvm::BasicBlock* condend = llvm::BasicBlock::Create("condend", gIR->topfunc(), oldend);
 fptr = DtoGEPi(lval,0,1,"tmp",p->scopebb());
 LLValue* castfptr = DtoBitCast(fd->ir.irFunc->func, fptr->getType()->getContainedType(0));
 DtoStore(castfptr, fptr);
-return new DVarValue(type, lval, true);
+return new DVarValue(type, lval);
 } else if(fd->tok == TOKfunction) {
-return new DVarValue(type, fd->ir.irFunc->func, false);
+return new DImValue(type, fd->ir.irFunc->func);
 }
 assert(0 && "fd->tok must be TOKfunction or TOKdelegate");
 }
 {
 Expression* expr = (Expression*)elements->data[i];
 LLValue* elemAddr = DtoGEPi(dstMem,0,i,"tmp",p->scopebb());
 // emulate assignment
-DVarValue* vv = new DVarValue(expr->type, elemAddr, true);
+DVarValue* vv = new DVarValue(expr->type, elemAddr);
 DValue* e = expr->toElem(p);
 DtoAssign(loc, vv, e);
 }
 // return storage directly ?
 Expression* vx = (Expression*)elements->data[i];
 if (!vx) continue;
 Logger::cout() << "getting index " << j << " of " << *sptr << '\n';
 LLValue* arrptr = DtoGEPi(sptr,0,j);
-DValue* darrptr = new DVarValue(vx->type, arrptr, true);
+DValue* darrptr = new DVarValue(vx->type, arrptr);
 DValue* ve = vx->toElem(p);
 DtoAssign(loc, darrptr, ve);
 j++;
 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");
-DValue* aa = new DVarValue(type, tmp, true);
+DValue* aa = new DVarValue(type, tmp);
 DtoStore(LLConstant::getNullValue(aalltype), tmp);
 const size_t n = keys->dim;
 for (size_t i=0; i<n; ++i)
 {

Mercurial > projects > ldc

comparison gen/toir.cpp @ 585:fbb1a366cfbc