mirror of
https://github.com/RPCSX/llvm.git
synced 2024-12-25 13:35:39 +00:00
6707770d48
Summary: This class is a list of AttributeSetNodes corresponding the function prototype of a call or function declaration. This class used to be called ParamAttrListPtr, then AttrListPtr, then AttributeSet. It is typically accessed by parameter and return value index, so "AttributeList" seems like a more intuitive name. Rename AttributeSetImpl to AttributeListImpl to follow suit. It's useful to rename this class so that we can rename AttributeSetNode to AttributeSet later. AttributeSet is the set of attributes that apply to a single function, argument, or return value. Reviewers: sanjoy, javed.absar, chandlerc, pete Reviewed By: pete Subscribers: pete, jholewinski, arsenm, dschuff, mehdi_amini, jfb, nhaehnle, sbc100, void, llvm-commits Differential Revision: https://reviews.llvm.org/D31102 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@298393 91177308-0d34-0410-b5e6-96231b3b80d8
255 lines
7.8 KiB
C++
255 lines
7.8 KiB
C++
//===-- LLVMContextImpl.cpp - Implement LLVMContextImpl -------------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file implements the opaque LLVMContextImpl.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "LLVMContextImpl.h"
|
|
#include "llvm/ADT/STLExtras.h"
|
|
#include "llvm/IR/Attributes.h"
|
|
#include "llvm/IR/DiagnosticInfo.h"
|
|
#include "llvm/IR/Module.h"
|
|
#include "llvm/IR/OptBisect.h"
|
|
#include "llvm/Support/ManagedStatic.h"
|
|
#include <algorithm>
|
|
using namespace llvm;
|
|
|
|
LLVMContextImpl::LLVMContextImpl(LLVMContext &C)
|
|
: TheTrueVal(nullptr), TheFalseVal(nullptr),
|
|
VoidTy(C, Type::VoidTyID),
|
|
LabelTy(C, Type::LabelTyID),
|
|
HalfTy(C, Type::HalfTyID),
|
|
FloatTy(C, Type::FloatTyID),
|
|
DoubleTy(C, Type::DoubleTyID),
|
|
MetadataTy(C, Type::MetadataTyID),
|
|
TokenTy(C, Type::TokenTyID),
|
|
X86_FP80Ty(C, Type::X86_FP80TyID),
|
|
FP128Ty(C, Type::FP128TyID),
|
|
PPC_FP128Ty(C, Type::PPC_FP128TyID),
|
|
X86_MMXTy(C, Type::X86_MMXTyID),
|
|
Int1Ty(C, 1),
|
|
Int8Ty(C, 8),
|
|
Int16Ty(C, 16),
|
|
Int32Ty(C, 32),
|
|
Int64Ty(C, 64),
|
|
Int128Ty(C, 128) {
|
|
InlineAsmDiagHandler = nullptr;
|
|
InlineAsmDiagContext = nullptr;
|
|
DiagnosticHandler = nullptr;
|
|
DiagnosticContext = nullptr;
|
|
RespectDiagnosticFilters = false;
|
|
DiagnosticHotnessRequested = false;
|
|
YieldCallback = nullptr;
|
|
YieldOpaqueHandle = nullptr;
|
|
NamedStructTypesUniqueID = 0;
|
|
}
|
|
|
|
LLVMContextImpl::~LLVMContextImpl() {
|
|
// NOTE: We need to delete the contents of OwnedModules, but Module's dtor
|
|
// will call LLVMContextImpl::removeModule, thus invalidating iterators into
|
|
// the container. Avoid iterators during this operation:
|
|
while (!OwnedModules.empty())
|
|
delete *OwnedModules.begin();
|
|
|
|
// Drop references for MDNodes. Do this before Values get deleted to avoid
|
|
// unnecessary RAUW when nodes are still unresolved.
|
|
for (auto *I : DistinctMDNodes)
|
|
I->dropAllReferences();
|
|
#define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS) \
|
|
for (auto *I : CLASS##s) \
|
|
I->dropAllReferences();
|
|
#include "llvm/IR/Metadata.def"
|
|
|
|
// Also drop references that come from the Value bridges.
|
|
for (auto &Pair : ValuesAsMetadata)
|
|
Pair.second->dropUsers();
|
|
for (auto &Pair : MetadataAsValues)
|
|
Pair.second->dropUse();
|
|
|
|
// Destroy MDNodes.
|
|
for (MDNode *I : DistinctMDNodes)
|
|
I->deleteAsSubclass();
|
|
#define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS) \
|
|
for (CLASS * I : CLASS##s) \
|
|
delete I;
|
|
#include "llvm/IR/Metadata.def"
|
|
|
|
// Free the constants.
|
|
for (auto *I : ExprConstants)
|
|
I->dropAllReferences();
|
|
for (auto *I : ArrayConstants)
|
|
I->dropAllReferences();
|
|
for (auto *I : StructConstants)
|
|
I->dropAllReferences();
|
|
for (auto *I : VectorConstants)
|
|
I->dropAllReferences();
|
|
ExprConstants.freeConstants();
|
|
ArrayConstants.freeConstants();
|
|
StructConstants.freeConstants();
|
|
VectorConstants.freeConstants();
|
|
InlineAsms.freeConstants();
|
|
|
|
CAZConstants.clear();
|
|
CPNConstants.clear();
|
|
UVConstants.clear();
|
|
IntConstants.clear();
|
|
FPConstants.clear();
|
|
|
|
for (auto &CDSConstant : CDSConstants)
|
|
delete CDSConstant.second;
|
|
CDSConstants.clear();
|
|
|
|
// Destroy attributes.
|
|
for (FoldingSetIterator<AttributeImpl> I = AttrsSet.begin(),
|
|
E = AttrsSet.end(); I != E; ) {
|
|
FoldingSetIterator<AttributeImpl> Elem = I++;
|
|
delete &*Elem;
|
|
}
|
|
|
|
// Destroy attribute lists.
|
|
for (FoldingSetIterator<AttributeListImpl> I = AttrsLists.begin(),
|
|
E = AttrsLists.end();
|
|
I != E;) {
|
|
FoldingSetIterator<AttributeListImpl> Elem = I++;
|
|
delete &*Elem;
|
|
}
|
|
|
|
// Destroy attribute node lists.
|
|
for (FoldingSetIterator<AttributeSetNode> I = AttrsSetNodes.begin(),
|
|
E = AttrsSetNodes.end(); I != E; ) {
|
|
FoldingSetIterator<AttributeSetNode> Elem = I++;
|
|
delete &*Elem;
|
|
}
|
|
|
|
// Destroy MetadataAsValues.
|
|
{
|
|
SmallVector<MetadataAsValue *, 8> MDVs;
|
|
MDVs.reserve(MetadataAsValues.size());
|
|
for (auto &Pair : MetadataAsValues)
|
|
MDVs.push_back(Pair.second);
|
|
MetadataAsValues.clear();
|
|
for (auto *V : MDVs)
|
|
delete V;
|
|
}
|
|
|
|
// Destroy ValuesAsMetadata.
|
|
for (auto &Pair : ValuesAsMetadata)
|
|
delete Pair.second;
|
|
}
|
|
|
|
void LLVMContextImpl::dropTriviallyDeadConstantArrays() {
|
|
bool Changed;
|
|
do {
|
|
Changed = false;
|
|
|
|
for (auto I = ArrayConstants.begin(), E = ArrayConstants.end(); I != E;) {
|
|
auto *C = *I++;
|
|
if (C->use_empty()) {
|
|
Changed = true;
|
|
C->destroyConstant();
|
|
}
|
|
}
|
|
|
|
} while (Changed);
|
|
}
|
|
|
|
void Module::dropTriviallyDeadConstantArrays() {
|
|
Context.pImpl->dropTriviallyDeadConstantArrays();
|
|
}
|
|
|
|
namespace llvm {
|
|
/// \brief Make MDOperand transparent for hashing.
|
|
///
|
|
/// This overload of an implementation detail of the hashing library makes
|
|
/// MDOperand hash to the same value as a \a Metadata pointer.
|
|
///
|
|
/// Note that overloading \a hash_value() as follows:
|
|
///
|
|
/// \code
|
|
/// size_t hash_value(const MDOperand &X) { return hash_value(X.get()); }
|
|
/// \endcode
|
|
///
|
|
/// does not cause MDOperand to be transparent. In particular, a bare pointer
|
|
/// doesn't get hashed before it's combined, whereas \a MDOperand would.
|
|
static const Metadata *get_hashable_data(const MDOperand &X) { return X.get(); }
|
|
}
|
|
|
|
unsigned MDNodeOpsKey::calculateHash(MDNode *N, unsigned Offset) {
|
|
unsigned Hash = hash_combine_range(N->op_begin() + Offset, N->op_end());
|
|
#ifndef NDEBUG
|
|
{
|
|
SmallVector<Metadata *, 8> MDs(N->op_begin() + Offset, N->op_end());
|
|
unsigned RawHash = calculateHash(MDs);
|
|
assert(Hash == RawHash &&
|
|
"Expected hash of MDOperand to equal hash of Metadata*");
|
|
}
|
|
#endif
|
|
return Hash;
|
|
}
|
|
|
|
unsigned MDNodeOpsKey::calculateHash(ArrayRef<Metadata *> Ops) {
|
|
return hash_combine_range(Ops.begin(), Ops.end());
|
|
}
|
|
|
|
StringMapEntry<uint32_t> *LLVMContextImpl::getOrInsertBundleTag(StringRef Tag) {
|
|
uint32_t NewIdx = BundleTagCache.size();
|
|
return &*(BundleTagCache.insert(std::make_pair(Tag, NewIdx)).first);
|
|
}
|
|
|
|
void LLVMContextImpl::getOperandBundleTags(SmallVectorImpl<StringRef> &Tags) const {
|
|
Tags.resize(BundleTagCache.size());
|
|
for (const auto &T : BundleTagCache)
|
|
Tags[T.second] = T.first();
|
|
}
|
|
|
|
uint32_t LLVMContextImpl::getOperandBundleTagID(StringRef Tag) const {
|
|
auto I = BundleTagCache.find(Tag);
|
|
assert(I != BundleTagCache.end() && "Unknown tag!");
|
|
return I->second;
|
|
}
|
|
|
|
// ConstantsContext anchors
|
|
void UnaryConstantExpr::anchor() { }
|
|
|
|
void BinaryConstantExpr::anchor() { }
|
|
|
|
void SelectConstantExpr::anchor() { }
|
|
|
|
void ExtractElementConstantExpr::anchor() { }
|
|
|
|
void InsertElementConstantExpr::anchor() { }
|
|
|
|
void ShuffleVectorConstantExpr::anchor() { }
|
|
|
|
void ExtractValueConstantExpr::anchor() { }
|
|
|
|
void InsertValueConstantExpr::anchor() { }
|
|
|
|
void GetElementPtrConstantExpr::anchor() { }
|
|
|
|
void CompareConstantExpr::anchor() { }
|
|
|
|
/// Singleton instance of the OptBisect class.
|
|
///
|
|
/// This singleton is accessed via the LLVMContext::getOptBisect() function. It
|
|
/// provides a mechanism to disable passes and individual optimizations at
|
|
/// compile time based on a command line option (-opt-bisect-limit) in order to
|
|
/// perform a bisecting search for optimization-related problems.
|
|
///
|
|
/// Even if multiple LLVMContext objects are created, they will all return the
|
|
/// same instance of OptBisect in order to provide a single bisect count. Any
|
|
/// code that uses the OptBisect object should be serialized when bisection is
|
|
/// enabled in order to enable a consistent bisect count.
|
|
static ManagedStatic<OptBisect> OptBisector;
|
|
|
|
OptBisect &LLVMContextImpl::getOptBisect() {
|
|
return *OptBisector;
|
|
}
|