projects/ldc: gen/toir.cpp comparison

comparison gen/toir.cpp @ 1255:9014d7f0433f

Rewrote runtime struct literal codegen.

author	Tomas Lindquist Olsen <tomas.l.olsen gmail com>
date	Wed, 22 Apr 2009 03:08:28 +0200
parents	01909bd1132c
children	dd135ff697fa

comparison

equal deleted inserted replaced

-:747fdd9245d7
+:9014d7f0433f
 #include "gen/dvalue.h"
 #include "gen/aa.h"
 #include "gen/functions.h"
 #include "gen/todebug.h"
 #include "gen/nested.h"
+#include "gen/utils.h"
 #include "llvm/Support/ManagedStatic.h"
 //////////////////////////////////////////////////////////////////////////////////////////
 return DtoConstSlice(DtoConstSize_t(elements->dim), globalstorePtr);
 }
 //////////////////////////////////////////////////////////////////////////////////////////
+// building a struct literal is pretty much the same as building a default initializer.
+extern size_t add_zeros(std::vector<llvm::Value*>& values, size_t diff);
+extern LLConstant* get_default_initializer(VarDeclaration* vd, Initializer* init);
 DValue* StructLiteralExp::toElem(IRState* p)
 {
 Logger::print("StructLiteralExp::toElem: %s @ %s\n", toChars(), type->toChars());
 LOG_SCOPE;
-// make sure the struct is resolved
+// make sure the struct is fully resolved
 sd->codegen(Type::sir);
-// get inits
+// final list of values to put in the struct
-std::vector<LLValue*> inits(sd->fields.dim, NULL);
+std::vector<LLValue*> initvalues;
+// offset tracker
+size_t offset = 0;
+// align(1) struct S { ... }
+bool packed = sd->type->alignsize() == 1;
+// ready elements data
+assert(elements && "struct literal has null elements");
 size_t nexprs = elements->dim;;
 Expression** exprs = (Expression**)elements->data;
-for (size_t i = 0; i < nexprs; i++)
+// go through fields
-{
+ArrayIter<VarDeclaration> it(sd->fields);
-if (exprs[i])
+for (; !it.done(); it.next())
 {
-DValue* v = exprs[i]->toElem(p);
+VarDeclaration* vd = it.get();
-inits[i] = v->getRVal();
+if (vd->offset < offset)
-// make sure we get inner structs/staticarrays right
+{
-if (DtoIsPassedByRef(v->getType()))
+IF_LOG Logger::println("skipping field: %s %s (+%u)", vd->type->toChars(), vd->toChars(), vd->offset);
-inits[i] = DtoLoad(inits[i]);
+continue;
 }
-}
+IF_LOG Logger::println("using field: %s %s (+%u)", vd->type->toChars(), vd->toChars(), vd->offset);
-// vector of values to build aggregate from
-std::vector<LLValue*> values = DtoStructLiteralValues(sd, inits);
+// get next aligned offset for this field
+size_t alignedoffset = offset;
-// get the struct type from the values
+if (!packed)
-size_t n = values.size();
+{
-std::vector<const LLType*> types(n, NULL);
+size_t alignsize = vd->type->alignsize();
+alignedoffset = (offset + alignsize - 1) & ~(alignsize - 1);
-for (size_t i=0; i<n; i++)
+}
-{
-types[i] = values[i]->getType();
+// insert explicit padding?
-}
+if (alignedoffset < vd->offset)
+{
-const LLStructType* sty = LLStructType::get(types, sd->ir.irStruct->packed);
+add_zeros(initvalues, vd->offset - alignedoffset);
+}
-// allocate storage for the struct literal on the stack
-LLValue* mem = DtoAlloca(sty, "tmpstructliteral");
+// add initializer
+Expression* expr = (it.index < nexprs) ? exprs[it.index] : NULL;
-// put all the values into the storage
+IF_LOG Logger::println("expr: %p", expr);
-for (size_t i=0; i<n; i++)
+if (expr)
 {
-LLValue* ptr = DtoGEPi(mem, 0, i);
+IF_LOG Logger::println("expr = %s", it.index, expr->toChars());
-DtoStore(values[i], ptr);
+LLValue* v = DtoExprValue(vd->type, expr);
-}
+initvalues.push_back(v);
+}
-// cast the alloca pointer to the "formal" struct type
+else
-const LLType* structtype = DtoType(sd->type);
+{
-mem = DtoBitCast(mem, getPtrToType(structtype));
+IF_LOG Logger::println("using default initializer");
+initvalues.push_back(get_default_initializer(vd, NULL));
+}
+// advance offset to right past this field
+offset = vd->offset + vd->type->size();
+}
+// tail padding?
+if (offset < sd->structsize)
+{
+add_zeros(initvalues, sd->structsize - offset);
+}
+// build type
+std::vector<const LLType*> valuetypes;
+size_t n = initvalues.size();
+valuetypes.reserve(n);
+for (size_t i = 0; i < n; i++)
+{
+valuetypes.push_back(initvalues[i]->getType());
+}
+const LLType* st = llvm::StructType::get(valuetypes, packed);
+// alloca a stack slot
+LLValue* mem = DtoAlloca(st, ".structliteral");
+// fill in values
+for (size_t i = 0; i < n; i++)
+{
+LLValue* addr = DtoGEPi(mem, 0, i);
+p->ir->CreateStore(initvalues[i], addr);
+}
+// cast to default struct type
+mem = DtoBitCast(mem, DtoType(sd->type->pointerTo()));
 // return as a var
 return new DVarValue(type, mem);
 }

Mercurial > projects > ldc

comparison gen/toir.cpp @ 1255:9014d7f0433f