mirror of
https://github.com/ldc-developers/ldc.git
synced 2025-05-05 09:31:03 +03:00

Also adds the CMake infrastructure to compile and link the D source files. The build is partially broken: - A few files in Phobos and druntime do not build - MSVC build is broken because of unresolved symbols involving reals
234 lines
6.6 KiB
C++
234 lines
6.6 KiB
C++
//===-- irtypeaggr.cpp ----------------------------------------------------===//
|
||
//
|
||
// LDC – the LLVM D compiler
|
||
//
|
||
// This file is distributed under the BSD-style LDC license. See the LICENSE
|
||
// file for details.
|
||
//
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
#include "ir/irtypeaggr.h"
|
||
|
||
#include "llvm/IR/DerivedTypes.h"
|
||
|
||
#include "aggregate.h"
|
||
#include "init.h"
|
||
|
||
#include "gen/irstate.h"
|
||
#include "gen/logger.h"
|
||
#include "gen/llvmhelpers.h"
|
||
|
||
//////////////////////////////////////////////////////////////////////////////
|
||
//////////////////////////////////////////////////////////////////////////////
|
||
|
||
// FIXME A similar function is in ir/iraggr.cpp and RTTIBuilder::push().
|
||
static inline size_t add_zeros(std::vector<llvm::Type *> &defaultTypes,
|
||
size_t startOffset, size_t endOffset) {
|
||
assert(startOffset <= endOffset);
|
||
const size_t paddingSize = endOffset - startOffset;
|
||
if (paddingSize) {
|
||
llvm::ArrayType *pad = llvm::ArrayType::get(
|
||
llvm::Type::getInt8Ty(gIR->context()), paddingSize);
|
||
defaultTypes.push_back(pad);
|
||
}
|
||
return paddingSize ? 1 : 0;
|
||
}
|
||
|
||
bool var_offset_sort_cb(const VarDeclaration *v1, const VarDeclaration *v2) {
|
||
if (v1 && v2) {
|
||
return v1->offset < v2->offset;
|
||
}
|
||
// sort NULL pointers towards the end
|
||
return v1 && !v2;
|
||
}
|
||
|
||
AggrTypeBuilder::AggrTypeBuilder(bool packed) : m_packed(packed) {
|
||
m_defaultTypes.reserve(32);
|
||
}
|
||
|
||
void AggrTypeBuilder::addType(llvm::Type *type, unsigned size) {
|
||
m_defaultTypes.push_back(type);
|
||
m_offset += size;
|
||
m_fieldIndex++;
|
||
}
|
||
|
||
void AggrTypeBuilder::addAggregate(AggregateDeclaration *ad) {
|
||
// mirror the ad->fields array but only fill in contributors
|
||
const size_t n = ad->fields.dim;
|
||
LLSmallVector<VarDeclaration *, 16> data(n, nullptr);
|
||
|
||
unsigned int errors = global.errors;
|
||
|
||
// first fill in the fields with explicit initializers
|
||
for (size_t index = 0; index < n; ++index) {
|
||
VarDeclaration *field = ad->fields[index];
|
||
|
||
// _init is !null for explicit inits
|
||
if (field->_init != nullptr && !field->_init->isVoidInitializer()) {
|
||
IF_LOG Logger::println("adding explicit initializer for struct field %s",
|
||
field->toChars());
|
||
|
||
size_t f_size = field->type->size();
|
||
size_t f_begin = field->offset;
|
||
size_t f_end = f_begin + f_size;
|
||
if (f_size == 0) {
|
||
continue;
|
||
}
|
||
|
||
data[index] = field;
|
||
|
||
// make sure there is no overlap
|
||
for (size_t i = 0; i < index; i++) {
|
||
if (data[i] != nullptr) {
|
||
VarDeclaration *vd = data[i];
|
||
size_t v_begin = vd->offset;
|
||
size_t v_end = v_begin + vd->type->size();
|
||
|
||
if (v_begin >= f_end || v_end <= f_begin) {
|
||
continue;
|
||
}
|
||
|
||
ad->error(vd->loc, "has overlapping initialization for %s and %s",
|
||
field->toChars(), vd->toChars());
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (errors != global.errors) {
|
||
// There was an overlapping initialization.
|
||
// Return if errors are gagged otherwise abort.
|
||
if (global.gag) {
|
||
return;
|
||
}
|
||
fatal();
|
||
}
|
||
|
||
// fill in default initializers
|
||
for (size_t index = 0; index < n; ++index) {
|
||
if (data[index]) {
|
||
continue;
|
||
}
|
||
VarDeclaration *field = ad->fields[index];
|
||
|
||
size_t f_size = field->type->size();
|
||
size_t f_begin = field->offset;
|
||
size_t f_end = f_begin + f_size;
|
||
if (f_size == 0) {
|
||
continue;
|
||
}
|
||
|
||
// make sure it doesn't overlap anything explicit
|
||
bool overlaps = false;
|
||
for (size_t i = 0; i < n; i++) {
|
||
if (data[i]) {
|
||
size_t v_begin = data[i]->offset;
|
||
size_t v_end = v_begin + data[i]->type->size();
|
||
|
||
if (v_begin >= f_end || v_end <= f_begin) {
|
||
continue;
|
||
}
|
||
|
||
overlaps = true;
|
||
break;
|
||
}
|
||
}
|
||
|
||
// if no overlap was found, add the default initializer
|
||
if (!overlaps) {
|
||
IF_LOG Logger::println("adding default initializer for struct field %s",
|
||
field->toChars());
|
||
data[index] = field;
|
||
}
|
||
}
|
||
|
||
//
|
||
// ok. now we can build a list of llvm types. and make sure zeros are inserted
|
||
// if necessary.
|
||
//
|
||
|
||
// first we sort the list by offset
|
||
std::sort(data.begin(), data.end(), var_offset_sort_cb);
|
||
|
||
// add types to list
|
||
for (size_t i = 0; i < n; i++) {
|
||
VarDeclaration *vd = data[i];
|
||
|
||
if (vd == nullptr) {
|
||
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;
|
||
++m_fieldIndex;
|
||
}
|
||
}
|
||
|
||
void AggrTypeBuilder::alignCurrentOffset(unsigned alignment) {
|
||
m_overallAlignment = std::max(alignment, m_overallAlignment);
|
||
|
||
unsigned aligned = (m_offset + alignment - 1) & ~(alignment - 1);
|
||
if (m_offset < aligned) {
|
||
m_fieldIndex += add_zeros(m_defaultTypes, m_offset, aligned);
|
||
m_offset = aligned;
|
||
}
|
||
}
|
||
|
||
void AggrTypeBuilder::addTailPadding(unsigned aggregateSize) {
|
||
// tail padding?
|
||
if (m_offset < aggregateSize) {
|
||
add_zeros(m_defaultTypes, m_offset, aggregateSize);
|
||
}
|
||
}
|
||
|
||
//////////////////////////////////////////////////////////////////////////////
|
||
//////////////////////////////////////////////////////////////////////////////
|
||
|
||
IrTypeAggr::IrTypeAggr(AggregateDeclaration *ad)
|
||
: IrType(ad->type,
|
||
LLStructType::create(gIR->context(), ad->toPrettyChars())),
|
||
aggr(ad) {}
|
||
|
||
bool IrTypeAggr::isPacked(AggregateDeclaration *ad) {
|
||
if (ad->isUnionDeclaration()) {
|
||
return true;
|
||
}
|
||
for (unsigned i = 0; i < ad->fields.dim; i++) {
|
||
VarDeclaration *vd = static_cast<VarDeclaration *>(ad->fields.data[i]);
|
||
unsigned a = vd->type->alignsize() - 1;
|
||
if (((vd->offset + a) & ~a) != vd->offset) {
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
void IrTypeAggr::getMemberLocation(VarDeclaration *var, unsigned &fieldIndex,
|
||
unsigned &byteOffset) const {
|
||
// Note: The interface is a bit more general than what we actually return.
|
||
// Specifically, the frontend offset information we use for overlapping
|
||
// fields is always based at the object start.
|
||
auto it = varGEPIndices.find(var);
|
||
if (it != varGEPIndices.end()) {
|
||
fieldIndex = it->second;
|
||
byteOffset = 0;
|
||
} else {
|
||
fieldIndex = 0;
|
||
byteOffset = var->offset;
|
||
}
|
||
}
|