projects/ldc: ir/irstruct.cpp comparison

comparison ir/irstruct.cpp @ 1240:f295e51d2dd0

Fixed static struct initializers.

author	Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
date	Fri, 17 Apr 2009 00:36:21 +0200
parents	212ec2d9d176
children	465a77c904d4

comparison

equal deleted inserted replaced

-:ff1b4cc2e9be
+:f295e51d2dd0
 #include "gen/utils.h"
 #include "ir/irstruct.h"
 #include "ir/irtypeclass.h"
+#include <algorithm>
 //////////////////////////////////////////////////////////////////////////////
 IrStruct::IrStruct(AggregateDeclaration* aggr)
 :   diCompositeType(NULL)
 {
 //////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 // yet another rewrite of the notorious StructInitializer.
+typedef std::pair<VarDeclaration*, llvm::Constant*> VCPair;
+bool struct_init_data_sort(const VCPair& a, const VCPair& b)
+{
+return (a.first && b.first)
+? a.first->offset < b.first->offset
+: false;
+}
 // this time a bit more inspired by the DMD code.
 LLConstant * IrStruct::createStructInitializer(StructInitializer * si)
 {
 IF_LOG Logger::println("Building StructInitializer of type %s", si->ad->toPrettyChars());
 // sanity check
 assert(si->ad == aggrdecl && "struct type mismatch");
 assert(si->vars.dim == si->value.dim && "inconsistent StructInitializer");
 // array of things to build
-typedef std::pair<VarDeclaration*, llvm::Constant*> VCPair;
 llvm::SmallVector<VCPair, 16> data(aggrdecl->fields.dim);
 // start by creating a map from initializer indices to field indices.
 // I have no fucking clue why dmd represents it like this :/
 size_t n = si->vars.dim;
 Loc l = ini ? ini->loc : si->loc;
 error(l, "duplicate initialization of %s", vd->toChars());
 continue;
 }
+IF_LOG Logger::println("Explicit initializer: %s @+%u", vd->toChars(), vd->offset);
+LOG_SCOPE;
 data[idx].first = vd;
 data[idx].second = get_default_initializer(vd, ini);
 }
-// build array of constants and try to fill in default initializers
+// fill in implicit initializers
-// where there is room.
+n = data.size();
+for (size_t i = 0; i < n; i++)
+{
+VarDeclaration* vd = data[i].first;
+if (vd)
+continue;
+vd = (VarDeclaration*)aggrdecl->fields.data[i];
+unsigned vd_begin = vd->offset;
+unsigned vd_end = vd_begin + vd->type->size();
+// make sure it doesn't overlap any explicit initializers.
+VarDeclarationIter it(aggrdecl->fields);
+bool overlaps = false;
+size_t j = 0;
+for (; it.more(); it.next(), j++)
+{
+if (i == j || !data[j].first)
+continue;
+unsigned f_begin = it->offset;
+unsigned f_end = f_begin + it->type->size();
+if (vd_begin >= f_end || vd_end <= f_begin)
+continue;
+overlaps = true;
+break;
+}
+// add if no overlap found
+if (!overlaps)
+{
+IF_LOG Logger::println("Implicit initializer: %s @+%u", vd->toChars(), vd->offset);
+LOG_SCOPE;
+data[i].first = vd;
+data[i].second = get_default_initializer(vd, NULL);
+}
+}
+// stop if there were errors
+if (global.errors)
+{
+fatal();
+}
+// sort data array by offset
+std::sort(data.begin(), data.end(), struct_init_data_sort);
+// build array of constants and make sure explicit zero padding is inserted when necessary.
 size_t offset = 0;
 std::vector<llvm::Constant*> constants;
-constants.reserve(16);
+constants.reserve(n);
-n = data.size();
 for (size_t i = 0; i < n; i++)
 {
 VarDeclaration* vd = data[i].first;
+if (vd == NULL)
-// explicitly initialized?
+continue;
-if (vd != NULL)
-{
+// get next aligned offset for this field
-// get next aligned offset for this field
+size_t alignedoffset = offset;
-size_t alignedoffset = offset;
+if (!packed)
-if (!packed)
+{
-{
+size_t alignsize = vd->type->alignsize();
-size_t alignsize = vd->type->alignsize();
+alignedoffset = (offset + alignsize - 1) & ~(alignsize - 1);
-alignedoffset = (offset + alignsize - 1) & ~(alignsize - 1);
+}
-}
+// insert explicit padding?
-// insert explicit padding?
+if (alignedoffset < vd->offset)
-if (alignedoffset < vd->offset)
+{
-{
+size_t diff = vd->offset - alignedoffset;
-add_zeros(constants, vd->offset - alignedoffset);
+IF_LOG Logger::println("adding %zu bytes zero padding", diff);
-}
+add_zeros(constants, diff);
+}
-IF_LOG Logger::println("using field: %s", vd->toChars());
-constants.push_back(data[i].second);
+IF_LOG Logger::println("adding field %s", vd->toChars());
-offset = vd->offset + vd->type->size();
-}
+constants.push_back(data[i].second);
-// not explicit! try and fit in the default initialization instead
+offset = vd->offset + vd->type->size();
-// make sure we don't overlap with any following explicity initialized fields
-else
-{
-vd = (VarDeclaration*)aggrdecl->fields.data[i];
-// check all the way that we don't overlap, slow but it works!
-for (size_t j = i+1; j <= n; j++)
-{
-if (j == n) // no overlap
-{
-IF_LOG Logger::println("using field default: %s", vd->toChars());
-constants.push_back(get_default_initializer(vd, NULL));
-offset = vd->offset + vd->type->size();
-break;
-}
-VarDeclaration* vd2 = (VarDeclaration*)aggrdecl->fields.data[j];
-size_t o2 = vd->offset + vd->type->size();
-if (vd2->offset < o2 && data[i].first)
-break; // overlaps
-}
-}
 }
 // tail padding?
 if (offset < aggrdecl->structsize)
 {
-add_zeros(constants, aggrdecl->structsize - offset);
+size_t diff = aggrdecl->structsize - offset;
-}
+IF_LOG Logger::println("adding %zu bytes zero padding", diff);
+add_zeros(constants, diff);
-// stop if there were errors
-if (global.errors)
-{
-fatal();
 }
 // build constant
 assert(!constants.empty());
 llvm::Constant* c = llvm::ConstantStruct::get(&constants[0], constants.size(), packed);

Mercurial > projects > ldc

comparison ir/irstruct.cpp @ 1240:f295e51d2dd0