std::string MembershipTableMgr::toString() {
stringstream s;
const size_t size = getMemberSize();
s << "\n=============== membership table ===============\n";
for (int i = 0; i < size; ++i) {
s << members[i].toString();
}
return s.str();
}
std::string MembershipTableMgr::toSimpleString() {
stringstream s;
const size_t size = getMemberSize();
s << "\n=============== membership table ===============\n";
for (size_t i = 0; i < size; ++i) {
s << members[i];
if(members[i].getId() == localIndex) {
s << ", " << "local";
}
s << "\n";
}
return s.str();
}
void AggrTypeBuilder::addAggregate(
AggregateDeclaration *ad, const AggrTypeBuilder::VarInitMap *explicitInits,
AggrTypeBuilder::Aliases aliases) {
const size_t n = ad->fields.dim;
if (n == 0)
return;
// prioritize overlapping fields
LLSmallVector<FieldPriority, 16> priorities;
priorities.reserve(n);
for (auto f : ad->fields) {
priorities.push_back(prioritize(f, explicitInits));
IF_LOG Logger::println("Field priority for %s: %d", f->toChars(),
priorities.back());
}
// mirror the ad->fields array but only fill in contributors
LLSmallVector<VarDeclaration *, 16> data(n, nullptr);
// list of pairs: alias => actual field (same offset, same LL type)
LLSmallVector<std::pair<VarDeclaration *, VarDeclaration *>, 16> aliasPairs;
// one pass per priority in descending order
const auto minMaxPriority =
std::minmax_element(priorities.begin(), priorities.end());
for (int p = *minMaxPriority.second; p >= *minMaxPriority.first; p--) {
// iterate over fields of that priority, in declaration order
for (size_t index = 0; index < n; ++index) {
if (priorities[index] != p)
continue;
VarDeclaration *field = ad->fields[index];
const size_t f_begin = field->offset;
const size_t f_end = f_begin + field->type->size();
// skip empty fields
if (f_begin == f_end)
continue;
// check for overlapping existing fields
bool overlaps = false;
if (field->overlapped) {
for (const auto vd : data) {
if (!vd)
continue;
const size_t v_begin = vd->offset;
const size_t v_end = v_begin + vd->type->size();
if (v_begin < f_end && v_end > f_begin) {
if (aliases == Aliases::AddToVarGEPIndices && v_begin == f_begin &&
DtoMemType(vd->type) == DtoMemType(field->type)) {
aliasPairs.push_back(std::make_pair(field, vd));
}
overlaps = true;
break;
}
}
}
if (!overlaps)
data[index] = field;
}
}
// Now we can build a list of LLVM types for the actual LL fields.
// Make sure to zero out any padding and set the GEP indices for the directly
// indexable variables.
// first we sort the list by offset
std::sort(data.begin(), data.end(), var_offset_sort_cb);
for (const auto vd : data) {
if (!vd)
continue;
assert(vd->offset >= m_offset && "Variable overlaps previous field.");
// Add an explicit field for any padding so we can zero it, as per TDPL
// §7.1.1.
if (m_offset < vd->offset) {
m_fieldIndex += add_zeros(m_defaultTypes, m_offset, vd->offset);
m_offset = vd->offset;
}
// add default type
m_defaultTypes.push_back(DtoMemType(vd->type));
// advance offset to right past this field
m_offset += getMemberSize(vd->type);
// set the field index
m_varGEPIndices[vd] = m_fieldIndex;
// let any aliases reuse this field/GEP index
for (const auto &pair : aliasPairs) {
if (pair.second == vd)
m_varGEPIndices[pair.first] = m_fieldIndex;
}
++m_fieldIndex;
}
}
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);
}
}
}
}
