projects/ldc: gen/toir.cpp comparison

comparison gen/toir.cpp @ 96:ce7ed8f59b99 trunk

[svn r100] Moved test/ray.d to demos/ray.d. Cleanups.

author	lindquist
date	Mon, 12 Nov 2007 07:58:44 +0100
parents	61615fa85940
children	c4e161556a21

comparison

equal deleted inserted replaced

-:71b8fecdae38
+:ce7ed8f59b99
 #include "gen/llvm.h"
 #include "total.h"
 #include "init.h"
-#include "symbol.h"
 #include "mtype.h"
 #include "hdrgen.h"
 #include "port.h"
 #include "gen/irstate.h"
-#include "gen/elem.h"
 #include "gen/logger.h"
 #include "gen/tollvm.h"
 #include "gen/runtime.h"
 #include "gen/arrays.h"
 #include "gen/structs.h"
 llvm::Constant* IntegerExp::toConstElem(IRState* p)
 {
 Logger::print("IntegerExp::toConstElem: %s | %s\n", toChars(), type->toChars());
 LOG_SCOPE;
 const llvm::Type* t = DtoType(type);
-if (llvm::isa<llvm::PointerType>(t)) {
+if (isaPointer(t)) {
 Logger::println("pointer");
 llvm::Constant* i = llvm::ConstantInt::get(DtoSize_t(),(uint64_t)value,false);
 return llvm::ConstantExpr::getIntToPtr(i, t);
 }
 assert(llvm::isa<llvm::IntegerType>(t));
 {
 Logger::print("NullExp::toConstElem(type=%s): %s\n", type->toChars(),toChars());
 LOG_SCOPE;
 const llvm::Type* t = DtoType(type);
 if (type->ty == Tarray) {
-assert(llvm::isa<llvm::StructType>(t));
+assert(isaStruct(t));
 return llvm::ConstantAggregateZero::get(t);
 }
 else {
 return llvm::Constant::getNullValue(t);
 }
 return DtoBinSub(l,r);
 }
 /*
 llvm::Value* left = l->getValue();
-if (llvm::isa<llvm::PointerType>(left->getType()))
+if (isaPointer(left->getType()))
 left = new llvm::PtrToIntInst(left,DtoSize_t(),"tmp",p->scopebb());
 llvm::Value* right = r->getValue();
-if (llvm::isa<llvm::PointerType>(right->getType()))
+if (isaPointer(right->getType()))
 right = new llvm::PtrToIntInst(right,DtoSize_t(),"tmp",p->scopebb());
 e->val = llvm::BinaryOperator::createSub(left,right,"tmp",p->scopebb());
 e->type = DValue::VAL;
 const llvm::Type* totype = DtoType(type);
 if (e->val->getType() != totype) {
 assert(0);
-assert(llvm::isa<llvm::PointerType>(e->val->getType()));
+assert(isaPointer(e->val->getType()));
 assert(llvm::isa<llvm::IntegerType>(totype));
 e->val = new llvm::IntToPtrInst(e->val,totype,"tmp",p->scopebb());
 }
 delete l;
 DValue* expelem = exp->toElem(p);
 Type* t = DtoDType(type);
 const llvm::Type* llt = DtoType(type);
 if (DtoIsPassedByRef(t))
 llt = llvm::PointerType::get(llt);
+// TODO
+if (strcmp(global.params.llvmArch, "x86") != 0) {
+warning("va_arg for C variadic functions is broken for anything but x86");
+}
 return new DImValue(type, p->ir->CreateVAArg(expelem->getLVal(),llt,"tmp"));
 }
 else if (fndecl->llvmInternal == LLVMalloca) {
 //Argument* fnarg = Argument::getNth(tf->parameters, 0);
 Expression* exp = (Expression*)arguments->data[0];
 // normal function call
 if (llvm::isa<llvm::FunctionType>(funcval->getType())) {
 llfnty = llvm::cast<llvm::FunctionType>(funcval->getType());
 }
 // pointer to something
-else if (llvm::isa<llvm::PointerType>(funcval->getType())) {
+else if (isaPointer(funcval->getType())) {
 // pointer to function pointer - I think this not really supposed to happen, but does :/
 // seems like sometimes we get a func* other times a func**
-if (llvm::isa<llvm::PointerType>(funcval->getType()->getContainedType(0))) {
+if (isaPointer(funcval->getType()->getContainedType(0))) {
 funcval = new llvm::LoadInst(funcval,"tmp",p->scopebb());
 }
 // function pointer
 if (llvm::isa<llvm::FunctionType>(funcval->getType()->getContainedType(0))) {
 //Logger::cout() << "function pointer type:\n" << *funcval << '\n';
 llfnty = llvm::cast<llvm::FunctionType>(funcval->getType()->getContainedType(0));
 }
 // struct pointer - delegate
-else if (llvm::isa<llvm::StructType>(funcval->getType()->getContainedType(0))) {
+else if (isaStruct(funcval->getType()->getContainedType(0))) {
 funcval = DtoGEP(funcval,zero,one,"tmp",p->scopebb());
 funcval = new llvm::LoadInst(funcval,"tmp",p->scopebb());
 const llvm::Type* ty = funcval->getType()->getContainedType(0);
 llfnty = llvm::cast<llvm::FunctionType>(ty);
 }
 // hidden struct return arguments
 if (retinptr) {
 if (topexp && topexp->e2 == this) {
 assert(topexp->v);
 llvm::Value* tlv = topexp->v->getLVal();
-assert(llvm::isa<llvm::StructType>(tlv->getType()->getContainedType(0)));
+assert(isaStruct(tlv->getType()->getContainedType(0)));
 llargs[j] = tlv;
 if (DtoIsPassedByRef(tf->next)) {
 isInPlace = true;
 }
 else
 const llvm::StructType* vtype = llvm::StructType::get(vtypes);
 llvm::Value* mem = new llvm::AllocaInst(vtype,"_argptr_storage",p->topallocapoint());
 for (unsigned i=0; i<vtype->getNumElements(); ++i)
 p->ir->CreateStore(vvalues[i], DtoGEPi(mem,0,i,"tmp"));
-//llvm::Constant* typeinfoparam = llvm::ConstantPointerNull::get(llvm::cast<llvm::PointerType>(llfnty->getParamType(j)));
+//llvm::Constant* typeinfoparam = llvm::ConstantPointerNull::get(isaPointer(llfnty->getParamType(j)));
 assert(Type::typeinfo->llvmInitZ);
 const llvm::Type* typeinfotype = llvm::PointerType::get(Type::typeinfo->llvmInitZ->getType());
 Logger::cout() << "typeinfo ptr type: " << *typeinfotype << '\n';
 const llvm::ArrayType* typeinfoarraytype = llvm::ArrayType::get(typeinfotype,vtype->getNumElements());
 llvm::Value* typeinfomem = new llvm::AllocaInst(typeinfoarraytype,"_arguments_storage",p->topallocapoint());
 }
 else {
 llvm::Value* uval = u->getRVal();
 if (fromtype->ty == Tsarray) {
 Logger::cout() << "uvalTy = " << *uval->getType() << '\n';
-assert(llvm::isa<llvm::PointerType>(uval->getType()));
+assert(isaPointer(uval->getType()));
-const llvm::ArrayType* arrty = llvm::cast<llvm::ArrayType>(uval->getType()->getContainedType(0));
+const llvm::ArrayType* arrty = isaArray(uval->getType()->getContainedType(0));
 rval2 = llvm::ConstantInt::get(DtoSize_t(), arrty->getNumElements(), false);
 rval2 = DtoArrayCastLength(rval2, ety, ptrty->getContainedType(0));
 rval = new llvm::BitCastInst(uval, ptrty, "tmp", p->scopebb());
 }
 else {
 eval = DtoDynArrayIs(op,l,r);
 }
 else {
 llvm::ICmpInst::Predicate pred = (op == TOKidentity) ? llvm::ICmpInst::ICMP_EQ : llvm::ICmpInst::ICMP_NE;
 if (t1->ty == Tpointer && v->isNull() && l->getType() != r->getType()) {
-r = llvm::ConstantPointerNull::get(llvm::cast<llvm::PointerType>(l->getType()));
+r = llvm::ConstantPointerNull::get(isaPointer(l->getType()));
 }
 Logger::cout() << "l = " << *l << " r = " << *r << '\n';
 eval = new llvm::ICmpInst(pred, l, r, "tmp", p->scopebb());
 }
 return new DImValue(type, eval);
 lval = new llvm::AllocaInst(dgty,"dgstorage",p->topallocapoint());
 temp = true;
 }
 llvm::Value* context = DtoGEPi(lval,0,0,"tmp",p->scopebb());
-const llvm::PointerType* pty = llvm::cast<llvm::PointerType>(context->getType()->getContainedType(0));
+const llvm::PointerType* pty = isaPointer(context->getType()->getContainedType(0));
 llvm::Value* llvmNested = p->func().decl->llvmNested;
 if (llvmNested == NULL) {
 llvm::Value* nullcontext = llvm::ConstantPointerNull::get(pty);
 p->ir->CreateStore(nullcontext, context);
 }
 }
 else {
 mem = p->topexp()->v->getLVal();
 }
 assert(mem);
-if (!llvm::isa<llvm::PointerType>(mem->getType()) ||
+if (!isaPointer(mem->getType()) ||
-!llvm::isa<llvm::ArrayType>(mem->getType()->getContainedType(0)))
+!isaArray(mem->getType()->getContainedType(0)))
 {
 assert(ty->ty == Tarray);
 // we need to give this array literal storage
 const llvm::ArrayType* arrty = llvm::ArrayType::get(DtoType(ty->next), elements->dim);
 mem = new llvm::AllocaInst(arrty, "arrayliteral", p->topallocapoint());
 Logger::print("ArrayLiteralExp::toConstElem: %s | %s\n", toChars(), type->toChars());
 LOG_SCOPE;
 const llvm::Type* t = DtoType(type);
 Logger::cout() << "array literal has llvm type: " << *t << '\n';
-assert(llvm::isa<llvm::ArrayType>(t));
+assert(isaArray(t));
-const llvm::ArrayType* arrtype = llvm::cast<llvm::ArrayType>(t);
+const llvm::ArrayType* arrtype = isaArray(t);
 assert(arrtype->getNumElements() == elements->dim);
 std::vector<llvm::Constant*> vals(elements->dim, NULL);
 for (unsigned i=0; i<elements->dim; ++i)
 {
 vals[i] = vx->toConstElem(p);
 }
 assert(DtoDType(type)->ty == Tstruct);
 const llvm::Type* t = DtoType(type);
-const llvm::StructType* st = llvm::cast<llvm::StructType>(t);
+const llvm::StructType* st = isaStruct(t);
 return llvm::ConstantStruct::get(st,vals);
 }
 //////////////////////////////////////////////////////////////////////////////////////////
 }
 int AsmStatement::comeFrom()
 {
 assert(0);
-return FALSE;
+return 0;
 }
 void
 backend_init()
 {

Mercurial > projects > ldc

comparison gen/toir.cpp @ 96:ce7ed8f59b99 trunk