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