Members/tobaru/cbc/CbC_llvm: lib/IR/LLVMContextImpl.cpp comparison

comparison 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

comparison

equal deleted inserted replaced

-:e218c19a8176
+:5e5d649e25d2
 Int64Ty(C, 64) {
 InlineAsmDiagHandler = nullptr;
 InlineAsmDiagContext = nullptr;
 DiagnosticHandler = nullptr;
 DiagnosticContext = nullptr;
+RespectDiagnosticFilters = false;
 YieldCallback = nullptr;
 YieldOpaqueHandle = nullptr;
 NamedStructTypesUniqueID = 0;
 }
 // NOTE: We need to delete the contents of OwnedModules, but Module's dtor
 // will call LLVMContextImpl::removeModule, thus invalidating iterators into
 // the container. Avoid iterators during this operation:
 while (!OwnedModules.empty())
 delete *OwnedModules.begin();
-// Free the constants.  This is important to do here to ensure that they are
+// Drop references for MDNodes.  Do this before Values get deleted to avoid
-// freed before the LeakDetector is torn down.
+// unnecessary RAUW when nodes are still unresolved.
+for (auto *I : DistinctMDNodes)
+I->dropAllReferences();
+#define HANDLE_MDNODE_LEAF(CLASS)                                              \
+for (auto *I : CLASS##s)                                                     \
+I->dropAllReferences();
+#include "llvm/IR/Metadata.def"
+// Also drop references that come from the Value bridges.
+for (auto &Pair : ValuesAsMetadata)
+Pair.second->dropUsers();
+for (auto &Pair : MetadataAsValues)
+Pair.second->dropUse();
+// Destroy MDNodes.
+for (MDNode *I : DistinctMDNodes)
+I->deleteAsSubclass();
+#define HANDLE_MDNODE_LEAF(CLASS)                                              \
+for (CLASS *I : CLASS##s)                                                    \
+delete I;
+#include "llvm/IR/Metadata.def"
+// Free the constants.
 std::for_each(ExprConstants.map_begin(), ExprConstants.map_end(),
 DropFirst());
 std::for_each(ArrayConstants.map_begin(), ArrayConstants.map_end(),
 DropFirst());
 std::for_each(StructConstants.map_begin(), StructConstants.map_end(),
 E = AttrsSetNodes.end(); I != E; ) {
 FoldingSetIterator<AttributeSetNode> Elem = I++;
 delete &*Elem;
 }
-// Destroy MDNodes.  ~MDNode can move and remove nodes between the MDNodeSet
+// Destroy MetadataAsValues.
-// and the NonUniquedMDNodes sets, so copy the values out first.
+{
-SmallVector<MDNode*, 8> MDNodes;
+SmallVector<MetadataAsValue *, 8> MDVs;
-MDNodes.reserve(MDNodeSet.size() + NonUniquedMDNodes.size());
+MDVs.reserve(MetadataAsValues.size());
-for (FoldingSetIterator<MDNode> I = MDNodeSet.begin(), E = MDNodeSet.end();
+for (auto &Pair : MetadataAsValues)
-I != E; ++I)
+MDVs.push_back(Pair.second);
-MDNodes.push_back(&*I);
+MetadataAsValues.clear();
-MDNodes.append(NonUniquedMDNodes.begin(), NonUniquedMDNodes.end());
+for (auto *V : MDVs)
-for (SmallVectorImpl<MDNode *>::iterator I = MDNodes.begin(),
+delete V;
-E = MDNodes.end(); I != E; ++I)
+}
-(*I)->destroy();
-assert(MDNodeSet.empty() && NonUniquedMDNodes.empty() &&
+// Destroy ValuesAsMetadata.
-"Destroying all MDNodes didn't empty the Context's sets.");
+for (auto &Pair : ValuesAsMetadata)
+delete Pair.second;
 // Destroy MDStrings.
-DeleteContainerSeconds(MDStringCache);
+MDStringCache.clear();
+}
+void LLVMContextImpl::dropTriviallyDeadConstantArrays() {
+bool Changed;
+do {
+Changed = false;
+for (auto I = ArrayConstants.map_begin(), E = ArrayConstants.map_end();
+I != E; ) {
+auto *C = I->first;
+I++;
+if (C->use_empty()) {
+Changed = true;
+C->destroyConstant();
+}
+}
+} while (Changed);
+}
+void Module::dropTriviallyDeadConstantArrays() {
+Context.pImpl->dropTriviallyDeadConstantArrays();
+}
+namespace llvm {
+/// \brief Make MDOperand transparent for hashing.
+///
+/// This overload of an implementation detail of the hashing library makes
+/// MDOperand hash to the same value as a \a Metadata pointer.
+///
+/// Note that overloading \a hash_value() as follows:
+///
+/// \code
+///     size_t hash_value(const MDOperand &X) { return hash_value(X.get()); }
+/// \endcode
+///
+/// does not cause MDOperand to be transparent.  In particular, a bare pointer
+/// doesn't get hashed before it's combined, whereas \a MDOperand would.
+static const Metadata *get_hashable_data(const MDOperand &X) { return X.get(); }
+}
+unsigned MDNodeOpsKey::calculateHash(MDNode *N, unsigned Offset) {
+unsigned Hash = hash_combine_range(N->op_begin() + Offset, N->op_end());
+#ifndef NDEBUG
+{
+SmallVector<Metadata *, 8> MDs(N->op_begin() + Offset, N->op_end());
+unsigned RawHash = calculateHash(MDs);
+assert(Hash == RawHash &&
+"Expected hash of MDOperand to equal hash of Metadata*");
+}
+#endif
+return Hash;
+}
+unsigned MDNodeOpsKey::calculateHash(ArrayRef<Metadata *> Ops) {
+return hash_combine_range(Ops.begin(), Ops.end());
 }
 // ConstantsContext anchors
 void UnaryConstantExpr::anchor() { }
 void InsertValueConstantExpr::anchor() { }
 void GetElementPtrConstantExpr::anchor() { }
 void CompareConstantExpr::anchor() { }

Mercurial > hg > Members > tobaru > cbc > CbC_llvm

comparison lib/IR/LLVMContextImpl.cpp @ 85:5e5d649e25d2