projects/ldc: gen/tollvm.cpp comparison

comparison gen/tollvm.cpp @ 104:4d1e9eb001e0 trunk

[svn r108] Now basic suppport for complex types. =,+,-,*,/ are supported.

author	lindquist
date	Mon, 19 Nov 2007 02:58:58 +0100
parents	855adfdb8d38
children	5b5194b25f33

comparison

equal deleted inserted replaced

-:855adfdb8d38
+:4d1e9eb001e0
 #include "gen/dvalue.h"
 #include "gen/functions.h"
 #include "gen/structs.h"
 #include "gen/classes.h"
 #include "gen/typeinf.h"
+#include "gen/complex.h"
 bool DtoIsPassedByRef(Type* type)
 {
-TY t = DtoDType(type)->ty;
+Type* typ = DtoDType(type);
-return (t == Tstruct || t == Tarray || t == Tdelegate || t == Tsarray);
+TY t = typ->ty;
+return (t == Tstruct || t == Tarray || t == Tdelegate || t == Tsarray || typ->iscomplex());
 }
 Type* DtoDType(Type* t)
 {
 if (t->ty == Ttypedef) {
 case Timaginary80:
 return llvm::Type::DoubleTy;
 // complex
 case Tcomplex32:
-return DtoComplexType(llvm::Type::FloatTy);
 case Tcomplex64:
 case Tcomplex80:
-return DtoComplexType(llvm::Type::DoubleTy);
+return DtoComplexType(t);
 // pointers
 case Tpointer: {
 assert(t->next);
 if (t->next->ty == Tvoid)
 const llvm::Type* funcptr = llvm::PointerType::get(func);
 std::vector<const llvm::Type*> types;
 types.push_back(i8ptr);
 types.push_back(funcptr);
-return llvm::StructType::get(types);
-}
-//////////////////////////////////////////////////////////////////////////////////////////
-const llvm::StructType* DtoComplexType(const llvm::Type* base)
-{
-std::vector<const llvm::Type*> types;
-types.push_back(base);
-types.push_back(base);
 return llvm::StructType::get(types);
 }
 //////////////////////////////////////////////////////////////////////////////////////////
 // regular class ref -> class ref assignment
 else {
 DtoStore(rhs->getRVal(), lhs->getLVal());
 }
 }
+else if (t->iscomplex()) {
+assert(!lhs->isComplex());
+if (DComplexValue* cx = rhs->isComplex()) {
+DtoComplexSet(lhs->getRVal(), cx->re, cx->im);
+}
+else {
+DtoComplexAssign(lhs->getRVal(), rhs->getRVal());
+}
+}
 else {
 llvm::Value* r = rhs->getRVal();
 llvm::Value* l = lhs->getLVal();
 Logger::cout() << "assign\nlhs: " << *l << "rhs: " << *r << '\n';
 const llvm::Type* lit = l->getType()->getContainedType(0);
 return new DImValue(to, rval);
 }
 DValue* DtoCastFloat(DValue* val, Type* to)
 {
+if (val->getType() == to)
+return val;
 const llvm::Type* tolltype = DtoType(to);
 Type* totype = DtoDType(to);
 Type* fromtype = DtoDType(val->getType());
 assert(fromtype->isfloating());
 size_t fromsz = fromtype->size();
 size_t tosz = totype->size();
 llvm::Value* rval;
-if (totype->isfloating()) {
+if (totype->iscomplex()) {
+assert(0);
+//return new DImValue(to, DtoComplex(to, val));
+}
+else if (totype->isfloating()) {
 if ((fromtype->ty == Tfloat80 || fromtype->ty == Tfloat64) && (totype->ty == Tfloat80 || totype->ty == Tfloat64)) {
 rval = val->getRVal();
 }
 else if (fromsz < tosz) {
 rval = new llvm::FPExtInst(val->getRVal(), tolltype, "tmp", gIR->scopebb());
 else {
 assert(0 && "bad float cast");
 }
 return new DImValue(to, rval);
+}
+DValue* DtoCastComplex(DValue* val, Type* _to)
+{
+Type* to = DtoDType(_to);
+llvm::Value* v = val->getRVal();
+if (to->iscomplex()) {
+assert(0);
+}
+else if (to->isimaginary()) {
+DImValue* im = new DImValue(to, gIR->ir->CreateExtractElement(v, DtoConstUint(1), "im"));
+return DtoCastFloat(im, to);
+}
+else if (to->isfloating()) {
+DImValue* re = new DImValue(to, gIR->ir->CreateExtractElement(v, DtoConstUint(0), "re"));
+return DtoCastFloat(re, to);
+}
+else
+assert(0);
 }
 DValue* DtoCastClass(DValue* val, Type* _to)
 {
 const llvm::Type* tolltype = DtoType(_to);
 {
 Type* fromtype = DtoDType(val->getType());
 if (fromtype->isintegral()) {
 return DtoCastInt(val, to);
 }
+else if (fromtype->iscomplex()) {
+return DtoCastComplex(val, to);
+}
 else if (fromtype->isfloating()) {
 return DtoCastFloat(val, to);
 }
 else if (fromtype->ty == Tclass) {
 return DtoCastClass(val, to);
 }
 llvm::Constant* DtoConstBool(bool b)
 {
 return llvm::ConstantInt::get(llvm::Type::Int1Ty, b, false);
 }
+llvm::ConstantFP* DtoConstFP(Type* t, long double value)
+{
+TY ty = DtoDType(t)->ty;
+if (ty == Tfloat32 || ty == Timaginary32)
+return llvm::ConstantFP::get(llvm::Type::FloatTy, float(value));
+else if (ty == Tfloat64 || ty == Timaginary64 || ty == Tfloat80 || ty == Timaginary80)
+return llvm::ConstantFP::get(llvm::Type::DoubleTy, double(value));
+}
 //////////////////////////////////////////////////////////////////////////////////////////
 llvm::Constant* DtoConstString(const char* str)
 {
 return ptr->getType()->getContainedType(0)->isFirstClassType();
 }
 return false;
 }
+//////////////////////////////////////////////////////////////////////////////////////////
 llvm::Value* DtoBitCast(llvm::Value* v, const llvm::Type* t)
 {
 if (v->getType() == t)
 return v;
 return gIR->ir->CreateBitCast(v, t, "tmp");
 }
+//////////////////////////////////////////////////////////////////////////////////////////
 const llvm::PointerType* isaPointer(llvm::Value* v)
 {
 return llvm::dyn_cast<llvm::PointerType>(v->getType());
 }

Mercurial > projects > ldc

comparison gen/tollvm.cpp @ 104:4d1e9eb001e0 trunk