mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-12-16 11:30:51 +00:00
dad20b2ae2
Split `Metadata` away from the `Value` class hierarchy, as part of PR21532. Assembly and bitcode changes are in the wings, but this is the bulk of the change for the IR C++ API. I have a follow-up patch prepared for `clang`. If this breaks other sub-projects, I apologize in advance :(. Help me compile it on Darwin I'll try to fix it. FWIW, the errors should be easy to fix, so it may be simpler to just fix it yourself. This breaks the build for all metadata-related code that's out-of-tree. Rest assured the transition is mechanical and the compiler should catch almost all of the problems. Here's a quick guide for updating your code: - `Metadata` is the root of a class hierarchy with three main classes: `MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from the `Value` class hierarchy. It is typeless -- i.e., instances do *not* have a `Type`. - `MDNode`'s operands are all `Metadata *` (instead of `Value *`). - `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively. If you're referring solely to resolved `MDNode`s -- post graph construction -- just use `MDNode*`. - `MDNode` (and the rest of `Metadata`) have only limited support for `replaceAllUsesWith()`. As long as an `MDNode` is pointing at a forward declaration -- the result of `MDNode::getTemporary()` -- it maintains a side map of its uses and can RAUW itself. Once the forward declarations are fully resolved RAUW support is dropped on the ground. This means that uniquing collisions on changing operands cause nodes to become "distinct". (This already happened fairly commonly, whenever an operand went to null.) If you're constructing complex (non self-reference) `MDNode` cycles, you need to call `MDNode::resolveCycles()` on each node (or on a top-level node that somehow references all of the nodes). Also, don't do that. Metadata cycles (and the RAUW machinery needed to construct them) are expensive. - An `MDNode` can only refer to a `Constant` through a bridge called `ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`). As a side effect, accessing an operand of an `MDNode` that is known to be, e.g., `ConstantInt`, takes three steps: first, cast from `Metadata` to `ConstantAsMetadata`; second, extract the `Constant`; third, cast down to `ConstantInt`. The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have metadata schema owners transition away from using `Constant`s when the type isn't important (and they don't care about referring to `GlobalValue`s). In the meantime, I've added transitional API to the `mdconst` namespace that matches semantics with the old code, in order to avoid adding the error-prone three-step equivalent to every call site. If your old code was: MDNode *N = foo(); bar(isa <ConstantInt>(N->getOperand(0))); baz(cast <ConstantInt>(N->getOperand(1))); bak(cast_or_null <ConstantInt>(N->getOperand(2))); bat(dyn_cast <ConstantInt>(N->getOperand(3))); bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4))); you can trivially match its semantics with: MDNode *N = foo(); bar(mdconst::hasa <ConstantInt>(N->getOperand(0))); baz(mdconst::extract <ConstantInt>(N->getOperand(1))); bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2))); bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3))); bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4))); and when you transition your metadata schema to `MDInt`: MDNode *N = foo(); bar(isa <MDInt>(N->getOperand(0))); baz(cast <MDInt>(N->getOperand(1))); bak(cast_or_null <MDInt>(N->getOperand(2))); bat(dyn_cast <MDInt>(N->getOperand(3))); bay(dyn_cast_or_null<MDInt>(N->getOperand(4))); - A `CallInst` -- specifically, intrinsic instructions -- can refer to metadata through a bridge called `MetadataAsValue`. This is a subclass of `Value` where `getType()->isMetadataTy()`. `MetadataAsValue` is the *only* class that can legally refer to a `LocalAsMetadata`, which is a bridged form of non-`Constant` values like `Argument` and `Instruction`. It can also refer to any other `Metadata` subclass. (I'll break all your testcases in a follow-up commit, when I propagate this change to assembly.) git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@223802 91177308-0d34-0410-b5e6-96231b3b80d8
357 lines
12 KiB
C++
357 lines
12 KiB
C++
//===-- LLVMContextImpl.h - The LLVMContextImpl opaque class ----*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file declares LLVMContextImpl, the opaque implementation
|
|
// of LLVMContext.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_LIB_IR_LLVMCONTEXTIMPL_H
|
|
#define LLVM_LIB_IR_LLVMCONTEXTIMPL_H
|
|
|
|
#include "AttributeImpl.h"
|
|
#include "ConstantsContext.h"
|
|
#include "LeaksContext.h"
|
|
#include "llvm/ADT/APFloat.h"
|
|
#include "llvm/ADT/APInt.h"
|
|
#include "llvm/ADT/ArrayRef.h"
|
|
#include "llvm/ADT/DenseMap.h"
|
|
#include "llvm/ADT/DenseSet.h"
|
|
#include "llvm/ADT/FoldingSet.h"
|
|
#include "llvm/ADT/Hashing.h"
|
|
#include "llvm/ADT/SmallPtrSet.h"
|
|
#include "llvm/ADT/StringMap.h"
|
|
#include "llvm/IR/Constants.h"
|
|
#include "llvm/IR/DerivedTypes.h"
|
|
#include "llvm/IR/LLVMContext.h"
|
|
#include "llvm/IR/Metadata.h"
|
|
#include "llvm/IR/ValueHandle.h"
|
|
#include <vector>
|
|
|
|
namespace llvm {
|
|
|
|
class ConstantInt;
|
|
class ConstantFP;
|
|
class DiagnosticInfoOptimizationRemark;
|
|
class DiagnosticInfoOptimizationRemarkMissed;
|
|
class DiagnosticInfoOptimizationRemarkAnalysis;
|
|
class LLVMContext;
|
|
class Type;
|
|
class Value;
|
|
|
|
struct DenseMapAPIntKeyInfo {
|
|
static inline APInt getEmptyKey() {
|
|
APInt V(nullptr, 0);
|
|
V.VAL = 0;
|
|
return V;
|
|
}
|
|
static inline APInt getTombstoneKey() {
|
|
APInt V(nullptr, 0);
|
|
V.VAL = 1;
|
|
return V;
|
|
}
|
|
static unsigned getHashValue(const APInt &Key) {
|
|
return static_cast<unsigned>(hash_value(Key));
|
|
}
|
|
static bool isEqual(const APInt &LHS, const APInt &RHS) {
|
|
return LHS.getBitWidth() == RHS.getBitWidth() && LHS == RHS;
|
|
}
|
|
};
|
|
|
|
struct DenseMapAPFloatKeyInfo {
|
|
static inline APFloat getEmptyKey() { return APFloat(APFloat::Bogus, 1); }
|
|
static inline APFloat getTombstoneKey() { return APFloat(APFloat::Bogus, 2); }
|
|
static unsigned getHashValue(const APFloat &Key) {
|
|
return static_cast<unsigned>(hash_value(Key));
|
|
}
|
|
static bool isEqual(const APFloat &LHS, const APFloat &RHS) {
|
|
return LHS.bitwiseIsEqual(RHS);
|
|
}
|
|
};
|
|
|
|
struct AnonStructTypeKeyInfo {
|
|
struct KeyTy {
|
|
ArrayRef<Type*> ETypes;
|
|
bool isPacked;
|
|
KeyTy(const ArrayRef<Type*>& E, bool P) :
|
|
ETypes(E), isPacked(P) {}
|
|
KeyTy(const StructType *ST)
|
|
: ETypes(ST->elements()), isPacked(ST->isPacked()) {}
|
|
bool operator==(const KeyTy& that) const {
|
|
if (isPacked != that.isPacked)
|
|
return false;
|
|
if (ETypes != that.ETypes)
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator!=(const KeyTy& that) const {
|
|
return !this->operator==(that);
|
|
}
|
|
};
|
|
static inline StructType* getEmptyKey() {
|
|
return DenseMapInfo<StructType*>::getEmptyKey();
|
|
}
|
|
static inline StructType* getTombstoneKey() {
|
|
return DenseMapInfo<StructType*>::getTombstoneKey();
|
|
}
|
|
static unsigned getHashValue(const KeyTy& Key) {
|
|
return hash_combine(hash_combine_range(Key.ETypes.begin(),
|
|
Key.ETypes.end()),
|
|
Key.isPacked);
|
|
}
|
|
static unsigned getHashValue(const StructType *ST) {
|
|
return getHashValue(KeyTy(ST));
|
|
}
|
|
static bool isEqual(const KeyTy& LHS, const StructType *RHS) {
|
|
if (RHS == getEmptyKey() || RHS == getTombstoneKey())
|
|
return false;
|
|
return LHS == KeyTy(RHS);
|
|
}
|
|
static bool isEqual(const StructType *LHS, const StructType *RHS) {
|
|
return LHS == RHS;
|
|
}
|
|
};
|
|
|
|
struct FunctionTypeKeyInfo {
|
|
struct KeyTy {
|
|
const Type *ReturnType;
|
|
ArrayRef<Type*> Params;
|
|
bool isVarArg;
|
|
KeyTy(const Type* R, const ArrayRef<Type*>& P, bool V) :
|
|
ReturnType(R), Params(P), isVarArg(V) {}
|
|
KeyTy(const FunctionType *FT)
|
|
: ReturnType(FT->getReturnType()), Params(FT->params()),
|
|
isVarArg(FT->isVarArg()) {}
|
|
bool operator==(const KeyTy& that) const {
|
|
if (ReturnType != that.ReturnType)
|
|
return false;
|
|
if (isVarArg != that.isVarArg)
|
|
return false;
|
|
if (Params != that.Params)
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator!=(const KeyTy& that) const {
|
|
return !this->operator==(that);
|
|
}
|
|
};
|
|
static inline FunctionType* getEmptyKey() {
|
|
return DenseMapInfo<FunctionType*>::getEmptyKey();
|
|
}
|
|
static inline FunctionType* getTombstoneKey() {
|
|
return DenseMapInfo<FunctionType*>::getTombstoneKey();
|
|
}
|
|
static unsigned getHashValue(const KeyTy& Key) {
|
|
return hash_combine(Key.ReturnType,
|
|
hash_combine_range(Key.Params.begin(),
|
|
Key.Params.end()),
|
|
Key.isVarArg);
|
|
}
|
|
static unsigned getHashValue(const FunctionType *FT) {
|
|
return getHashValue(KeyTy(FT));
|
|
}
|
|
static bool isEqual(const KeyTy& LHS, const FunctionType *RHS) {
|
|
if (RHS == getEmptyKey() || RHS == getTombstoneKey())
|
|
return false;
|
|
return LHS == KeyTy(RHS);
|
|
}
|
|
static bool isEqual(const FunctionType *LHS, const FunctionType *RHS) {
|
|
return LHS == RHS;
|
|
}
|
|
};
|
|
|
|
/// \brief DenseMapInfo for GenericMDNode.
|
|
///
|
|
/// Note that we don't need the is-function-local bit, since that's implicit in
|
|
/// the operands.
|
|
struct GenericMDNodeInfo {
|
|
struct KeyTy {
|
|
ArrayRef<Metadata *> RawOps;
|
|
ArrayRef<MDOperand> Ops;
|
|
unsigned Hash;
|
|
|
|
KeyTy(ArrayRef<Metadata *> Ops)
|
|
: RawOps(Ops), Hash(hash_combine_range(Ops.begin(), Ops.end())) {}
|
|
|
|
KeyTy(GenericMDNode *N)
|
|
: Ops(N->op_begin(), N->op_end()), Hash(N->getHash()) {}
|
|
|
|
bool operator==(const GenericMDNode *RHS) const {
|
|
if (RHS == getEmptyKey() || RHS == getTombstoneKey())
|
|
return false;
|
|
if (Hash != RHS->getHash())
|
|
return false;
|
|
assert((RawOps.empty() || Ops.empty()) && "Two sets of operands?");
|
|
return RawOps.empty() ? compareOps(Ops, RHS) : compareOps(RawOps, RHS);
|
|
}
|
|
template <class T>
|
|
static bool compareOps(ArrayRef<T> Ops, const GenericMDNode *RHS) {
|
|
if (Ops.size() != RHS->getNumOperands())
|
|
return false;
|
|
return std::equal(Ops.begin(), Ops.end(), RHS->op_begin());
|
|
}
|
|
};
|
|
static inline GenericMDNode *getEmptyKey() {
|
|
return DenseMapInfo<GenericMDNode *>::getEmptyKey();
|
|
}
|
|
static inline GenericMDNode *getTombstoneKey() {
|
|
return DenseMapInfo<GenericMDNode *>::getTombstoneKey();
|
|
}
|
|
static unsigned getHashValue(const KeyTy &Key) { return Key.Hash; }
|
|
static unsigned getHashValue(const GenericMDNode *U) {
|
|
return U->getHash();
|
|
}
|
|
static bool isEqual(const KeyTy &LHS, const GenericMDNode *RHS) {
|
|
return LHS == RHS;
|
|
}
|
|
static bool isEqual(const GenericMDNode *LHS, const GenericMDNode *RHS) {
|
|
return LHS == RHS;
|
|
}
|
|
};
|
|
|
|
class LLVMContextImpl {
|
|
public:
|
|
/// OwnedModules - The set of modules instantiated in this context, and which
|
|
/// will be automatically deleted if this context is deleted.
|
|
SmallPtrSet<Module*, 4> OwnedModules;
|
|
|
|
LLVMContext::InlineAsmDiagHandlerTy InlineAsmDiagHandler;
|
|
void *InlineAsmDiagContext;
|
|
|
|
LLVMContext::DiagnosticHandlerTy DiagnosticHandler;
|
|
void *DiagnosticContext;
|
|
bool RespectDiagnosticFilters;
|
|
|
|
LLVMContext::YieldCallbackTy YieldCallback;
|
|
void *YieldOpaqueHandle;
|
|
|
|
typedef DenseMap<APInt, ConstantInt *, DenseMapAPIntKeyInfo> IntMapTy;
|
|
IntMapTy IntConstants;
|
|
|
|
typedef DenseMap<APFloat, ConstantFP *, DenseMapAPFloatKeyInfo> FPMapTy;
|
|
FPMapTy FPConstants;
|
|
|
|
FoldingSet<AttributeImpl> AttrsSet;
|
|
FoldingSet<AttributeSetImpl> AttrsLists;
|
|
FoldingSet<AttributeSetNode> AttrsSetNodes;
|
|
|
|
StringMap<MDString> MDStringCache;
|
|
DenseMap<Value *, ValueAsMetadata *> ValuesAsMetadata;
|
|
DenseMap<Metadata *, MetadataAsValue *> MetadataAsValues;
|
|
|
|
DenseSet<GenericMDNode *, GenericMDNodeInfo> MDNodeSet;
|
|
|
|
// MDNodes may be uniqued or not uniqued. When they're not uniqued, they
|
|
// aren't in the MDNodeSet, but they're still shared between objects, so no
|
|
// one object can destroy them. This set allows us to at least destroy them
|
|
// on Context destruction.
|
|
SmallPtrSet<GenericMDNode *, 1> NonUniquedMDNodes;
|
|
|
|
DenseMap<Type*, ConstantAggregateZero*> CAZConstants;
|
|
|
|
typedef ConstantUniqueMap<ConstantArray> ArrayConstantsTy;
|
|
ArrayConstantsTy ArrayConstants;
|
|
|
|
typedef ConstantUniqueMap<ConstantStruct> StructConstantsTy;
|
|
StructConstantsTy StructConstants;
|
|
|
|
typedef ConstantUniqueMap<ConstantVector> VectorConstantsTy;
|
|
VectorConstantsTy VectorConstants;
|
|
|
|
DenseMap<PointerType*, ConstantPointerNull*> CPNConstants;
|
|
|
|
DenseMap<Type*, UndefValue*> UVConstants;
|
|
|
|
StringMap<ConstantDataSequential*> CDSConstants;
|
|
|
|
DenseMap<std::pair<const Function *, const BasicBlock *>, BlockAddress *>
|
|
BlockAddresses;
|
|
ConstantUniqueMap<ConstantExpr> ExprConstants;
|
|
|
|
ConstantUniqueMap<InlineAsm> InlineAsms;
|
|
|
|
ConstantInt *TheTrueVal;
|
|
ConstantInt *TheFalseVal;
|
|
|
|
LeakDetectorImpl<Value> LLVMObjects;
|
|
LeakDetectorImpl<Metadata> LLVMMDObjects;
|
|
|
|
// Basic type instances.
|
|
Type VoidTy, LabelTy, HalfTy, FloatTy, DoubleTy, MetadataTy;
|
|
Type X86_FP80Ty, FP128Ty, PPC_FP128Ty, X86_MMXTy;
|
|
IntegerType Int1Ty, Int8Ty, Int16Ty, Int32Ty, Int64Ty;
|
|
|
|
|
|
/// TypeAllocator - All dynamically allocated types are allocated from this.
|
|
/// They live forever until the context is torn down.
|
|
BumpPtrAllocator TypeAllocator;
|
|
|
|
DenseMap<unsigned, IntegerType*> IntegerTypes;
|
|
|
|
typedef DenseSet<FunctionType *, FunctionTypeKeyInfo> FunctionTypeSet;
|
|
FunctionTypeSet FunctionTypes;
|
|
typedef DenseSet<StructType *, AnonStructTypeKeyInfo> StructTypeSet;
|
|
StructTypeSet AnonStructTypes;
|
|
StringMap<StructType*> NamedStructTypes;
|
|
unsigned NamedStructTypesUniqueID;
|
|
|
|
DenseMap<std::pair<Type *, uint64_t>, ArrayType*> ArrayTypes;
|
|
DenseMap<std::pair<Type *, unsigned>, VectorType*> VectorTypes;
|
|
DenseMap<Type*, PointerType*> PointerTypes; // Pointers in AddrSpace = 0
|
|
DenseMap<std::pair<Type*, unsigned>, PointerType*> ASPointerTypes;
|
|
|
|
|
|
/// ValueHandles - This map keeps track of all of the value handles that are
|
|
/// watching a Value*. The Value::HasValueHandle bit is used to know
|
|
/// whether or not a value has an entry in this map.
|
|
typedef DenseMap<Value*, ValueHandleBase*> ValueHandlesTy;
|
|
ValueHandlesTy ValueHandles;
|
|
|
|
/// CustomMDKindNames - Map to hold the metadata string to ID mapping.
|
|
StringMap<unsigned> CustomMDKindNames;
|
|
|
|
typedef std::pair<unsigned, TrackingMDNodeRef> MDPairTy;
|
|
typedef SmallVector<MDPairTy, 2> MDMapTy;
|
|
|
|
/// MetadataStore - Collection of per-instruction metadata used in this
|
|
/// context.
|
|
DenseMap<const Instruction *, MDMapTy> MetadataStore;
|
|
|
|
/// DiscriminatorTable - This table maps file:line locations to an
|
|
/// integer representing the next DWARF path discriminator to assign to
|
|
/// instructions in different blocks at the same location.
|
|
DenseMap<std::pair<const char *, unsigned>, unsigned> DiscriminatorTable;
|
|
|
|
/// IntrinsicIDCache - Cache of intrinsic name (string) to numeric ID mappings
|
|
/// requested in this context
|
|
typedef DenseMap<const Function*, unsigned> IntrinsicIDCacheTy;
|
|
IntrinsicIDCacheTy IntrinsicIDCache;
|
|
|
|
/// \brief Mapping from a function to its prefix data, which is stored as the
|
|
/// operand of an unparented ReturnInst so that the prefix data has a Use.
|
|
typedef DenseMap<const Function *, ReturnInst *> PrefixDataMapTy;
|
|
PrefixDataMapTy PrefixDataMap;
|
|
|
|
/// \brief Mapping from a function to its prologue data, which is stored as
|
|
/// the operand of an unparented ReturnInst so that the prologue data has a
|
|
/// Use.
|
|
typedef DenseMap<const Function *, ReturnInst *> PrologueDataMapTy;
|
|
PrologueDataMapTy PrologueDataMap;
|
|
|
|
int getOrAddScopeRecordIdxEntry(MDNode *N, int ExistingIdx);
|
|
int getOrAddScopeInlinedAtIdxEntry(MDNode *Scope, MDNode *IA,int ExistingIdx);
|
|
|
|
LLVMContextImpl(LLVMContext &C);
|
|
~LLVMContextImpl();
|
|
};
|
|
|
|
}
|
|
|
|
#endif
|