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/Module.h"
18#include <algorithm>
19using namespace llvm;
20
21LLVMContextImpl::LLVMContextImpl(LLVMContext &C)
22  : TheTrueVal(0), TheFalseVal(0),
23    VoidTy(C, Type::VoidTyID),
24    LabelTy(C, Type::LabelTyID),
25    HalfTy(C, Type::HalfTyID),
26    FloatTy(C, Type::FloatTyID),
27    DoubleTy(C, Type::DoubleTyID),
28    MetadataTy(C, Type::MetadataTyID),
29    X86_FP80Ty(C, Type::X86_FP80TyID),
30    FP128Ty(C, Type::FP128TyID),
31    PPC_FP128Ty(C, Type::PPC_FP128TyID),
32    X86_MMXTy(C, Type::X86_MMXTyID),
33    Int1Ty(C, 1),
34    Int8Ty(C, 8),
35    Int16Ty(C, 16),
36    Int32Ty(C, 32),
37    Int64Ty(C, 64) {
38  InlineAsmDiagHandler = 0;
39  InlineAsmDiagContext = 0;
40  NamedStructTypesUniqueID = 0;
41}
42
43namespace {
44struct DropReferences {
45  // Takes the value_type of a ConstantUniqueMap's internal map, whose 'second'
46  // is a Constant*.
47  template<typename PairT>
48  void operator()(const PairT &P) {
49    P.second->dropAllReferences();
50  }
51};
52
53// Temporary - drops pair.first instead of second.
54struct DropFirst {
55  // Takes the value_type of a ConstantUniqueMap's internal map, whose 'second'
56  // is a Constant*.
57  template<typename PairT>
58  void operator()(const PairT &P) {
59    P.first->dropAllReferences();
60  }
61};
62}
63
64LLVMContextImpl::~LLVMContextImpl() {
65  // NOTE: We need to delete the contents of OwnedModules, but we have to
66  // duplicate it into a temporary vector, because the destructor of Module
67  // will try to remove itself from OwnedModules set.  This would cause
68  // iterator invalidation if we iterated on the set directly.
69  std::vector<Module*> Modules(OwnedModules.begin(), OwnedModules.end());
70  DeleteContainerPointers(Modules);
71
72  // Free the constants.  This is important to do here to ensure that they are
73  // freed before the LeakDetector is torn down.
74  std::for_each(ExprConstants.map_begin(), ExprConstants.map_end(),
75                DropReferences());
76  std::for_each(ArrayConstants.map_begin(), ArrayConstants.map_end(),
77                DropFirst());
78  std::for_each(StructConstants.map_begin(), StructConstants.map_end(),
79                DropFirst());
80  std::for_each(VectorConstants.map_begin(), VectorConstants.map_end(),
81                DropFirst());
82  ExprConstants.freeConstants();
83  ArrayConstants.freeConstants();
84  StructConstants.freeConstants();
85  VectorConstants.freeConstants();
86  DeleteContainerSeconds(CAZConstants);
87  DeleteContainerSeconds(CPNConstants);
88  DeleteContainerSeconds(UVConstants);
89  InlineAsms.freeConstants();
90  DeleteContainerSeconds(IntConstants);
91  DeleteContainerSeconds(FPConstants);
92
93  for (StringMap<ConstantDataSequential*>::iterator I = CDSConstants.begin(),
94       E = CDSConstants.end(); I != E; ++I)
95    delete I->second;
96  CDSConstants.clear();
97
98  // Destroy attributes.
99  for (FoldingSetIterator<AttributeImpl> I = AttrsSet.begin(),
100         E = AttrsSet.end(); I != E; ) {
101    FoldingSetIterator<AttributeImpl> Elem = I++;
102    delete &*Elem;
103  }
104
105  // Destroy attribute lists.
106  for (FoldingSetIterator<AttributeSetImpl> I = AttrsLists.begin(),
107         E = AttrsLists.end(); I != E; ) {
108    FoldingSetIterator<AttributeSetImpl> Elem = I++;
109    delete &*Elem;
110  }
111
112  // Destroy attribute node lists.
113  for (FoldingSetIterator<AttributeSetNode> I = AttrsSetNodes.begin(),
114         E = AttrsSetNodes.end(); I != E; ) {
115    FoldingSetIterator<AttributeSetNode> Elem = I++;
116    delete &*Elem;
117  }
118
119  // Destroy MDNodes.  ~MDNode can move and remove nodes between the MDNodeSet
120  // and the NonUniquedMDNodes sets, so copy the values out first.
121  SmallVector<MDNode*, 8> MDNodes;
122  MDNodes.reserve(MDNodeSet.size() + NonUniquedMDNodes.size());
123  for (FoldingSetIterator<MDNode> I = MDNodeSet.begin(), E = MDNodeSet.end();
124       I != E; ++I)
125    MDNodes.push_back(&*I);
126  MDNodes.append(NonUniquedMDNodes.begin(), NonUniquedMDNodes.end());
127  for (SmallVectorImpl<MDNode *>::iterator I = MDNodes.begin(),
128         E = MDNodes.end(); I != E; ++I)
129    (*I)->destroy();
130  assert(MDNodeSet.empty() && NonUniquedMDNodes.empty() &&
131         "Destroying all MDNodes didn't empty the Context's sets.");
132
133  // Destroy MDStrings.
134  DeleteContainerSeconds(MDStringCache);
135}
136
137// ConstantsContext anchors
138void UnaryConstantExpr::anchor() { }
139
140void BinaryConstantExpr::anchor() { }
141
142void SelectConstantExpr::anchor() { }
143
144void ExtractElementConstantExpr::anchor() { }
145
146void InsertElementConstantExpr::anchor() { }
147
148void ShuffleVectorConstantExpr::anchor() { }
149
150void ExtractValueConstantExpr::anchor() { }
151
152void InsertValueConstantExpr::anchor() { }
153
154void GetElementPtrConstantExpr::anchor() { }
155
156void CompareConstantExpr::anchor() { }
157