1249259Sdim//===-- LLVMContextImpl.cpp - Implement LLVMContextImpl -------------------===// 2249259Sdim// 3249259Sdim// The LLVM Compiler Infrastructure 4249259Sdim// 5249259Sdim// This file is distributed under the University of Illinois Open Source 6249259Sdim// License. See LICENSE.TXT for details. 7249259Sdim// 8249259Sdim//===----------------------------------------------------------------------===// 9249259Sdim// 10249259Sdim// This file implements the opaque LLVMContextImpl. 11249259Sdim// 12249259Sdim//===----------------------------------------------------------------------===// 13249259Sdim 14249259Sdim#include "LLVMContextImpl.h" 15249259Sdim#include "llvm/ADT/STLExtras.h" 16249259Sdim#include "llvm/IR/Attributes.h" 17276479Sdim#include "llvm/IR/DiagnosticInfo.h" 18249259Sdim#include "llvm/IR/Module.h" 19249259Sdim#include <algorithm> 20249259Sdimusing namespace llvm; 21249259Sdim 22249259SdimLLVMContextImpl::LLVMContextImpl(LLVMContext &C) 23276479Sdim : TheTrueVal(nullptr), TheFalseVal(nullptr), 24249259Sdim VoidTy(C, Type::VoidTyID), 25249259Sdim LabelTy(C, Type::LabelTyID), 26249259Sdim HalfTy(C, Type::HalfTyID), 27249259Sdim FloatTy(C, Type::FloatTyID), 28249259Sdim DoubleTy(C, Type::DoubleTyID), 29249259Sdim MetadataTy(C, Type::MetadataTyID), 30296417Sdim TokenTy(C, Type::TokenTyID), 31249259Sdim X86_FP80Ty(C, Type::X86_FP80TyID), 32249259Sdim FP128Ty(C, Type::FP128TyID), 33249259Sdim PPC_FP128Ty(C, Type::PPC_FP128TyID), 34249259Sdim X86_MMXTy(C, Type::X86_MMXTyID), 35249259Sdim Int1Ty(C, 1), 36249259Sdim Int8Ty(C, 8), 37249259Sdim Int16Ty(C, 16), 38249259Sdim Int32Ty(C, 32), 39288943Sdim Int64Ty(C, 64), 40288943Sdim Int128Ty(C, 128) { 41276479Sdim InlineAsmDiagHandler = nullptr; 42276479Sdim InlineAsmDiagContext = nullptr; 43276479Sdim DiagnosticHandler = nullptr; 44276479Sdim DiagnosticContext = nullptr; 45280031Sdim RespectDiagnosticFilters = false; 46276479Sdim YieldCallback = nullptr; 47276479Sdim YieldOpaqueHandle = nullptr; 48249259Sdim NamedStructTypesUniqueID = 0; 49249259Sdim} 50249259Sdim 51249259Sdimnamespace { 52249259Sdimstruct DropReferences { 53249259Sdim // Takes the value_type of a ConstantUniqueMap's internal map, whose 'second' 54249259Sdim // is a Constant*. 55276479Sdim template <typename PairT> void operator()(const PairT &P) { 56249259Sdim P.second->dropAllReferences(); 57249259Sdim } 58249259Sdim}; 59249259Sdim 60249259Sdim// Temporary - drops pair.first instead of second. 61249259Sdimstruct DropFirst { 62249259Sdim // Takes the value_type of a ConstantUniqueMap's internal map, whose 'second' 63249259Sdim // is a Constant*. 64249259Sdim template<typename PairT> 65249259Sdim void operator()(const PairT &P) { 66249259Sdim P.first->dropAllReferences(); 67249259Sdim } 68249259Sdim}; 69249259Sdim} 70249259Sdim 71249259SdimLLVMContextImpl::~LLVMContextImpl() { 72276479Sdim // NOTE: We need to delete the contents of OwnedModules, but Module's dtor 73276479Sdim // will call LLVMContextImpl::removeModule, thus invalidating iterators into 74276479Sdim // the container. Avoid iterators during this operation: 75276479Sdim while (!OwnedModules.empty()) 76276479Sdim delete *OwnedModules.begin(); 77280031Sdim 78280031Sdim // Drop references for MDNodes. Do this before Values get deleted to avoid 79280031Sdim // unnecessary RAUW when nodes are still unresolved. 80280031Sdim for (auto *I : DistinctMDNodes) 81280031Sdim I->dropAllReferences(); 82296417Sdim#define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS) \ 83288943Sdim for (auto *I : CLASS##s) \ 84280031Sdim I->dropAllReferences(); 85288943Sdim#include "llvm/IR/Metadata.def" 86280031Sdim 87280031Sdim // Also drop references that come from the Value bridges. 88280031Sdim for (auto &Pair : ValuesAsMetadata) 89280031Sdim Pair.second->dropUsers(); 90280031Sdim for (auto &Pair : MetadataAsValues) 91280031Sdim Pair.second->dropUse(); 92280031Sdim 93280031Sdim // Destroy MDNodes. 94288943Sdim for (MDNode *I : DistinctMDNodes) 95280031Sdim I->deleteAsSubclass(); 96296417Sdim#define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS) \ 97296417Sdim for (CLASS * I : CLASS##s) \ 98280031Sdim delete I; 99288943Sdim#include "llvm/IR/Metadata.def" 100280031Sdim 101288943Sdim // Free the constants. 102249259Sdim std::for_each(ExprConstants.map_begin(), ExprConstants.map_end(), 103280031Sdim DropFirst()); 104249259Sdim std::for_each(ArrayConstants.map_begin(), ArrayConstants.map_end(), 105249259Sdim DropFirst()); 106249259Sdim std::for_each(StructConstants.map_begin(), StructConstants.map_end(), 107249259Sdim DropFirst()); 108249259Sdim std::for_each(VectorConstants.map_begin(), VectorConstants.map_end(), 109249259Sdim DropFirst()); 110249259Sdim ExprConstants.freeConstants(); 111249259Sdim ArrayConstants.freeConstants(); 112249259Sdim StructConstants.freeConstants(); 113249259Sdim VectorConstants.freeConstants(); 114249259Sdim DeleteContainerSeconds(CAZConstants); 115249259Sdim DeleteContainerSeconds(CPNConstants); 116249259Sdim DeleteContainerSeconds(UVConstants); 117249259Sdim InlineAsms.freeConstants(); 118249259Sdim DeleteContainerSeconds(IntConstants); 119249259Sdim DeleteContainerSeconds(FPConstants); 120249259Sdim 121249259Sdim for (StringMap<ConstantDataSequential*>::iterator I = CDSConstants.begin(), 122249259Sdim E = CDSConstants.end(); I != E; ++I) 123249259Sdim delete I->second; 124249259Sdim CDSConstants.clear(); 125249259Sdim 126249259Sdim // Destroy attributes. 127249259Sdim for (FoldingSetIterator<AttributeImpl> I = AttrsSet.begin(), 128249259Sdim E = AttrsSet.end(); I != E; ) { 129249259Sdim FoldingSetIterator<AttributeImpl> Elem = I++; 130249259Sdim delete &*Elem; 131249259Sdim } 132249259Sdim 133249259Sdim // Destroy attribute lists. 134249259Sdim for (FoldingSetIterator<AttributeSetImpl> I = AttrsLists.begin(), 135249259Sdim E = AttrsLists.end(); I != E; ) { 136249259Sdim FoldingSetIterator<AttributeSetImpl> Elem = I++; 137249259Sdim delete &*Elem; 138249259Sdim } 139249259Sdim 140249259Sdim // Destroy attribute node lists. 141249259Sdim for (FoldingSetIterator<AttributeSetNode> I = AttrsSetNodes.begin(), 142249259Sdim E = AttrsSetNodes.end(); I != E; ) { 143249259Sdim FoldingSetIterator<AttributeSetNode> Elem = I++; 144249259Sdim delete &*Elem; 145249259Sdim } 146249259Sdim 147280031Sdim // Destroy MetadataAsValues. 148280031Sdim { 149280031Sdim SmallVector<MetadataAsValue *, 8> MDVs; 150280031Sdim MDVs.reserve(MetadataAsValues.size()); 151280031Sdim for (auto &Pair : MetadataAsValues) 152280031Sdim MDVs.push_back(Pair.second); 153280031Sdim MetadataAsValues.clear(); 154280031Sdim for (auto *V : MDVs) 155280031Sdim delete V; 156280031Sdim } 157249259Sdim 158280031Sdim // Destroy ValuesAsMetadata. 159280031Sdim for (auto &Pair : ValuesAsMetadata) 160280031Sdim delete Pair.second; 161280031Sdim 162249259Sdim // Destroy MDStrings. 163280031Sdim MDStringCache.clear(); 164249259Sdim} 165249259Sdim 166288943Sdimvoid LLVMContextImpl::dropTriviallyDeadConstantArrays() { 167288943Sdim bool Changed; 168288943Sdim do { 169288943Sdim Changed = false; 170288943Sdim 171288943Sdim for (auto I = ArrayConstants.map_begin(), E = ArrayConstants.map_end(); 172288943Sdim I != E; ) { 173288943Sdim auto *C = I->first; 174288943Sdim I++; 175288943Sdim if (C->use_empty()) { 176288943Sdim Changed = true; 177288943Sdim C->destroyConstant(); 178288943Sdim } 179288943Sdim } 180288943Sdim 181288943Sdim } while (Changed); 182288943Sdim} 183288943Sdim 184288943Sdimvoid Module::dropTriviallyDeadConstantArrays() { 185288943Sdim Context.pImpl->dropTriviallyDeadConstantArrays(); 186288943Sdim} 187288943Sdim 188288943Sdimnamespace llvm { 189288943Sdim/// \brief Make MDOperand transparent for hashing. 190288943Sdim/// 191288943Sdim/// This overload of an implementation detail of the hashing library makes 192288943Sdim/// MDOperand hash to the same value as a \a Metadata pointer. 193288943Sdim/// 194288943Sdim/// Note that overloading \a hash_value() as follows: 195288943Sdim/// 196288943Sdim/// \code 197288943Sdim/// size_t hash_value(const MDOperand &X) { return hash_value(X.get()); } 198288943Sdim/// \endcode 199288943Sdim/// 200288943Sdim/// does not cause MDOperand to be transparent. In particular, a bare pointer 201288943Sdim/// doesn't get hashed before it's combined, whereas \a MDOperand would. 202288943Sdimstatic const Metadata *get_hashable_data(const MDOperand &X) { return X.get(); } 203288943Sdim} 204288943Sdim 205288943Sdimunsigned MDNodeOpsKey::calculateHash(MDNode *N, unsigned Offset) { 206288943Sdim unsigned Hash = hash_combine_range(N->op_begin() + Offset, N->op_end()); 207288943Sdim#ifndef NDEBUG 208288943Sdim { 209288943Sdim SmallVector<Metadata *, 8> MDs(N->op_begin() + Offset, N->op_end()); 210288943Sdim unsigned RawHash = calculateHash(MDs); 211288943Sdim assert(Hash == RawHash && 212288943Sdim "Expected hash of MDOperand to equal hash of Metadata*"); 213288943Sdim } 214288943Sdim#endif 215288943Sdim return Hash; 216288943Sdim} 217288943Sdim 218288943Sdimunsigned MDNodeOpsKey::calculateHash(ArrayRef<Metadata *> Ops) { 219288943Sdim return hash_combine_range(Ops.begin(), Ops.end()); 220288943Sdim} 221288943Sdim 222296417SdimStringMapEntry<uint32_t> *LLVMContextImpl::getOrInsertBundleTag(StringRef Tag) { 223296417Sdim uint32_t NewIdx = BundleTagCache.size(); 224296417Sdim return &*(BundleTagCache.insert(std::make_pair(Tag, NewIdx)).first); 225296417Sdim} 226296417Sdim 227296417Sdimvoid LLVMContextImpl::getOperandBundleTags(SmallVectorImpl<StringRef> &Tags) const { 228296417Sdim Tags.resize(BundleTagCache.size()); 229296417Sdim for (const auto &T : BundleTagCache) 230296417Sdim Tags[T.second] = T.first(); 231296417Sdim} 232296417Sdim 233296417Sdimuint32_t LLVMContextImpl::getOperandBundleTagID(StringRef Tag) const { 234296417Sdim auto I = BundleTagCache.find(Tag); 235296417Sdim assert(I != BundleTagCache.end() && "Unknown tag!"); 236296417Sdim return I->second; 237296417Sdim} 238296417Sdim 239249259Sdim// ConstantsContext anchors 240249259Sdimvoid UnaryConstantExpr::anchor() { } 241249259Sdim 242249259Sdimvoid BinaryConstantExpr::anchor() { } 243249259Sdim 244249259Sdimvoid SelectConstantExpr::anchor() { } 245249259Sdim 246249259Sdimvoid ExtractElementConstantExpr::anchor() { } 247249259Sdim 248249259Sdimvoid InsertElementConstantExpr::anchor() { } 249249259Sdim 250249259Sdimvoid ShuffleVectorConstantExpr::anchor() { } 251249259Sdim 252249259Sdimvoid ExtractValueConstantExpr::anchor() { } 253249259Sdim 254249259Sdimvoid InsertValueConstantExpr::anchor() { } 255249259Sdim 256249259Sdimvoid GetElementPtrConstantExpr::anchor() { } 257249259Sdim 258249259Sdimvoid CompareConstantExpr::anchor() { } 259288943Sdim 260