CbC/CbC_llvm: lib/Bitcode/Writer/ValueEnumerator.cpp comparison

comparison lib/Bitcode/Writer/ValueEnumerator.cpp @ 121:803732b1fca8

LLVM 5.0

author	kono
date	Fri, 27 Oct 2017 17:07:41 +0900
parents	1172e4bd9c6f
children	c2174574ed3a

comparison

equal deleted inserted replaced

-:1172e4bd9c6f
+:803732b1fca8
-//===-- ValueEnumerator.cpp - Number values and types for bitcode writer --===//
+//===- ValueEnumerator.cpp - Number values and types for bitcode writer ---===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 // This file implements the ValueEnumerator class.
 //
 //===----------------------------------------------------------------------===//
 #include "ValueEnumerator.h"
-#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/SmallPtrSet.h"
+#include "llvm/ADT/SmallVector.h"
-#include "llvm/IR/Constants.h"
+#include "llvm/IR/Argument.h"
+#include "llvm/IR/Attributes.h"
+#include "llvm/IR/BasicBlock.h"
+#include "llvm/IR/Constant.h"
 #include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/DerivedTypes.h"
+#include "llvm/IR/Function.h"
+#include "llvm/IR/GlobalAlias.h"
+#include "llvm/IR/GlobalIFunc.h"
+#include "llvm/IR/GlobalObject.h"
+#include "llvm/IR/GlobalValue.h"
+#include "llvm/IR/GlobalVariable.h"
+#include "llvm/IR/Instruction.h"
 #include "llvm/IR/Instructions.h"
+#include "llvm/IR/Metadata.h"
 #include "llvm/IR/Module.h"
+#include "llvm/IR/Type.h"
+#include "llvm/IR/Use.h"
 #include "llvm/IR/UseListOrder.h"
+#include "llvm/IR/User.h"
+#include "llvm/IR/Value.h"
 #include "llvm/IR/ValueSymbolTable.h"
+#include "llvm/Support/Casting.h"
+#include "llvm/Support/Compiler.h"
 #include "llvm/Support/Debug.h"
+#include "llvm/Support/MathExtras.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <iterator>
+#include <tuple>
+#include <utility>
+#include <vector>
 using namespace llvm;
 namespace {
 struct OrderMap {
 DenseMap<const Value *, std::pair<unsigned, bool>> IDs;
-unsigned LastGlobalConstantID;
+unsigned LastGlobalConstantID = 0;
-unsigned LastGlobalValueID;
+unsigned LastGlobalValueID = 0;
-OrderMap() : LastGlobalConstantID(0), LastGlobalValueID(0) {}
+OrderMap() = default;
 bool isGlobalConstant(unsigned ID) const {
 return ID <= LastGlobalConstantID;
 }
 bool isGlobalValue(unsigned ID) const {
 return ID <= LastGlobalValueID && !isGlobalConstant(ID);
 }
 unsigned size() const { return IDs.size(); }
 std::pair<unsigned, bool> &operator[](const Value *V) { return IDs[V]; }
 std::pair<unsigned, bool> lookup(const Value *V) const {
 return IDs.lookup(V);
 }
 void index(const Value *V) {
 // Explicitly sequence get-size and insert-value operations to avoid UB.
 unsigned ID = IDs.size() + 1;
 IDs[V].first = ID;
 }
 };
-}
+} // end anonymous namespace
 static void orderValue(const Value *V, OrderMap &OM) {
 if (OM.lookup(V).first)
 return;
 static void predictValueUseListOrderImpl(const Value *V, const Function *F,
 unsigned ID, const OrderMap &OM,
 UseListOrderStack &Stack) {
 // Predict use-list order for this one.
-typedef std::pair<const Use *, unsigned> Entry;
+using Entry = std::pair<const Use *, unsigned>;
 SmallVector<Entry, 64> List;
 for (const Use &U : V->uses())
 // Check if this user will be serialized.
 if (OM.lookup(U.getUser()).first)
 List.push_back(std::make_pair(&U, List.size()));
 EnumerateValue(&GIF);
 // Remember what is the cutoff between globalvalue's and other constants.
 unsigned FirstConstant = Values.size();
-// Enumerate the global variable initializers.
+// Enumerate the global variable initializers and attributes.
-for (const GlobalVariable &GV : M.globals())
+for (const GlobalVariable &GV : M.globals()) {
 if (GV.hasInitializer())
 EnumerateValue(GV.getInitializer());
+if (GV.hasAttributes())
+EnumerateAttributes(GV.getAttributesAsList(AttributeList::FunctionIndex));
+}
 // Enumerate the aliasees.
 for (const GlobalAlias &GA : M.aliases())
 EnumerateValue(GA.getAliasee());
 ValueMapType::const_iterator I = ValueMap.find(V);
 assert(I != ValueMap.end() && "Value not in slotcalculator!");
 return I->second-1;
 }
+#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 LLVM_DUMP_METHOD void ValueEnumerator::dump() const {
 print(dbgs(), ValueMap, "Default");
 dbgs() << '\n';
 print(dbgs(), MetadataMap, "MetaData");
 dbgs() << '\n';
 }
+#endif
 void ValueEnumerator::print(raw_ostream &OS, const ValueMapType &Map,
 const char *Name) const {
 OS << "Map Name: " << Name << "\n";
 OS << "Size: " << Map.size() << "\n";
 for (ValueMapType::const_iterator I = Map.begin(),
 E = Map.end(); I != E; ++I) {
 const Value *V = I->first;
 if (V->hasName())
 OS << "Value: " << V->getName();
 else
 OS << "Value: [null]\n";
-V->dump();
+V->print(errs());
+errs() << '\n';
 OS << " Uses(" << std::distance(V->use_begin(),V->use_end()) << "):";
 for (const Use &U : V->uses()) {
 if (&U != &*V->use_begin())
 OS << ",";
 }
 }
 void ValueEnumerator::print(raw_ostream &OS, const MetadataMapType &Map,
 const char *Name) const {
 OS << "Map Name: " << Name << "\n";
 OS << "Size: " << Map.size() << "\n";
 for (auto I = Map.begin(), E = Map.end(); I != E; ++I) {
 const Metadata *MD = I->first;
 OS << "Metadata: slot = " << I->second.ID << "\n";
 // Rebuild the modified portion of ValueMap.
 for (; CstStart != CstEnd; ++CstStart)
 ValueMap[Values[CstStart].first] = CstStart+1;
 }
 /// EnumerateValueSymbolTable - Insert all of the values in the specified symbol
 /// table into the values table.
 void ValueEnumerator::EnumerateValueSymbolTable(const ValueSymbolTable &VST) {
 for (ValueSymbolTable::const_iterator VI = VST.begin(), VE = VST.end();
 VI != VE; ++VI)
 }
 void ValueEnumerator::dropFunctionFromMetadata(
 MetadataMapType::value_type &FirstMD) {
 SmallVector<const MDNode *, 64> Worklist;
-auto push = [this, &Worklist](MetadataMapType::value_type &MD) {
+auto push = [&Worklist](MetadataMapType::value_type &MD) {
 auto &Entry = MD.second;
 // Nothing to do if this metadata isn't tagged.
 if (!Entry.F)
 return;
 EnumerateOperandType(Op);
 }
 }
-void ValueEnumerator::EnumerateAttributes(AttributeSet PAL) {
+void ValueEnumerator::EnumerateAttributes(AttributeList PAL) {
 if (PAL.isEmpty()) return;  // null is always 0.
 // Do a lookup.
-unsigned &Entry = AttributeMap[PAL];
+unsigned &Entry = AttributeListMap[PAL];
 if (Entry == 0) {
 // Never saw this before, add it.
-Attribute.push_back(PAL);
+AttributeLists.push_back(PAL);
-Entry = Attribute.size();
+Entry = AttributeLists.size();
 }
 // Do lookups for all attribute groups.
-for (unsigned i = 0, e = PAL.getNumSlots(); i != e; ++i) {
+for (unsigned i = PAL.index_begin(), e = PAL.index_end(); i != e; ++i) {
-AttributeSet AS = PAL.getSlotAttributes(i);
+AttributeSet AS = PAL.getAttributes(i);
-unsigned &Entry = AttributeGroupMap[AS];
+if (!AS.hasAttributes())
+continue;
+IndexAndAttrSet Pair = {i, AS};
+unsigned &Entry = AttributeGroupMap[Pair];
 if (Entry == 0) {
-AttributeGroups.push_back(AS);
+AttributeGroups.push_back(Pair);
 Entry = AttributeGroups.size();
 }
 }
 }

Mercurial > hg > CbC > CbC_llvm

comparison lib/Bitcode/Writer/ValueEnumerator.cpp @ 121:803732b1fca8