projects/ldc: gen/toir.cpp comparison

comparison gen/toir.cpp @ 1479:4f7d50c744ed

Rewrite `StructLiteralExp::toElem` to store individual fields instead of generating a constant to fill the entire struct with a single `store`. This is much more efficient at compile time (fixing #320) and vastly reduces the size of the emitted code. Since LLVM no longer needs to keep the data for all fields in "registers" until the store happens, it should also be more efficient at run time in cases where the fields aren't assigned with constants. There's also some code clean-up by removing duplicated logic.

author	Frits van Bommel <fvbommel wxs.nl>
date	Sat, 06 Jun 2009 20:16:13 +0200
parents	dd72f56ad211
children	b4fc62f047cd

comparison

equal deleted inserted replaced

-:4dca8ed9d8b7
+:4f7d50c744ed
 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);
+static LLValue* write_zeroes(LLValue* mem, unsigned start, unsigned end) {
+mem = DtoBitCast(mem, getVoidPtrType());
+LLValue* gep = DtoGEPi1(mem, start, ".padding");
+DtoMemSetZero(gep, DtoConstSize_t(end - start));
+return mem;
+}
 DValue* StructLiteralExp::toElem(IRState* p)
 {
 Logger::print("StructLiteralExp::toElem: %s @ %s\n", toChars(), type->toChars());
 LOG_SCOPE;
 // make sure the struct is fully resolved
 sd->codegen(Type::sir);
-// final list of values to put in the struct
+// alloca a stack slot
-std::vector<LLValue*> initvalues;
+LLValue* mem = DtoRawAlloca(DtoType(type), 0, ".structliteral");
-// 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;;
+size_t nexprs = elements->dim;
 Expression** exprs = (Expression**)elements->data;
+LLValue* voidptr = mem;
+unsigned offset = 0;
 // go through fields
 ArrayIter<VarDeclaration> it(sd->fields);
 for (; !it.done(); it.next())
 {
 VarDeclaration* vd = it.get();
+// don't re-initialize unions
 if (vd->offset < offset)
 {
 IF_LOG Logger::println("skipping field: %s %s (+%u)", vd->type->toChars(), vd->toChars(), vd->offset);
 continue;
 }
+// initialize any padding so struct comparisons work
-IF_LOG Logger::println("using field: %s %s (+%u)", vd->type->toChars(), vd->toChars(), vd->offset);
+if (vd->offset != offset)
+voidptr = write_zeroes(voidptr, offset, vd->offset);
-// get next aligned offset for this field
+offset = vd->offset + vd->type->size();
-size_t alignedoffset = offset;
-if (!packed)
+IF_LOG Logger::println("initializing field: %s %s (+%u)", vd->type->toChars(), vd->toChars(), vd->offset);
-{
-alignedoffset = realignOffset(alignedoffset, vd->type);
+// get initializer
-}
-// insert explicit padding?
-if (alignedoffset < vd->offset)
-{
-add_zeros(initvalues, vd->offset - alignedoffset);
-}
-// add initializer
 Expression* expr = (it.index < nexprs) ? exprs[it.index] : NULL;
 IF_LOG Logger::println("expr: %p", expr);
+DValue* val;
+DConstValue cv(vd->type, NULL); // Only used in one branch; value is set beforehand
 if (expr)
 {
 IF_LOG Logger::println("expr %zu = %s", it.index, expr->toChars());
-LLValue* v = DtoExprValue(vd->type, expr);
+val = expr->toElem(gIR);
-initvalues.push_back(v);
 }
 else
 {
 IF_LOG Logger::println("using default initializer");
-initvalues.push_back(get_default_initializer(vd, NULL));
+cv.c = get_default_initializer(vd, NULL);
-}
+val = &cv;
+}
-// advance offset to right past this field
-offset = vd->offset + vd->type->size();
+// get a pointer to this field
-}
+DVarValue field(vd->type, vd, DtoIndexStruct(mem, sd, vd));
-// tail padding?
+// store the initializer there
-if (offset < sd->structsize)
+DtoAssign(loc, &field, val);
-{
+}
-add_zeros(initvalues, sd->structsize - offset);
+// initialize trailing padding
-}
+if (sd->structsize != offset)
+write_zeroes(voidptr, offset, sd->structsize);
-// 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 = DtoRawAlloca(st, 0, ".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 @ 1479:4f7d50c744ed