lib/IR/LLVMContextImpl.cpp

   1 //===-- LLVMContextImpl.cpp - Implement LLVMContextImpl -------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 //  This file implements the opaque LLVMContextImpl.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "LLVMContextImpl.h"
  15 #include "llvm/ADT/STLExtras.h"
  16 #include "llvm/IR/Attributes.h"
  17 #include "llvm/IR/DiagnosticInfo.h"
  18 #include "llvm/IR/Module.h"
  19 #include <algorithm>
  20 using namespace llvm;
  21
  22 LLVMContextImpl::LLVMContextImpl(LLVMContext &C)
  23   : TheTrueVal(nullptr), TheFalseVal(nullptr),
  24     VoidTy(C, Type::VoidTyID),
  25     LabelTy(C, Type::LabelTyID),
  26     HalfTy(C, Type::HalfTyID),
  27     FloatTy(C, Type::FloatTyID),
  28     DoubleTy(C, Type::DoubleTyID),
  29     MetadataTy(C, Type::MetadataTyID),
  30     X86_FP80Ty(C, Type::X86_FP80TyID),
  31     FP128Ty(C, Type::FP128TyID),
  32     PPC_FP128Ty(C, Type::PPC_FP128TyID),
  33     X86_MMXTy(C, Type::X86_MMXTyID),
  34     Int1Ty(C, 1),
  35     Int8Ty(C, 8),
  36     Int16Ty(C, 16),
  37     Int32Ty(C, 32),
  38     Int64Ty(C, 64),
  39     Int128Ty(C, 128) {
  40   InlineAsmDiagHandler = nullptr;
  41   InlineAsmDiagContext = nullptr;
  42   DiagnosticHandler = nullptr;
  43   DiagnosticContext = nullptr;
  44   RespectDiagnosticFilters = false;
  45   YieldCallback = nullptr;
  46   YieldOpaqueHandle = nullptr;
  47   NamedStructTypesUniqueID = 0;
  48 }
  49
  50 namespace {
  51 struct DropReferences {
  52   // Takes the value_type of a ConstantUniqueMap's internal map, whose 'second'
  53   // is a Constant*.
  54   template <typename PairT> void operator()(const PairT &P) {
  55     P.second->dropAllReferences();
  56   }
  57 };
  58
  59 // Temporary - drops pair.first instead of second.
  60 struct DropFirst {
  61   // Takes the value_type of a ConstantUniqueMap's internal map, whose 'second'
  62   // is a Constant*.
  63   template<typename PairT>
  64   void operator()(const PairT &P) {
  65     P.first->dropAllReferences();
  66   }
  67 };
  68 }
  69
  70 LLVMContextImpl::~LLVMContextImpl() {
  71   // NOTE: We need to delete the contents of OwnedModules, but Module's dtor
  72   // will call LLVMContextImpl::removeModule, thus invalidating iterators into
  73   // the container. Avoid iterators during this operation:
  74   while (!OwnedModules.empty())
  75     delete *OwnedModules.begin();
  76
  77   // Drop references for MDNodes.  Do this before Values get deleted to avoid
  78   // unnecessary RAUW when nodes are still unresolved.
  79   for (auto *I : DistinctMDNodes)
  80     I->dropAllReferences();
  81 #define HANDLE_MDNODE_LEAF(CLASS)                                              \
  82   for (auto *I : CLASS##s)                                                     \
  83     I->dropAllReferences();
  84 #include "llvm/IR/Metadata.def"
  85
  86   // Also drop references that come from the Value bridges.
  87   for (auto &Pair : ValuesAsMetadata)
  88     Pair.second->dropUsers();
  89   for (auto &Pair : MetadataAsValues)
  90     Pair.second->dropUse();
  91
  92   // Destroy MDNodes.
  93   for (MDNode *I : DistinctMDNodes)
  94     I->deleteAsSubclass();
  95 #define HANDLE_MDNODE_LEAF(CLASS)                                              \
  96   for (CLASS *I : CLASS##s)                                                    \
  97     delete I;
  98 #include "llvm/IR/Metadata.def"
  99
 100   // Free the constants.
 101   std::for_each(ExprConstants.map_begin(), ExprConstants.map_end(),
 102                 DropFirst());
 103   std::for_each(ArrayConstants.map_begin(), ArrayConstants.map_end(),
 104                 DropFirst());
 105   std::for_each(StructConstants.map_begin(), StructConstants.map_end(),
 106                 DropFirst());
 107   std::for_each(VectorConstants.map_begin(), VectorConstants.map_end(),
 108                 DropFirst());
 109   ExprConstants.freeConstants();
 110   ArrayConstants.freeConstants();
 111   StructConstants.freeConstants();
 112   VectorConstants.freeConstants();
 113   DeleteContainerSeconds(CAZConstants);
 114   DeleteContainerSeconds(CPNConstants);
 115   DeleteContainerSeconds(UVConstants);
 116   InlineAsms.freeConstants();
 117   DeleteContainerSeconds(IntConstants);
 118   DeleteContainerSeconds(FPConstants);
 119
 120   for (StringMap<ConstantDataSequential*>::iterator I = CDSConstants.begin(),
 121        E = CDSConstants.end(); I != E; ++I)
 122     delete I->second;
 123   CDSConstants.clear();
 124
 125   // Destroy attributes.
 126   for (FoldingSetIterator<AttributeImpl> I = AttrsSet.begin(),
 127          E = AttrsSet.end(); I != E; ) {
 128     FoldingSetIterator<AttributeImpl> Elem = I++;
 129     delete &*Elem;
 130   }
 131
 132   // Destroy attribute lists.
 133   for (FoldingSetIterator<AttributeSetImpl> I = AttrsLists.begin(),
 134          E = AttrsLists.end(); I != E; ) {
 135     FoldingSetIterator<AttributeSetImpl> Elem = I++;
 136     delete &*Elem;
 137   }
 138
 139   // Destroy attribute node lists.
 140   for (FoldingSetIterator<AttributeSetNode> I = AttrsSetNodes.begin(),
 141          E = AttrsSetNodes.end(); I != E; ) {
 142     FoldingSetIterator<AttributeSetNode> Elem = I++;
 143     delete &*Elem;
 144   }
 145
 146   // Destroy MetadataAsValues.
 147   {
 148     SmallVector<MetadataAsValue *, 8> MDVs;
 149     MDVs.reserve(MetadataAsValues.size());
 150     for (auto &Pair : MetadataAsValues)
 151       MDVs.push_back(Pair.second);
 152     MetadataAsValues.clear();
 153     for (auto *V : MDVs)
 154       delete V;
 155   }
 156
 157   // Destroy ValuesAsMetadata.
 158   for (auto &Pair : ValuesAsMetadata)
 159     delete Pair.second;
 160
 161   // Destroy MDStrings.
 162   MDStringCache.clear();
 163 }
 164
 165 void LLVMContextImpl::dropTriviallyDeadConstantArrays() {
 166   bool Changed;
 167   do {
 168     Changed = false;
 169
 170     for (auto I = ArrayConstants.map_begin(), E = ArrayConstants.map_end();
 171          I != E; ) {
 172       auto *C = I->first;
 173       I++;
 174       if (C->use_empty()) {
 175         Changed = true;
 176         C->destroyConstant();
 177       }
 178     }
 179
 180   } while (Changed);
 181 }
 182
 183 void Module::dropTriviallyDeadConstantArrays() {
 184   Context.pImpl->dropTriviallyDeadConstantArrays();
 185 }
 186
 187 namespace llvm {
 188 /// \brief Make MDOperand transparent for hashing.
 189 ///
 190 /// This overload of an implementation detail of the hashing library makes
 191 /// MDOperand hash to the same value as a \a Metadata pointer.
 192 ///
 193 /// Note that overloading \a hash_value() as follows:
 194 ///
 195 /// \code
 196 ///     size_t hash_value(const MDOperand &X) { return hash_value(X.get()); }
 197 /// \endcode
 198 ///
 199 /// does not cause MDOperand to be transparent.  In particular, a bare pointer
 200 /// doesn't get hashed before it's combined, whereas \a MDOperand would.
 201 static const Metadata *get_hashable_data(const MDOperand &X) { return X.get(); }
 202 }
 203
 204 unsigned MDNodeOpsKey::calculateHash(MDNode *N, unsigned Offset) {
 205   unsigned Hash = hash_combine_range(N->op_begin() + Offset, N->op_end());
 206 #ifndef NDEBUG
 207   {
 208     SmallVector<Metadata *, 8> MDs(N->op_begin() + Offset, N->op_end());
 209     unsigned RawHash = calculateHash(MDs);
 210     assert(Hash == RawHash &&
 211            "Expected hash of MDOperand to equal hash of Metadata*");
 212   }
 213 #endif
 214   return Hash;
 215 }
 216
 217 unsigned MDNodeOpsKey::calculateHash(ArrayRef<Metadata *> Ops) {
 218   return hash_combine_range(Ops.begin(), Ops.end());
 219 }
 220
 221 // ConstantsContext anchors
 222 void UnaryConstantExpr::anchor() { }
 223
 224 void BinaryConstantExpr::anchor() { }
 225
 226 void SelectConstantExpr::anchor() { }
 227
 228 void ExtractElementConstantExpr::anchor() { }
 229
 230 void InsertElementConstantExpr::anchor() { }
 231
 232 void ShuffleVectorConstantExpr::anchor() { }
 233
 234 void ExtractValueConstantExpr::anchor() { }
 235
 236 void InsertValueConstantExpr::anchor() { }
 237
 238 void GetElementPtrConstantExpr::anchor() { }
 239
 240 void CompareConstantExpr::anchor() { }
 241