llvm::Constant *
IrAggr::createInitializerConstant(const VarInitMap &explicitInitializers) {
IF_LOG Logger::println("Creating initializer constant for %s",
aggrdecl->toChars());
LOG_SCOPE;
llvm::SmallVector<llvm::Constant *, 16> constants;
unsigned offset = 0;
if (type->ty == Tclass) {
// add vtbl
constants.push_back(getVtblSymbol());
offset += Target::ptrsize;
// add monitor (except for C++ classes)
if (!aggrdecl->isClassDeclaration()->isCPPclass()) {
constants.push_back(getNullValue(getVoidPtrType()));
offset += Target::ptrsize;
}
}
// Add the initializers for the member fields. While we are traversing the
// class hierarchy, use the opportunity to populate interfacesWithVtbls if
// we haven't done so previously (due to e.g. ClassReferenceExp, we can
// have multiple initializer constants for a single class).
addFieldInitializers(constants, explicitInitializers, aggrdecl, offset,
interfacesWithVtbls.empty());
// tail padding?
const size_t structsize = aggrdecl->size(Loc());
if (offset < structsize)
add_zeros(constants, offset, structsize);
assert(!constants.empty());
// get LL field types
llvm::SmallVector<llvm::Type *, 16> types;
types.reserve(constants.size());
for (auto c : constants)
types.push_back(c->getType());
auto llStructType = getLLStructType();
bool isCompatible = (types.size() == llStructType->getNumElements());
if (isCompatible) {
for (size_t i = 0; i < types.size(); i++) {
if (types[i] != llStructType->getElementType(i)) {
isCompatible = false;
break;
}
}
}
// build constant
LLStructType *llType =
isCompatible ? llStructType
: LLStructType::get(gIR->context(), types, isPacked());
llvm::Constant *c = LLConstantStruct::get(llType, constants);
IF_LOG Logger::cout() << "final initializer: " << *c << std::endl;
return c;
}
llvm::Constant* IrAggr::createInitializerConstant(
const VarInitMap& explicitInitializers,
llvm::StructType* initializerType)
{
IF_LOG Logger::println("Creating initializer constant for %s", aggrdecl->toChars());
LOG_SCOPE;
llvm::SmallVector<llvm::Constant*, 16> constants;
unsigned offset = 0;
if (type->ty == Tclass)
{
// add vtbl
constants.push_back(getVtblSymbol());
// add monitor
constants.push_back(getNullValue(DtoType(Type::tvoid->pointerTo())));
// we start right after the vtbl and monitor
offset = Target::ptrsize * 2;
}
// Add the initializers for the member fields. While we are traversing the
// class hierarchy, use the opportunity to populate interfacesWithVtbls if
// we haven't done so previously (due to e.g. ClassReferenceExp, we can
// have multiple initializer constants for a single class).
addFieldInitializers(constants, explicitInitializers, aggrdecl, offset,
interfacesWithVtbls.empty());
// tail padding?
const size_t structsize = aggrdecl->size(Loc());
if (offset < structsize)
{
add_zeros(constants, offset, structsize);
}
// get initializer type
if (!initializerType || initializerType->isOpaque())
{
llvm::SmallVector<llvm::Constant*, 16>::iterator itr, end = constants.end();
llvm::SmallVector<llvm::Type*, 16> types;
types.reserve(constants.size());
for (itr = constants.begin(); itr != end; ++itr)
types.push_back((*itr)->getType());
if (!initializerType)
initializerType = LLStructType::get(gIR->context(), types, isPacked());
else
initializerType->setBody(types, isPacked());
}
// build constant
assert(!constants.empty());
llvm::Constant* c = LLConstantStruct::get(initializerType, constants);
IF_LOG Logger::cout() << "final initializer: " << *c << std::endl;
return c;
}
void IrAggr::addFieldInitializers(
llvm::SmallVectorImpl<llvm::Constant *> &constants,
const VarInitMap &explicitInitializers, AggregateDeclaration *decl,
unsigned &offset, bool populateInterfacesWithVtbls) {
if (ClassDeclaration *cd = decl->isClassDeclaration()) {
if (cd->baseClass) {
addFieldInitializers(constants, explicitInitializers, cd->baseClass,
offset, populateInterfacesWithVtbls);
}
// has interface vtbls?
if (cd->vtblInterfaces && cd->vtblInterfaces->dim > 0) {
// Align interface infos to pointer size.
unsigned aligned =
(offset + Target::ptrsize - 1) & ~(Target::ptrsize - 1);
if (offset < aligned) {
add_zeros(constants, offset, aligned);
offset = aligned;
}
// false when it's not okay to use functions from super classes
bool newinsts = (cd == aggrdecl->isClassDeclaration());
size_t inter_idx = interfacesWithVtbls.size();
for (auto bc : *cd->vtblInterfaces) {
constants.push_back(getInterfaceVtbl(bc, newinsts, inter_idx));
offset += Target::ptrsize;
inter_idx++;
if (populateInterfacesWithVtbls)
interfacesWithVtbls.push_back(bc);
}
}
}
AggrTypeBuilder b(false, offset);
b.addAggregate(decl, &explicitInitializers, AggrTypeBuilder::Aliases::Skip);
offset = b.currentOffset();
const size_t baseLLFieldIndex = constants.size();
const size_t numNewLLFields = b.defaultTypes().size();
constants.resize(constants.size() + numNewLLFields, nullptr);
// add explicit and non-overlapping implicit initializers
for (const auto &pair : b.varGEPIndices()) {
const auto field = pair.first;
const size_t fieldIndex = pair.second;
const auto explicitIt = explicitInitializers.find(field);
llvm::Constant *init = (explicitIt != explicitInitializers.end()
? explicitIt->second
: getDefaultInitializer(field));
constants[baseLLFieldIndex + fieldIndex] =
FillSArrayDims(field->type, init);
}
// zero out remaining padding fields
for (size_t i = 0; i < numNewLLFields; i++) {
auto &init = constants[baseLLFieldIndex + i];
if (!init)
init = llvm::Constant::getNullValue(b.defaultTypes()[i]);
}
}
void IrAggr::addFieldInitializers(
llvm::SmallVectorImpl<llvm::Constant*>& constants,
const VarInitMap& explicitInitializers,
AggregateDeclaration* decl,
unsigned& offset,
bool populateInterfacesWithVtbls
)
{
if (ClassDeclaration* cd = decl->isClassDeclaration())
{
if (cd->baseClass)
{
addFieldInitializers(constants, explicitInitializers,
cd->baseClass, offset, populateInterfacesWithVtbls);
}
}
// Build up vector with one-to-one mapping to field indices.
const size_t n = decl->fields.dim;
llvm::SmallVector<VarInitConst, 16> data(n);
// Fill in explicit initializers.
for (size_t i = 0; i < n; ++i)
{
VarDeclaration* vd = decl->fields[i];
VarInitMap::const_iterator expl = explicitInitializers.find(vd);
if (expl != explicitInitializers.end())
data[i] = *expl;
}
// Fill in implicit initializers
for (size_t i = 0; i < n; i++)
{
if (data[i].first) continue;
VarDeclaration* vd = decl->fields[i];
/* Skip void initializers for unions. DMD bug 3991:
union X
{
int a = void;
dchar b = 'a';
}
*/
if (decl->isUnionDeclaration() && vd->init && vd->init->isVoidInitializer())
continue;
unsigned vd_begin = vd->offset;
unsigned vd_end = vd_begin + vd->type->size();
/* Skip zero size fields like zero-length static arrays, LDC issue 812:
class B {
ubyte[0] test;
}
*/
if (vd_begin == vd_end)
continue;
// make sure it doesn't overlap any explicit initializers.
bool overlaps = false;
if (type->ty == Tstruct)
{
// Only structs and unions can have overlapping fields.
for (size_t j = 0; j < n; ++j)
{
if (i == j || !data[j].first)
continue;
VarDeclaration* it = decl->fields[j];
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);
}
}
// Sort data array by offset.
// TODO: Figure out whether this is really necessary, fields should already
// be in offset order. Not having do do this would mean we could use a plain
// llvm::Constant* vector for initializers and avoid all the VarInitConst business.
std::sort(data.begin(), data.end(), struct_init_data_sort);
// build array of constants and make sure explicit zero padding is inserted when necessary.
for (size_t i = 0; i < n; i++)
{
VarDeclaration* vd = data[i].first;
if (vd == NULL)
continue;
// Explicitly zero the padding as per TDPL ยง7.1.1. Otherwise, it would
// be left uninitialized by LLVM.
if (offset < vd->offset)
{
add_zeros(constants, offset, vd->offset);
offset = vd->offset;
}
IF_LOG Logger::println("adding field %s", vd->toChars());
constants.push_back(FillSArrayDims(vd->type, data[i].second));
offset += getMemberSize(vd->type);
}
if (ClassDeclaration* cd = decl->isClassDeclaration())
{
// has interface vtbls?
if (cd->vtblInterfaces && cd->vtblInterfaces->dim > 0)
{
// Align interface infos to pointer size.
unsigned aligned = (offset + Target::ptrsize - 1) & ~(Target::ptrsize - 1);
if (offset < aligned)
{
add_zeros(constants, offset, aligned);
offset = aligned;
}
// false when it's not okay to use functions from super classes
bool newinsts = (cd == aggrdecl->isClassDeclaration());
size_t inter_idx = interfacesWithVtbls.size();
offset = (offset + Target::ptrsize - 1) & ~(Target::ptrsize - 1);
for (BaseClasses::iterator I = cd->vtblInterfaces->begin(),
E = cd->vtblInterfaces->end();
I != E; ++I)
{
constants.push_back(getInterfaceVtbl(*I, newinsts, inter_idx));
offset += Target::ptrsize;
inter_idx++;
if (populateInterfacesWithVtbls)
interfacesWithVtbls.push_back(*I);
}
}
}
}
