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 "llvm/Support/CommandLine.h"
  20 #include "llvm/Support/Regex.h"
  21 #include <algorithm>
  22 using namespace llvm;
  23
  24 LLVMContextImpl::LLVMContextImpl(LLVMContext &C)
  25   : TheTrueVal(nullptr), TheFalseVal(nullptr),
  26     VoidTy(C, Type::VoidTyID),
  27     LabelTy(C, Type::LabelTyID),
  28     HalfTy(C, Type::HalfTyID),
  29     FloatTy(C, Type::FloatTyID),
  30     DoubleTy(C, Type::DoubleTyID),
  31     MetadataTy(C, Type::MetadataTyID),
  32     X86_FP80Ty(C, Type::X86_FP80TyID),
  33     FP128Ty(C, Type::FP128TyID),
  34     PPC_FP128Ty(C, Type::PPC_FP128TyID),
  35     X86_MMXTy(C, Type::X86_MMXTyID),
  36     Int1Ty(C, 1),
  37     Int8Ty(C, 8),
  38     Int16Ty(C, 16),
  39     Int32Ty(C, 32),
  40     Int64Ty(C, 64) {
  41   InlineAsmDiagHandler = nullptr;
  42   InlineAsmDiagContext = nullptr;
  43   DiagnosticHandler = nullptr;
  44   DiagnosticContext = nullptr;
  45   YieldCallback = nullptr;
  46   YieldOpaqueHandle = nullptr;
  47   NamedStructTypesUniqueID = 0;
  48 }
  49
  50 namespace {
  51
  52 /// \brief Regular expression corresponding to the value given in one of the
  53 /// -pass-remarks* command line flags. Passes whose name matches this regexp
  54 /// will emit a diagnostic when calling the associated diagnostic function
  55 /// (emitOptimizationRemark, emitOptimizationRemarkMissed or
  56 /// emitOptimizationRemarkAnalysis).
  57 struct PassRemarksOpt {
  58   std::shared_ptr<Regex> Pattern;
  59
  60   void operator=(const std::string &Val) {
  61     // Create a regexp object to match pass names for emitOptimizationRemark.
  62     if (!Val.empty()) {
  63       Pattern = std::make_shared<Regex>(Val);
  64       std::string RegexError;
  65       if (!Pattern->isValid(RegexError))
  66         report_fatal_error("Invalid regular expression '" + Val +
  67                                "' in -pass-remarks: " + RegexError,
  68                            false);
  69     }
  70   };
  71 };
  72
  73 static PassRemarksOpt PassRemarksOptLoc;
  74 static PassRemarksOpt PassRemarksMissedOptLoc;
  75 static PassRemarksOpt PassRemarksAnalysisOptLoc;
  76
  77 // -pass-remarks
  78 //    Command line flag to enable emitOptimizationRemark()
  79 static cl::opt<PassRemarksOpt, true, cl::parser<std::string>>
  80 PassRemarks("pass-remarks", cl::value_desc("pattern"),
  81             cl::desc("Enable optimization remarks from passes whose name match "
  82                      "the given regular expression"),
  83             cl::Hidden, cl::location(PassRemarksOptLoc), cl::ValueRequired,
  84             cl::ZeroOrMore);
  85
  86 // -pass-remarks-missed
  87 //    Command line flag to enable emitOptimizationRemarkMissed()
  88 static cl::opt<PassRemarksOpt, true, cl::parser<std::string>> PassRemarksMissed(
  89     "pass-remarks-missed", cl::value_desc("pattern"),
  90     cl::desc("Enable missed optimization remarks from passes whose name match "
  91              "the given regular expression"),
  92     cl::Hidden, cl::location(PassRemarksMissedOptLoc), cl::ValueRequired,
  93     cl::ZeroOrMore);
  94
  95 // -pass-remarks-analysis
  96 //    Command line flag to enable emitOptimizationRemarkAnalysis()
  97 static cl::opt<PassRemarksOpt, true, cl::parser<std::string>>
  98 PassRemarksAnalysis(
  99     "pass-remarks-analysis", cl::value_desc("pattern"),
 100     cl::desc(
 101         "Enable optimization analysis remarks from passes whose name match "
 102         "the given regular expression"),
 103     cl::Hidden, cl::location(PassRemarksAnalysisOptLoc), cl::ValueRequired,
 104     cl::ZeroOrMore);
 105 }
 106
 107 bool LLVMContextImpl::optimizationRemarkEnabledFor(
 108     const DiagnosticInfoOptimizationRemark *DI) const {
 109   return PassRemarksOptLoc.Pattern &&
 110          PassRemarksOptLoc.Pattern->match(DI->getPassName());
 111 }
 112
 113 bool LLVMContextImpl::optimizationRemarkEnabledFor(
 114     const DiagnosticInfoOptimizationRemarkMissed *DI) const {
 115   return PassRemarksMissedOptLoc.Pattern &&
 116          PassRemarksMissedOptLoc.Pattern->match(DI->getPassName());
 117 }
 118
 119 bool LLVMContextImpl::optimizationRemarkEnabledFor(
 120     const DiagnosticInfoOptimizationRemarkAnalysis *DI) const {
 121   return PassRemarksAnalysisOptLoc.Pattern &&
 122          PassRemarksAnalysisOptLoc.Pattern->match(DI->getPassName());
 123 }
 124
 125 namespace {
 126 struct DropReferences {
 127   // Takes the value_type of a ConstantUniqueMap's internal map, whose 'second'
 128   // is a Constant*.
 129   template <typename PairT> void operator()(const PairT &P) {
 130     P.second->dropAllReferences();
 131   }
 132 };
 133
 134 // Temporary - drops pair.first instead of second.
 135 struct DropFirst {
 136   // Takes the value_type of a ConstantUniqueMap's internal map, whose 'second'
 137   // is a Constant*.
 138   template<typename PairT>
 139   void operator()(const PairT &P) {
 140     P.first->dropAllReferences();
 141   }
 142 };
 143 }
 144
 145 LLVMContextImpl::~LLVMContextImpl() {
 146   // NOTE: We need to delete the contents of OwnedModules, but Module's dtor
 147   // will call LLVMContextImpl::removeModule, thus invalidating iterators into
 148   // the container. Avoid iterators during this operation:
 149   while (!OwnedModules.empty())
 150     delete *OwnedModules.begin();
 151
 152   // Free the constants.  This is important to do here to ensure that they are
 153   // freed before the LeakDetector is torn down.
 154   std::for_each(ExprConstants.map_begin(), ExprConstants.map_end(),
 155                 DropReferences());
 156   std::for_each(ArrayConstants.map_begin(), ArrayConstants.map_end(),
 157                 DropFirst());
 158   std::for_each(StructConstants.map_begin(), StructConstants.map_end(),
 159                 DropFirst());
 160   std::for_each(VectorConstants.map_begin(), VectorConstants.map_end(),
 161                 DropFirst());
 162   ExprConstants.freeConstants();
 163   ArrayConstants.freeConstants();
 164   StructConstants.freeConstants();
 165   VectorConstants.freeConstants();
 166   DeleteContainerSeconds(CAZConstants);
 167   DeleteContainerSeconds(CPNConstants);
 168   DeleteContainerSeconds(UVConstants);
 169   InlineAsms.freeConstants();
 170   DeleteContainerSeconds(IntConstants);
 171   DeleteContainerSeconds(FPConstants);
 172
 173   for (StringMap<ConstantDataSequential*>::iterator I = CDSConstants.begin(),
 174        E = CDSConstants.end(); I != E; ++I)
 175     delete I->second;
 176   CDSConstants.clear();
 177
 178   // Destroy attributes.
 179   for (FoldingSetIterator<AttributeImpl> I = AttrsSet.begin(),
 180          E = AttrsSet.end(); I != E; ) {
 181     FoldingSetIterator<AttributeImpl> Elem = I++;
 182     delete &*Elem;
 183   }
 184
 185   // Destroy attribute lists.
 186   for (FoldingSetIterator<AttributeSetImpl> I = AttrsLists.begin(),
 187          E = AttrsLists.end(); I != E; ) {
 188     FoldingSetIterator<AttributeSetImpl> Elem = I++;
 189     delete &*Elem;
 190   }
 191
 192   // Destroy attribute node lists.
 193   for (FoldingSetIterator<AttributeSetNode> I = AttrsSetNodes.begin(),
 194          E = AttrsSetNodes.end(); I != E; ) {
 195     FoldingSetIterator<AttributeSetNode> Elem = I++;
 196     delete &*Elem;
 197   }
 198
 199   // Destroy MDNodes.  ~MDNode can move and remove nodes between the MDNodeSet
 200   // and the NonUniquedMDNodes sets, so copy the values out first.
 201   SmallVector<MDNode*, 8> MDNodes;
 202   MDNodes.reserve(MDNodeSet.size() + NonUniquedMDNodes.size());
 203   for (FoldingSetIterator<MDNode> I = MDNodeSet.begin(), E = MDNodeSet.end();
 204        I != E; ++I)
 205     MDNodes.push_back(&*I);
 206   MDNodes.append(NonUniquedMDNodes.begin(), NonUniquedMDNodes.end());
 207   for (SmallVectorImpl<MDNode *>::iterator I = MDNodes.begin(),
 208          E = MDNodes.end(); I != E; ++I)
 209     (*I)->destroy();
 210   assert(MDNodeSet.empty() && NonUniquedMDNodes.empty() &&
 211          "Destroying all MDNodes didn't empty the Context's sets.");
 212
 213   // Destroy MDStrings.
 214   DeleteContainerSeconds(MDStringCache);
 215 }
 216
 217 // ConstantsContext anchors
 218 void UnaryConstantExpr::anchor() { }
 219
 220 void BinaryConstantExpr::anchor() { }
 221
 222 void SelectConstantExpr::anchor() { }
 223
 224 void ExtractElementConstantExpr::anchor() { }
 225
 226 void InsertElementConstantExpr::anchor() { }
 227
 228 void ShuffleVectorConstantExpr::anchor() { }
 229
 230 void ExtractValueConstantExpr::anchor() { }
 231
 232 void InsertValueConstantExpr::anchor() { }
 233
 234 void GetElementPtrConstantExpr::anchor() { }
 235
 236 void CompareConstantExpr::anchor() { }