300 lines
10 KiB
C++
300 lines
10 KiB
C++
|
//===--- ConstantInitBuilder.cpp - Global initializer builder -------------===//
|
||
|
|
//
|
||
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
||
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||
|
|
//
|
||
|
|
//===----------------------------------------------------------------------===//
|
||
|
|
//
|
||
|
|
// This file defines out-of-line routines for building initializers for
|
||
|
|
// global variables, in particular the kind of globals that are implicitly
|
||
|
|
// introduced by various language ABIs.
|
||
|
|
//
|
||
|
|
//===----------------------------------------------------------------------===//
|
||
|
|
|
||
|
|
#include "clang/CodeGen/ConstantInitBuilder.h"
|
||
|
|
#include "CodeGenModule.h"
|
||
|
|
|
||
|
|
using namespace clang;
|
||
|
|
using namespace CodeGen;
|
||
|
|
|
||
|
|
llvm::Type *ConstantInitFuture::getType() const {
|
||
|
|
assert(Data && "dereferencing null future");
|
||
|
|
if (Data.is<llvm::Constant*>()) {
|
||
|
|
return Data.get<llvm::Constant*>()->getType();
|
||
|
|
} else {
|
||
|
|
return Data.get<ConstantInitBuilderBase*>()->Buffer[0]->getType();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void ConstantInitFuture::abandon() {
|
||
|
|
assert(Data && "abandoning null future");
|
||
|
|
if (auto builder = Data.dyn_cast<ConstantInitBuilderBase*>()) {
|
||
|
|
builder->abandon(0);
|
||
|
|
}
|
||
|
|
Data = nullptr;
|
||
|
|
}
|
||
|
|
|
||
|
|
void ConstantInitFuture::installInGlobal(llvm::GlobalVariable *GV) {
|
||
|
|
assert(Data && "installing null future");
|
||
|
|
if (Data.is<llvm::Constant*>()) {
|
||
|
|
GV->setInitializer(Data.get<llvm::Constant*>());
|
||
|
|
} else {
|
||
|
|
auto &builder = *Data.get<ConstantInitBuilderBase*>();
|
||
|
|
assert(builder.Buffer.size() == 1);
|
||
|
|
builder.setGlobalInitializer(GV, builder.Buffer[0]);
|
||
|
|
builder.Buffer.clear();
|
||
|
|
Data = nullptr;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
ConstantInitFuture
|
||
|
|
ConstantInitBuilderBase::createFuture(llvm::Constant *initializer) {
|
||
|
|
assert(Buffer.empty() && "buffer not current empty");
|
||
|
|
Buffer.push_back(initializer);
|
||
|
|
return ConstantInitFuture(this);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Only used in this file.
|
||
|
|
inline ConstantInitFuture::ConstantInitFuture(ConstantInitBuilderBase *builder)
|
||
|
|
: Data(builder) {
|
||
|
|
assert(!builder->Frozen);
|
||
|
|
assert(builder->Buffer.size() == 1);
|
||
|
|
assert(builder->Buffer[0] != nullptr);
|
||
|
|
}
|
||
|
|
|
||
|
|
llvm::GlobalVariable *
|
||
|
|
ConstantInitBuilderBase::createGlobal(llvm::Constant *initializer,
|
||
|
|
const llvm::Twine &name,
|
||
|
|
CharUnits alignment,
|
||
|
|
bool constant,
|
||
|
|
llvm::GlobalValue::LinkageTypes linkage,
|
||
|
|
unsigned addressSpace) {
|
||
|
|
auto GV = new llvm::GlobalVariable(CGM.getModule(),
|
||
|
|
initializer->getType(),
|
||
|
|
constant,
|
||
|
|
linkage,
|
||
|
|
initializer,
|
||
|
|
name,
|
||
|
|
/*insert before*/ nullptr,
|
||
|
|
llvm::GlobalValue::NotThreadLocal,
|
||
|
|
addressSpace);
|
||
|
|
GV->setAlignment(alignment.getAsAlign());
|
||
|
|
resolveSelfReferences(GV);
|
||
|
|
return GV;
|
||
|
|
}
|
||
|
|
|
||
|
|
void ConstantInitBuilderBase::setGlobalInitializer(llvm::GlobalVariable *GV,
|
||
|
|
llvm::Constant *initializer){
|
||
|
|
GV->setInitializer(initializer);
|
||
|
|
|
||
|
|
if (!SelfReferences.empty())
|
||
|
|
resolveSelfReferences(GV);
|
||
|
|
}
|
||
|
|
|
||
|
|
void ConstantInitBuilderBase::resolveSelfReferences(llvm::GlobalVariable *GV) {
|
||
|
|
for (auto &entry : SelfReferences) {
|
||
|
|
llvm::Constant *resolvedReference =
|
||
|
|
llvm::ConstantExpr::getInBoundsGetElementPtr(
|
||
|
|
GV->getValueType(), GV, entry.Indices);
|
||
|
|
auto dummy = entry.Dummy;
|
||
|
|
dummy->replaceAllUsesWith(resolvedReference);
|
||
|
|
dummy->eraseFromParent();
|
||
|
|
}
|
||
|
|
SelfReferences.clear();
|
||
|
|
}
|
||
|
|
|
||
|
|
void ConstantInitBuilderBase::abandon(size_t newEnd) {
|
||
|
|
// Remove all the entries we've added.
|
||
|
|
Buffer.erase(Buffer.begin() + newEnd, Buffer.end());
|
||
|
|
|
||
|
|
// If we're abandoning all the way to the beginning, destroy
|
||
|
|
// all the self-references, because we might not get another
|
||
|
|
// opportunity.
|
||
|
|
if (newEnd == 0) {
|
||
|
|
for (auto &entry : SelfReferences) {
|
||
|
|
auto dummy = entry.Dummy;
|
||
|
|
dummy->replaceAllUsesWith(llvm::UndefValue::get(dummy->getType()));
|
||
|
|
dummy->eraseFromParent();
|
||
|
|
}
|
||
|
|
SelfReferences.clear();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void ConstantAggregateBuilderBase::addSize(CharUnits size) {
|
||
|
|
add(Builder.CGM.getSize(size));
|
||
|
|
}
|
||
|
|
|
||
|
|
llvm::Constant *
|
||
|
|
ConstantAggregateBuilderBase::getRelativeOffset(llvm::IntegerType *offsetType,
|
||
|
|
llvm::Constant *target) {
|
||
|
|
return getRelativeOffsetToPosition(offsetType, target,
|
||
|
|
Builder.Buffer.size() - Begin);
|
||
|
|
}
|
||
|
|
|
||
|
|
llvm::Constant *ConstantAggregateBuilderBase::getRelativeOffsetToPosition(
|
||
|
|
llvm::IntegerType *offsetType, llvm::Constant *target, size_t position) {
|
||
|
|
// Compute the address of the relative-address slot.
|
||
|
|
auto base = getAddrOfPosition(offsetType, position);
|
||
|
|
|
||
|
|
// Subtract.
|
||
|
|
base = llvm::ConstantExpr::getPtrToInt(base, Builder.CGM.IntPtrTy);
|
||
|
|
target = llvm::ConstantExpr::getPtrToInt(target, Builder.CGM.IntPtrTy);
|
||
|
|
llvm::Constant *offset = llvm::ConstantExpr::getSub(target, base);
|
||
|
|
|
||
|
|
// Truncate to the relative-address type if necessary.
|
||
|
|
if (Builder.CGM.IntPtrTy != offsetType) {
|
||
|
|
offset = llvm::ConstantExpr::getTrunc(offset, offsetType);
|
||
|
|
}
|
||
|
|
|
||
|
|
return offset;
|
||
|
|
}
|
||
|
|
|
||
|
|
llvm::Constant *
|
||
|
|
ConstantAggregateBuilderBase::getAddrOfPosition(llvm::Type *type,
|
||
|
|
size_t position) {
|
||
|
|
// Make a global variable. We will replace this with a GEP to this
|
||
|
|
// position after installing the initializer.
|
||
|
|
auto dummy = new llvm::GlobalVariable(Builder.CGM.getModule(), type, true,
|
||
|
|
llvm::GlobalVariable::PrivateLinkage,
|
||
|
|
nullptr, "");
|
||
|
|
Builder.SelfReferences.emplace_back(dummy);
|
||
|
|
auto &entry = Builder.SelfReferences.back();
|
||
|
|
(void)getGEPIndicesTo(entry.Indices, position + Begin);
|
||
|
|
return dummy;
|
||
|
|
}
|
||
|
|
|
||
|
|
llvm::Constant *
|
||
|
|
ConstantAggregateBuilderBase::getAddrOfCurrentPosition(llvm::Type *type) {
|
||
|
|
// Make a global variable. We will replace this with a GEP to this
|
||
|
|
// position after installing the initializer.
|
||
|
|
auto dummy =
|
||
|
|
new llvm::GlobalVariable(Builder.CGM.getModule(), type, true,
|
||
|
|
llvm::GlobalVariable::PrivateLinkage,
|
||
|
|
nullptr, "");
|
||
|
|
Builder.SelfReferences.emplace_back(dummy);
|
||
|
|
auto &entry = Builder.SelfReferences.back();
|
||
|
|
(void) getGEPIndicesToCurrentPosition(entry.Indices);
|
||
|
|
return dummy;
|
||
|
|
}
|
||
|
|
|
||
|
|
void ConstantAggregateBuilderBase::getGEPIndicesTo(
|
||
|
|
llvm::SmallVectorImpl<llvm::Constant*> &indices,
|
||
|
|
size_t position) const {
|
||
|
|
// Recurse on the parent builder if present.
|
||
|
|
if (Parent) {
|
||
|
|
Parent->getGEPIndicesTo(indices, Begin);
|
||
|
|
|
||
|
|
// Otherwise, add an index to drill into the first level of pointer.
|
||
|
|
} else {
|
||
|
|
assert(indices.empty());
|
||
|
|
indices.push_back(llvm::ConstantInt::get(Builder.CGM.Int32Ty, 0));
|
||
|
|
}
|
||
|
|
|
||
|
|
assert(position >= Begin);
|
||
|
|
// We have to use i32 here because struct GEPs demand i32 indices.
|
||
|
|
// It's rather unlikely to matter in practice.
|
||
|
|
indices.push_back(llvm::ConstantInt::get(Builder.CGM.Int32Ty,
|
||
|
|
position - Begin));
|
||
|
|
}
|
||
|
|
|
||
|
|
ConstantAggregateBuilderBase::PlaceholderPosition
|
||
|
|
ConstantAggregateBuilderBase::addPlaceholderWithSize(llvm::Type *type) {
|
||
|
|
// Bring the offset up to the last field.
|
||
|
|
CharUnits offset = getNextOffsetFromGlobal();
|
||
|
|
|
||
|
|
// Create the placeholder.
|
||
|
|
auto position = addPlaceholder();
|
||
|
|
|
||
|
|
// Advance the offset past that field.
|
||
|
|
auto &layout = Builder.CGM.getDataLayout();
|
||
|
|
if (!Packed)
|
||
|
|
offset = offset.alignTo(CharUnits::fromQuantity(
|
||
|
|
layout.getABITypeAlignment(type)));
|
||
|
|
offset += CharUnits::fromQuantity(layout.getTypeStoreSize(type));
|
||
|
|
|
||
|
|
CachedOffsetEnd = Builder.Buffer.size();
|
||
|
|
CachedOffsetFromGlobal = offset;
|
||
|
|
|
||
|
|
return position;
|
||
|
|
}
|
||
|
|
|
||
|
|
CharUnits ConstantAggregateBuilderBase::getOffsetFromGlobalTo(size_t end) const{
|
||
|
|
size_t cacheEnd = CachedOffsetEnd;
|
||
|
|
assert(cacheEnd <= end);
|
||
|
|
|
||
|
|
// Fast path: if the cache is valid, just use it.
|
||
|
|
if (cacheEnd == end) {
|
||
|
|
return CachedOffsetFromGlobal;
|
||
|
|
}
|
||
|
|
|
||
|
|
// If the cached range ends before the index at which the current
|
||
|
|
// aggregate starts, recurse for the parent.
|
||
|
|
CharUnits offset;
|
||
|
|
if (cacheEnd < Begin) {
|
||
|
|
assert(cacheEnd == 0);
|
||
|
|
assert(Parent && "Begin != 0 for root builder");
|
||
|
|
cacheEnd = Begin;
|
||
|
|
offset = Parent->getOffsetFromGlobalTo(Begin);
|
||
|
|
} else {
|
||
|
|
offset = CachedOffsetFromGlobal;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Perform simple layout on the elements in cacheEnd..<end.
|
||
|
|
if (cacheEnd != end) {
|
||
|
|
auto &layout = Builder.CGM.getDataLayout();
|
||
|
|
do {
|
||
|
|
llvm::Constant *element = Builder.Buffer[cacheEnd];
|
||
|
|
assert(element != nullptr &&
|
||
|
|
"cannot compute offset when a placeholder is present");
|
||
|
|
llvm::Type *elementType = element->getType();
|
||
|
|
if (!Packed)
|
||
|
|
offset = offset.alignTo(CharUnits::fromQuantity(
|
||
|
|
layout.getABITypeAlignment(elementType)));
|
||
|
|
offset += CharUnits::fromQuantity(layout.getTypeStoreSize(elementType));
|
||
|
|
} while (++cacheEnd != end);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Cache and return.
|
||
|
|
CachedOffsetEnd = cacheEnd;
|
||
|
|
CachedOffsetFromGlobal = offset;
|
||
|
|
return offset;
|
||
|
|
}
|
||
|
|
|
||
|
|
llvm::Constant *ConstantAggregateBuilderBase::finishArray(llvm::Type *eltTy) {
|
||
|
|
markFinished();
|
||
|
|
|
||
|
|
auto &buffer = getBuffer();
|
||
|
|
assert((Begin < buffer.size() ||
|
||
|
|
(Begin == buffer.size() && eltTy))
|
||
|
|
&& "didn't add any array elements without element type");
|
||
|
|
auto elts = llvm::makeArrayRef(buffer).slice(Begin);
|
||
|
|
if (!eltTy) eltTy = elts[0]->getType();
|
||
|
|
auto type = llvm::ArrayType::get(eltTy, elts.size());
|
||
|
|
auto constant = llvm::ConstantArray::get(type, elts);
|
||
|
|
buffer.erase(buffer.begin() + Begin, buffer.end());
|
||
|
|
return constant;
|
||
|
|
}
|
||
|
|
|
||
|
|
llvm::Constant *
|
||
|
|
ConstantAggregateBuilderBase::finishStruct(llvm::StructType *ty) {
|
||
|
|
markFinished();
|
||
|
|
|
||
|
|
auto &buffer = getBuffer();
|
||
|
|
auto elts = llvm::makeArrayRef(buffer).slice(Begin);
|
||
|
|
|
||
|
|
if (ty == nullptr && elts.empty())
|
||
|
|
ty = llvm::StructType::get(Builder.CGM.getLLVMContext(), {}, Packed);
|
||
|
|
|
||
|
|
llvm::Constant *constant;
|
||
|
|
if (ty) {
|
||
|
|
assert(ty->isPacked() == Packed);
|
||
|
|
constant = llvm::ConstantStruct::get(ty, elts);
|
||
|
|
} else {
|
||
|
|
constant = llvm::ConstantStruct::getAnon(elts, Packed);
|
||
|
|
}
|
||
|
|
|
||
|
|
buffer.erase(buffer.begin() + Begin, buffer.end());
|
||
|
|
return constant;
|
||
|
|
}
|