15#ifndef LLVM_CLANG_CODEGEN_CONSTANTINITBUILDER_H
16#define LLVM_CLANG_CODEGEN_CONSTANTINITBUILDER_H
18#include "llvm/ADT/ArrayRef.h"
19#include "llvm/ADT/SmallVector.h"
20#include "llvm/IR/Constants.h"
21#include "llvm/IR/GlobalValue.h"
52 struct SelfReference {
53 llvm::GlobalVariable *Dummy;
56 SelfReference(llvm::GlobalVariable *dummy) : Dummy(dummy) {}
60 std::vector<SelfReference> SelfReferences;
65 template <
class,
class>
72 assert(Buffer.empty() &&
"didn't claim all values out of buffer");
73 assert(SelfReferences.empty() &&
"didn't apply all self-references");
77 llvm::GlobalVariable *createGlobal(llvm::Constant *initializer,
78 const llvm::Twine &name,
80 bool constant =
false,
81 llvm::GlobalValue::LinkageTypes linkage
82 = llvm::GlobalValue::InternalLinkage,
83 unsigned addressSpace = 0);
87 void setGlobalInitializer(llvm::GlobalVariable *GV,
88 llvm::Constant *initializer);
90 void resolveSelfReferences(llvm::GlobalVariable *GV);
92 void abandon(
size_t newEnd);
120 assert(!parent->
Frozen &&
"parent already has child builder active");
123 assert(!builder.Frozen &&
"builder already has child builder active");
124 builder.Frozen =
true;
129 assert(
Finished &&
"didn't finish aggregate builder");
133 assert(!
Frozen &&
"child builder still active");
134 assert(!
Finished &&
"builder already finished");
138 "parent not frozen while child builder active");
142 "builder not frozen while child builder active");
160 other.Finished =
true;
168 assert(!this->Finished &&
"cannot query after finishing builder");
169 assert(!this->Frozen &&
"cannot query while sub-builder is active");
182 Builder.abandon(
Begin);
186 void add(llvm::Constant *value) {
187 assert(value &&
"adding null value to constant initializer");
188 assert(!
Finished &&
"cannot add more values after finishing builder");
189 assert(!
Frozen &&
"cannot add values while subbuilder is active");
190 Builder.Buffer.push_back(value);
197 void addInt(llvm::IntegerType *intTy, uint64_t value,
198 bool isSigned =
false) {
199 add(llvm::ConstantInt::get(intTy, value, isSigned));
204 add(llvm::ConstantPointerNull::get(ptrTy));
209 add(llvm::ConstantExpr::getBitCast(value,
type));
214 assert(!
Finished &&
"cannot add more values after finishing builder");
215 assert(!
Frozen &&
"cannot add values while subbuilder is active");
216 Builder.Buffer.append(values.begin(), values.end());
226 add(getRelativeOffset(
type, target));
232 llvm::Constant *target,
size_t position) {
233 add(getRelativeOffsetToPosition(
type, target, position));
241 llvm::Constant *address,
243 llvm::Constant *offset = getRelativeOffset(
type, address);
245 offset = llvm::ConstantExpr::getAdd(offset,
246 llvm::ConstantInt::get(
type, tag));
257 assert(!
Finished &&
"cannot add more values after finishing builder");
258 assert(!
Frozen &&
"cannot add values while subbuilder is active");
259 return getOffsetFromGlobalTo(
Builder.Buffer.size());
279 assert(!
Finished &&
"cannot add more values after finishing builder");
280 assert(!
Frozen &&
"cannot add values while subbuilder is active");
281 Builder.Buffer.push_back(
nullptr);
282 return Builder.Buffer.size() - 1;
290 llvm::IntegerType *
type, uint64_t value,
291 bool isSigned =
false) {
297 assert(!
Finished &&
"cannot change values after finishing builder");
298 assert(!
Frozen &&
"cannot add values while subbuilder is active");
299 llvm::Constant *&slot =
Builder.Buffer[position.Index];
300 assert(slot ==
nullptr &&
"placeholder already filled");
322 getGEPIndicesTo(indices,
Builder.Buffer.size());
328 llvm::Constant *
finishStruct(llvm::StructType *structTy);
332 size_t position)
const;
334 llvm::Constant *getRelativeOffset(llvm::IntegerType *offsetType,
335 llvm::Constant *target);
337 llvm::Constant *getRelativeOffsetToPosition(llvm::IntegerType *offsetType,
338 llvm::Constant *target,
341 CharUnits getOffsetFromGlobalTo(
size_t index)
const;
344template <
class Impl,
class Traits>
346 :
public Traits::AggregateBuilderBase {
347 using super =
typename Traits::AggregateBuilderBase;
357 : super(builder, parent) {}
359 Impl &
asImpl() {
return *
static_cast<Impl*
>(
this); }
380 assert(this->
Parent == &parent &&
"adding to non-parent builder");
381 parent.add(
asImpl().finishImpl());
387 template <
class... As>
389 assert(!this->
Parent &&
"finishing non-root builder");
390 return this->Builder.createGlobal(
asImpl().finishImpl(),
391 std::forward<As>(args)...);
398 assert(!this->
Parent &&
"finishing non-root builder");
399 return this->Builder.setGlobalInitializer(global,
asImpl().finishImpl());
411 assert(!this->
Parent &&
"finishing non-root builder");
412 return this->Builder.createFuture(
asImpl().finishImpl());
416template <
class Traits>
430 template <
class,
class>
437 :
super(builder, parent), EltTy(eltTy) {}
442 llvm::Constant *finishImpl() {
443 return AggregateBuilderBase::finishArray(EltTy);
452template <
class Traits>
464 llvm::StructType *StructTy;
466 template <
class,
class>
472 llvm::StructType *structTy)
473 :
super(builder, parent), StructTy(structTy) {
474 if (structTy) this->Packed = structTy->isPacked();
479 this->Packed = packed;
485 if (this->size() == structTy->getNumElements()) {
493 llvm::Constant *finishImpl() {
494 return AggregateBuilderBase::finishStruct(StructTy);
503template <
class Traits>
523class ConstantInitBuilder;
524class ConstantStructBuilder;
525class ConstantArrayBuilder;
546 template <
class Traits>
550 template <
class Impl,
class Traits>
563 template <
class Traits>
567 template <
class Impl,
class Traits>
572 llvm::StructType *structTy)
CharUnits - This is an opaque type for sizes expressed in character units.
This class organizes the cross-function state that is used while generating LLVM code.
An opaque class to hold the abstract position of a placeholder.
A concrete base class for struct and array aggregate initializer builders.
ConstantAggregateBuilderBase & operator=(ConstantAggregateBuilderBase &&other)=delete
bool empty() const
Return true if no elements have yet been added to this struct or array.
void addTaggedRelativeOffset(llvm::IntegerType *type, llvm::Constant *address, unsigned tag)
Add a relative offset to the target address, plus a small constant offset.
void addRelativeOffset(llvm::IntegerType *type, llvm::Constant *target)
Add a relative offset to the given target address, i.e.
llvm::Constant * getAddrOfPosition(llvm::Type *type, size_t position)
Produce an address which points to a position in the aggregate being constructed.
CharUnits CachedOffsetFromGlobal
PlaceholderPosition addPlaceholder()
Add a placeholder value to the structure.
ConstantAggregateBuilderBase & operator=(const ConstantAggregateBuilderBase &)=delete
void addRelativeOffsetToPosition(llvm::IntegerType *type, llvm::Constant *target, size_t position)
Same as addRelativeOffset(), but instead relative to an element in this aggregate,...
void fillPlaceholder(PlaceholderPosition position, llvm::Constant *value)
Fill a previously-added placeholder.
llvm::SmallVectorImpl< llvm::Constant * > & getBuffer()
void abandon()
Abandon this builder completely.
void add(llvm::Constant *value)
Add a new value to this initializer.
llvm::Constant * finishArray(llvm::Type *eltTy)
PlaceholderPosition addPlaceholderWithSize(llvm::Type *expectedType)
Add a placeholder, giving the expected type that will be filled in.
void addSize(CharUnits size)
Add an integer value of type size_t.
void addInt(llvm::IntegerType *intTy, uint64_t value, bool isSigned=false)
Add an integer value of a specific type.
ConstantAggregateBuilderBase(ConstantAggregateBuilderBase &&other)
llvm::Constant * finishStruct(llvm::StructType *structTy)
llvm::Constant * getAddrOfCurrentPosition(llvm::Type *type)
Produce an address which will eventually point to the next position to be filled.
ConstantAggregateBuilderBase(ConstantInitBuilderBase &builder, ConstantAggregateBuilderBase *parent)
void addNullPointer(llvm::PointerType *ptrTy)
Add a null pointer of a specific type.
CharUnits getNextOffsetFromGlobal() const
Return the offset from the start of the initializer to the next position, assuming no padding is requ...
llvm::ArrayRef< llvm::Constant * > getGEPIndicesToCurrentPosition(llvm::SmallVectorImpl< llvm::Constant * > &indices)
void addAll(llvm::ArrayRef< llvm::Constant * > values)
Add a bunch of new values to this initializer.
const llvm::SmallVectorImpl< llvm::Constant * > & getBuffer() const
size_t size() const
Return the number of elements that have been added to this struct or array.
void addBitCast(llvm::Constant *value, llvm::Type *type)
Add a bitcast of a value to a specific type.
~ConstantAggregateBuilderBase()
ConstantInitBuilderBase & Builder
void fillPlaceholderWithInt(PlaceholderPosition position, llvm::IntegerType *type, uint64_t value, bool isSigned=false)
Fill a previously-added placeholder.
ConstantAggregateBuilderBase * Parent
ConstantAggregateBuilderBase(const ConstantAggregateBuilderBase &)=delete
ArrayBuilder beginArray(llvm::Type *eltTy=nullptr)
llvm::GlobalVariable * finishAndCreateGlobal(As &&...args)
Given that this builder was created by beginning an array or struct directly on a ConstantInitBuilder...
ConstantInitFuture finishAndCreateFuture()
Given that this builder was created by beginning an array or struct directly on a ConstantInitBuilder...
ConstantAggregateBuilderTemplateBase(InitBuilder &builder, AggregateBuilderBase *parent)
typename Traits::StructBuilder StructBuilder
typename Traits::ArrayBuilder ArrayBuilder
void finishAndSetAsInitializer(llvm::GlobalVariable *global)
Given that this builder was created by beginning an array or struct directly on a ConstantInitBuilder...
typename Traits::InitBuilder InitBuilder
StructBuilder beginStruct(llvm::StructType *ty=nullptr)
typename Traits::AggregateBuilderBase AggregateBuilderBase
void finishAndAddTo(AggregateBuilderBase &parent)
Given that this builder was created by beginning an array or struct component on the given parent bui...
typename Traits::InitBuilder InitBuilder
ConstantArrayBuilderTemplateBase(InitBuilder &builder, AggregateBuilderBase *parent, llvm::Type *eltTy)
typename Traits::AggregateBuilderBase AggregateBuilderBase
A helper class of ConstantInitBuilder, used for building constant array initializers.
A convenience builder class for complex constant initializers, especially for anonymous global struct...
~ConstantInitBuilderBase()
ConstantInitBuilderBase(CodeGenModule &CGM)
A template class designed to allow other frontends to easily customize the builder classes used by Co...
StructBuilder beginStruct(llvm::StructType *structTy=nullptr)
ArrayBuilder beginArray(llvm::Type *eltTy=nullptr)
typename Traits::StructBuilder StructBuilder
typename Traits::InitBuilder InitBuilder
ConstantInitBuilderTemplateBase(CodeGenModule &CGM)
typename Traits::ArrayBuilder ArrayBuilder
The standard implementation of ConstantInitBuilder used in Clang.
ConstantInitBuilder(CodeGenModule &CGM)
A "future" for a completed constant initializer, which can be passed around independently of any sub-...
A template class designed to allow other frontends to easily customize the builder classes used by Co...
ConstantStructBuilderTemplateBase(InitBuilder &builder, AggregateBuilderBase *parent, llvm::StructType *structTy)
void suggestType(llvm::StructType *structTy)
Use the given type for the struct if its element count is correct.
void setPacked(bool packed)
typename Traits::AggregateBuilderBase AggregateBuilderBase
typename Traits::InitBuilder InitBuilder
A helper class of ConstantInitBuilder, used for building constant struct initializers.
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.