Create a typedef GlobalValue::GUID for uint64_t and RAUW (NFC)

[mehdi_amini]

Summary

This should make the code more readable, especially all the map declarations.

[mehdi_amini]

Add missing include

[tejohnson]

Nice cleanup!

include/llvm/IR/GlobalValue.h

334

Make this a const method?

[mehdi_amini]

r265215

include/llvm/IR/GlobalValue.h

334

r265217

include/llvm/IR/GlobalValue.h

public:
   static std::string getGlobalIdentifier(StringRef Name,
                                          GlobalValue::LinkageTypes Linkage,
                                          StringRef FileName);
 
   /// Return the modified name for this global value suitable to be
   /// used as the key for a global lookup (e.g. profile or ThinLTO).
   std::string getGlobalIdentifier();
 
+  /// Declare a type to represent a global unique identifier for a global value.
+  /// This is a 64 bits hash that is used by PGO and ThinLTO to have a compact
+  /// unique way to identify a symbol.
+  using GUID = uint64_t;
+
   /// Return a 64-bit global unique ID constructed from global value name
   /// (i.e. returned by getGlobalIdentifier()).
-  static uint64_t getGUID(StringRef GlobalName) { return MD5Hash(GlobalName); }
+  static GUID getGUID(StringRef GlobalName) { return MD5Hash(GlobalName); }
 
   /// Return a 64-bit global unique ID constructed from global value name
   /// (i.e. returned by getGlobalIdentifier()).
-  uint64_t getGUID() { return getGUID(getGlobalIdentifier()); }
+  GUID getGUID() { return getGUID(getGlobalIdentifier()); }
 
   /// @name Materialization
   /// Materialization is used to construct functions only as they're needed.
   /// This
   /// is useful to reduce memory usage in LLVM or parsing work done by the
   /// BitcodeReader to load the Module.
   /// @{
 

include/llvm/IR/ModuleSummaryIndex.h

private:
   /// In the future this will be used to update and optimize linkage
   /// types based on global summary-based analysis.
   GlobalValue::LinkageTypes Linkage;
 
   /// List of GUIDs of values referenced by this global value's definition
   /// (either by the initializer of a global variable, or referenced
   /// from within a function). This does not include functions called, which
   /// are listed in the derived FunctionSummary object.
-  std::vector<uint64_t> RefEdgeList;
+  std::vector<GlobalValue::GUID> RefEdgeList;
 
 protected:
   /// GlobalValueSummary constructor.
   GlobalValueSummary(SummaryKind K, GlobalValue::LinkageTypes Linkage)
       : Kind(K), Linkage(Linkage) {}
 
 public:
   virtual ~GlobalValueSummary() = default;
 
   /// Which kind of summary subclass this is.
   SummaryKind getSummaryKind() const { return Kind; }
 
   /// Set the path to the module containing this function, for use in
   /// the combined index.
   void setModulePath(StringRef ModPath) { ModulePath = ModPath; }
 
   /// Get the path to the module containing this function.
   StringRef modulePath() const { return ModulePath; }
 
   /// Return linkage type recorded for this global value.
   GlobalValue::LinkageTypes linkage() const { return Linkage; }
 
   /// Record a reference from this global value to the global value identified
   /// by \p RefGUID.
-  void addRefEdge(uint64_t RefGUID) { RefEdgeList.push_back(RefGUID); }
+  void addRefEdge(GlobalValue::GUID RefGUID) { RefEdgeList.push_back(RefGUID); }
 
   /// Record a reference from this global value to each global value identified
   /// in \p RefEdges.
   void addRefEdges(DenseSet<unsigned> &RefEdges) {
     for (auto &RI : RefEdges)
       addRefEdge(RI);
   }
 
   /// Return the list of GUIDs referenced by this global value definition.
-  std::vector<uint64_t> &refs() { return RefEdgeList; }
-  const std::vector<uint64_t> &refs() const { return RefEdgeList; }
+  std::vector<GlobalValue::GUID> &refs() { return RefEdgeList; }
+  const std::vector<GlobalValue::GUID> &refs() const { return RefEdgeList; }
 };
 
 /// \brief Function summary information to aid decisions and implementation of
 /// importing.
 class FunctionSummary : public GlobalValueSummary {
 public:
   /// <CalleeGUID, CalleeInfo> call edge pair.
-  typedef std::pair<uint64_t, CalleeInfo> EdgeTy;
+  typedef std::pair<GlobalValue::GUID, CalleeInfo> EdgeTy;
 
 private:
   /// Number of instructions (ignoring debug instructions, e.g.) computed
   /// during the initial compile step when the summary index is first built.
   unsigned InstCount;
 
   /// List of <CalleeGUID, CalleeInfo> call edge pairs from this function.
   std::vector<EdgeTy> CallGraphEdgeList;
public:
   }
 
   /// Get the instruction count recorded for this function.
   unsigned instCount() const { return InstCount; }
 
   /// Record a call graph edge from this function to the function identified
   /// by \p CalleeGUID, with \p CalleeInfo including the cumulative profile
   /// count (across all calls from this function) or 0 if no PGO.
-  void addCallGraphEdge(uint64_t CalleeGUID, CalleeInfo Info) {
+  void addCallGraphEdge(GlobalValue::GUID CalleeGUID, CalleeInfo Info) {
     CallGraphEdgeList.push_back(std::make_pair(CalleeGUID, Info));
   }
 
   /// Record a call graph edge from this function to each function recorded
   /// in \p CallGraphEdges.
   void addCallGraphEdges(DenseMap<unsigned, CalleeInfo> &CallGraphEdges) {
     for (auto &EI : CallGraphEdges)
       addCallGraphEdge(EI.first, EI.second);

 /// COMDAT values of the same name.
 typedef std::vector<std::unique_ptr<GlobalValueInfo>> GlobalValueInfoList;
 
 /// Map from global value GUID to corresponding info structures.
 /// Use a std::map rather than a DenseMap since it will likely incur
 /// less overhead, as the value type is not very small and the size
 /// of the map is unknown, resulting in inefficiencies due to repeated
 /// insertions and resizing.
-typedef std::map<uint64_t, GlobalValueInfoList> GlobalValueInfoMapTy;
+typedef std::map<GlobalValue::GUID, GlobalValueInfoList> GlobalValueInfoMapTy;
 
 /// Type used for iterating through the global value info map.
 typedef GlobalValueInfoMapTy::const_iterator const_globalvalueinfo_iterator;
 typedef GlobalValueInfoMapTy::iterator globalvalueinfo_iterator;
 
 /// String table to hold/own module path strings, which additionally holds the
 /// module ID assigned to each module during the plugin step, as well as a hash
 /// of the module. The StringMap makes a copy of and owns inserted strings.
public:
   /// Get the list of global value info objects for a given value name.
   const const_globalvalueinfo_iterator
   findGlobalValueInfoList(StringRef ValueName) const {
     return GlobalValueMap.find(GlobalValue::getGUID(ValueName));
   }
 
   /// Get the list of global value info objects for a given value GUID.
   const const_globalvalueinfo_iterator
-  findGlobalValueInfoList(uint64_t ValueGUID) const {
+  findGlobalValueInfoList(GlobalValue::GUID ValueGUID) const {
     return GlobalValueMap.find(ValueGUID);
   }
 
   /// Add a global value info for a value of the given name.
   void addGlobalValueInfo(StringRef ValueName,
                           std::unique_ptr<GlobalValueInfo> Info) {
     GlobalValueMap[GlobalValue::getGUID(ValueName)].push_back(std::move(Info));
   }
 
   /// Add a global value info for a value of the given GUID.
-  void addGlobalValueInfo(uint64_t ValueGUID,
+  void addGlobalValueInfo(GlobalValue::GUID ValueGUID,
                           std::unique_ptr<GlobalValueInfo> Info) {
     GlobalValueMap[ValueGUID].push_back(std::move(Info));
   }
 
   /// Table of modules, containing module hash and id.
   const StringMap<std::pair<uint64_t, ModuleHash>> &modulePaths() const {
     return ModulePathStringTable;
   }

include/llvm/Transforms/IPO/FunctionImport.h

 //===- llvm/Transforms/IPO/FunctionImport.h - ThinLTO importing -*- C++ -*-===//
 //
 //                      The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_FUNCTIONIMPORT_H
 #define LLVM_FUNCTIONIMPORT_H
 
 #include "llvm/ADT/StringMap.h"
+#include "llvm/IR/GlobalValue.h"
 
 #include <functional>
 #include <map>
 #include <unordered_set>
 
 namespace llvm {
 class LLVMContext;
 class Module;
 class ModuleSummaryIndex;
 
 /// The function importer is automatically importing function from other modules
 /// based on the provided summary informations.
 class FunctionImporter {
 public:
   /// Set of functions to import from a source module. Each entry is a map
   /// containing all the functions to import for a source module.
   /// The keys is the GUID identifying a function to import, and the value
   /// is the threshold applied when deciding to import it.
-  typedef std::map<uint64_t, unsigned> FunctionsToImportTy;
+  typedef std::map<GlobalValue::GUID, unsigned> FunctionsToImportTy;
 
   /// The map contains an entry for every module to import from, the key being
   /// the module identifier to pass to the ModuleLoader. The value is the set of
   /// functions to import.
   typedef StringMap<FunctionsToImportTy> ImportMapTy;
 
   /// The set contains an entry for every global value the module exports.
-  typedef std::unordered_set<uint64_t> ExportSetTy;
+  typedef std::unordered_set<GlobalValue::GUID> ExportSetTy;
 
   /// Create a Function Importer.
   FunctionImporter(
       const ModuleSummaryIndex &Index,
       std::function<std::unique_ptr<Module>(StringRef Identifier)> ModuleLoader)
       : Index(Index), ModuleLoader(ModuleLoader) {}
 
   /// Import functions in Module \p M based on the supplied import list.

lib/Bitcode/Reader/BitcodeReader.cpp

class ModuleSummaryIndexBitcodeReader {
   /// Used to enable on-demand parsing of the VST.
   uint64_t VSTOffset = 0;
 
   // Map to save ValueId to GUID association that was recorded in the
   // ValueSymbolTable. It is used after the VST is parsed to convert
   // call graph edges read from the function summary from referencing
   // callees by their ValueId to using the GUID instead, which is how
   // they are recorded in the summary index being built.
-  DenseMap<unsigned, uint64_t> ValueIdToCallGraphGUIDMap;
+  DenseMap<unsigned, GlobalValue::GUID> ValueIdToCallGraphGUIDMap;
 
   /// Map to save the association between summary offset in the VST to the
   /// GlobalValueInfo object created when parsing it. Used to access the
   /// info object when parsing the summary section.
   DenseMap<uint64_t, GlobalValueInfo *> SummaryOffsetToInfoMap;
 
   /// Map populated during module path string table parsing, from the
   /// module ID to a string reference owned by the index's module
private:
   std::error_code parseValueSymbolTable(
       uint64_t Offset,
       DenseMap<unsigned, GlobalValue::LinkageTypes> &ValueIdToLinkageMap);
   std::error_code parseEntireSummary();
   std::error_code parseModuleStringTable();
   std::error_code initStream(std::unique_ptr<DataStreamer> Streamer);
   std::error_code initStreamFromBuffer();
   std::error_code initLazyStream(std::unique_ptr<DataStreamer> Streamer);
-  uint64_t getGUIDFromValueId(unsigned ValueId);
+  GlobalValue::GUID getGUIDFromValueId(unsigned ValueId);
   GlobalValueInfo *getInfoFromSummaryOffset(uint64_t Offset);
 };
 } // end anonymous namespace
 
 BitcodeDiagnosticInfo::BitcodeDiagnosticInfo(std::error_code EC,
                                              DiagnosticSeverity Severity,
                                              const Twine &Msg)
     : DiagnosticInfo(DK_Bitcode, Severity), Msg(Msg), EC(EC) {}
ModuleSummaryIndexBitcodeReader::ModuleSummaryIndexBitcodeReader(
     bool CheckGlobalValSummaryPresenceOnly)
     : DiagnosticHandler(DiagnosticHandler), Buffer(nullptr), IsLazy(IsLazy),
       CheckGlobalValSummaryPresenceOnly(CheckGlobalValSummaryPresenceOnly) {}
 
 void ModuleSummaryIndexBitcodeReader::freeState() { Buffer = nullptr; }
 
 void ModuleSummaryIndexBitcodeReader::releaseBuffer() { Buffer.release(); }
 
-uint64_t ModuleSummaryIndexBitcodeReader::getGUIDFromValueId(unsigned ValueId) {
+GlobalValue::GUID
+ModuleSummaryIndexBitcodeReader::getGUIDFromValueId(unsigned ValueId) {
   auto VGI = ValueIdToCallGraphGUIDMap.find(ValueId);
   assert(VGI != ValueIdToCallGraphGUIDMap.end());
   return VGI->second;
 }
 
 GlobalValueInfo *
 ModuleSummaryIndexBitcodeReader::getInfoFromSummaryOffset(uint64_t Offset) {
   auto I = SummaryOffsetToInfoMap.find(Offset);
case bitc::VST_CODE_FNENTRY: {
 
       ValueName.clear();
       break;
     }
     case bitc::VST_CODE_COMBINED_GVDEFENTRY: {
       // VST_CODE_COMBINED_GVDEFENTRY: [valueid, offset, guid]
       unsigned ValueID = Record[0];
       uint64_t GlobalValSummaryOffset = Record[1];
-      uint64_t GlobalValGUID = Record[2];
+      GlobalValue::GUID GlobalValGUID = Record[2];
       std::unique_ptr<GlobalValueInfo> GlobalValInfo =
           llvm::make_unique<GlobalValueInfo>(GlobalValSummaryOffset);
       SummaryOffsetToInfoMap[GlobalValSummaryOffset] = GlobalValInfo.get();
       TheIndex->addGlobalValueInfo(GlobalValGUID, std::move(GlobalValInfo));
       ValueIdToCallGraphGUIDMap[ValueID] = GlobalValGUID;
       break;
     }
     case bitc::VST_CODE_COMBINED_ENTRY: {
       // VST_CODE_COMBINED_ENTRY: [valueid, refguid]
       unsigned ValueID = Record[0];
-      uint64_t RefGUID = Record[1];
+      GlobalValue::GUID RefGUID = Record[1];
       ValueIdToCallGraphGUIDMap[ValueID] = RefGUID;
       break;
     }
     }
   }
 }
 
 // Parse just the blocks needed for building the index out of the module.
case bitc::FS_PERMODULE_PROFILE: {
       FS->setModulePath(
           TheIndex->addModulePath(Buffer->getBufferIdentifier(), 0)->first());
       static int RefListStartIndex = 4;
       int CallGraphEdgeStartIndex = RefListStartIndex + NumRefs;
       assert(Record.size() >= RefListStartIndex + NumRefs &&
              "Record size inconsistent with number of references");
       for (unsigned I = 4, E = CallGraphEdgeStartIndex; I != E; ++I) {
         unsigned RefValueId = Record[I];
-        uint64_t RefGUID = getGUIDFromValueId(RefValueId);
+        GlobalValue::GUID RefGUID = getGUIDFromValueId(RefValueId);
         FS->addRefEdge(RefGUID);
       }
       bool HasProfile = (BitCode == bitc::FS_PERMODULE_PROFILE);
       for (unsigned I = CallGraphEdgeStartIndex, E = Record.size(); I != E;
            ++I) {
         unsigned CalleeValueId = Record[I];
         unsigned CallsiteCount = Record[++I];
         uint64_t ProfileCount = HasProfile ? Record[++I] : 0;
-        uint64_t CalleeGUID = getGUIDFromValueId(CalleeValueId);
+        GlobalValue::GUID CalleeGUID = getGUIDFromValueId(CalleeValueId);
         FS->addCallGraphEdge(CalleeGUID,
                              CalleeInfo(CallsiteCount, ProfileCount));
       }
-      uint64_t GUID = getGUIDFromValueId(ValueID);
+      GlobalValue::GUID GUID = getGUIDFromValueId(ValueID);
       auto InfoList = TheIndex->findGlobalValueInfoList(GUID);
       assert(InfoList != TheIndex->end() &&
              "Expected VST parse to create GlobalValueInfo entry");
       assert(InfoList->second.size() == 1 &&
              "Expected a single GlobalValueInfo per GUID in module");
       auto &Info = InfoList->second[0];
       assert(!Info->summary() && "Expected a single summary per VST entry");
       Info->setSummary(std::move(FS));
       break;
     }
     // FS_PERMODULE_GLOBALVAR_INIT_REFS: [valueid, linkage, n x valueid]
     case bitc::FS_PERMODULE_GLOBALVAR_INIT_REFS: {
       unsigned ValueID = Record[0];
       uint64_t RawLinkage = Record[1];
       std::unique_ptr<GlobalVarSummary> FS =
           llvm::make_unique<GlobalVarSummary>(getDecodedLinkage(RawLinkage));
       FS->setModulePath(
           TheIndex->addModulePath(Buffer->getBufferIdentifier(), 0)->first());
       for (unsigned I = 2, E = Record.size(); I != E; ++I) {
         unsigned RefValueId = Record[I];
-        uint64_t RefGUID = getGUIDFromValueId(RefValueId);
+        GlobalValue::GUID RefGUID = getGUIDFromValueId(RefValueId);
         FS->addRefEdge(RefGUID);
       }
-      uint64_t GUID = getGUIDFromValueId(ValueID);
+      GlobalValue::GUID GUID = getGUIDFromValueId(ValueID);
       auto InfoList = TheIndex->findGlobalValueInfoList(GUID);
       assert(InfoList != TheIndex->end() &&
              "Expected VST parse to create GlobalValueInfo entry");
       assert(InfoList->second.size() == 1 &&
              "Expected a single GlobalValueInfo per GUID in module");
       auto &Info = InfoList->second[0];
       assert(!Info->summary() && "Expected a single summary per VST entry");
       Info->setSummary(std::move(FS));
case bitc::FS_COMBINED_PROFILE: {
           getDecodedLinkage(RawLinkage), InstCount);
       FS->setModulePath(ModuleIdMap[ModuleId]);
       static int RefListStartIndex = 4;
       int CallGraphEdgeStartIndex = RefListStartIndex + NumRefs;
       assert(Record.size() >= RefListStartIndex + NumRefs &&
              "Record size inconsistent with number of references");
       for (unsigned I = 4, E = CallGraphEdgeStartIndex; I != E; ++I) {
         unsigned RefValueId = Record[I];
-        uint64_t RefGUID = getGUIDFromValueId(RefValueId);
+        GlobalValue::GUID RefGUID = getGUIDFromValueId(RefValueId);
         FS->addRefEdge(RefGUID);
       }
       bool HasProfile = (BitCode == bitc::FS_COMBINED_PROFILE);
       for (unsigned I = CallGraphEdgeStartIndex, E = Record.size(); I != E;
            ++I) {
         unsigned CalleeValueId = Record[I];
         unsigned CallsiteCount = Record[++I];
         uint64_t ProfileCount = HasProfile ? Record[++I] : 0;
-        uint64_t CalleeGUID = getGUIDFromValueId(CalleeValueId);
+        GlobalValue::GUID CalleeGUID = getGUIDFromValueId(CalleeValueId);
         FS->addCallGraphEdge(CalleeGUID,
                              CalleeInfo(CallsiteCount, ProfileCount));
       }
       auto *Info = getInfoFromSummaryOffset(CurRecordBit);
       assert(!Info->summary() && "Expected a single summary per VST entry");
       Info->setSummary(std::move(FS));
       Combined = true;
       break;
     }
     // FS_COMBINED_GLOBALVAR_INIT_REFS: [modid, linkage, n x valueid]
     case bitc::FS_COMBINED_GLOBALVAR_INIT_REFS: {
       uint64_t ModuleId = Record[0];
       uint64_t RawLinkage = Record[1];
       std::unique_ptr<GlobalVarSummary> FS =
           llvm::make_unique<GlobalVarSummary>(getDecodedLinkage(RawLinkage));
       FS->setModulePath(ModuleIdMap[ModuleId]);
       for (unsigned I = 2, E = Record.size(); I != E; ++I) {
         unsigned RefValueId = Record[I];
-        uint64_t RefGUID = getGUIDFromValueId(RefValueId);
+        GlobalValue::GUID RefGUID = getGUIDFromValueId(RefValueId);
         FS->addRefEdge(RefGUID);
       }
       auto *Info = getInfoFromSummaryOffset(CurRecordBit);
       assert(!Info->summary() && "Expected a single summary per VST entry");
       Info->setSummary(std::move(FS));
       Combined = true;
       break;
     }

lib/Bitcode/Writer/BitcodeWriter.cpp

for (const ValueName &Name : VST) {
     Stream.EmitRecord(Code, NameVals, AbbrevToUse);
     NameVals.clear();
   }
   Stream.ExitBlock();
 }
 
 /// Emit function names and summary offsets for the combined index
 /// used by ThinLTO.
-static void
-WriteCombinedValueSymbolTable(const ModuleSummaryIndex &Index,
-                              BitstreamWriter &Stream,
-                              std::map<uint64_t, unsigned> &GUIDToValueIdMap,
-                              uint64_t VSTOffsetPlaceholder) {
+static void WriteCombinedValueSymbolTable(
+    const ModuleSummaryIndex &Index, BitstreamWriter &Stream,
+    std::map<GlobalValue::GUID, unsigned> &GUIDToValueIdMap,
   assert(VSTOffsetPlaceholder > 0 && "Expected non-zero VSTOffsetPlaceholder");
   // Get the offset of the VST we are writing, and backpatch it into
   // the VST forward declaration record.
   uint64_t VSTOffset = Stream.GetCurrentBitNo();
   assert((VSTOffset & 31) == 0 && "VST block not 32-bit aligned");
   Stream.BackpatchWord(VSTOffsetPlaceholder, VSTOffset / 32);
 
   Stream.EnterSubblock(bitc::VALUE_SYMTAB_BLOCK_ID, 4);
static void WriteCombinedValueSymbolTable(
   Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_COMBINED_ENTRY));
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // valueid
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // refguid
   unsigned EntryAbbrev = Stream.EmitAbbrev(Abbv);
 
   SmallVector<uint64_t, 64> NameVals;
 
   for (const auto &FII : Index) {
-    uint64_t FuncGUID = FII.first;
+    GlobalValue::GUID FuncGUID = FII.first;
     const auto &VMI = GUIDToValueIdMap.find(FuncGUID);
     assert(VMI != GUIDToValueIdMap.end());
 
     for (const auto &FI : FII.second) {
       // VST_CODE_COMBINED_GVDEFENTRY: [valueid, sumoffset, guid]
       NameVals.push_back(VMI->second);
       NameVals.push_back(FI->bitcodeIndex());
       NameVals.push_back(FuncGUID);
if (auto *GV = dyn_cast<GlobalVariable>(A.getBaseObject()))
       WriteModuleLevelReferences(*GV, VE, NameVals, FSModRefsAbbrev, Stream);
 
   Stream.ExitBlock();
 }
 
 /// Emit the combined summary section into the combined index file.
 static void WriteCombinedGlobalValueSummary(
     const ModuleSummaryIndex &I, BitstreamWriter &Stream,
-    std::map<uint64_t, unsigned> &GUIDToValueIdMap, unsigned GlobalValueId) {
+    std::map<GlobalValue::GUID, unsigned> &GUIDToValueIdMap,
+    unsigned GlobalValueId) {
   Stream.EnterSubblock(bitc::GLOBALVAL_SUMMARY_BLOCK_ID, 3);
 
   // Abbrev for FS_COMBINED.
   BitCodeAbbrev *Abbv = new BitCodeAbbrev();
   Abbv->Add(BitCodeAbbrevOp(bitc::FS_COMBINED));
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // modid
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 5)); // linkage
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // instcount
void llvm::WriteIndexToFile(const ModuleSummaryIndex &Index, raw_ostream &Out) {
 
   // Write the module paths in the combined index.
   WriteModStrings(Index, Stream);
 
   // Assign unique value ids to all functions in the index for use
   // in writing out the call graph edges. Save the mapping from GUID
   // to the new global value id to use when writing those edges, which
   // are currently saved in the index in terms of GUID.
-  std::map<uint64_t, unsigned> GUIDToValueIdMap;
+  std::map<GlobalValue::GUID, unsigned> GUIDToValueIdMap;
   unsigned GlobalValueId = 0;
   for (auto &II : Index)
     GUIDToValueIdMap[II.first] = ++GlobalValueId;
 
   // Write the summary combined index records.
   WriteCombinedGlobalValueSummary(Index, Stream, GUIDToValueIdMap,
                                   GlobalValueId);
 

lib/IR/ModuleSummaryIndex.cpp

 
 // Create the combined module index/summary from multiple
 // per-module instances.
 void ModuleSummaryIndex::mergeFrom(std::unique_ptr<ModuleSummaryIndex> Other,
                                    uint64_t NextModuleId) {
 
   StringRef ModPath;
   for (auto &OtherGlobalValInfoLists : *Other) {
-    uint64_t ValueGUID = OtherGlobalValInfoLists.first;
+    GlobalValue::GUID ValueGUID = OtherGlobalValInfoLists.first;
     GlobalValueInfoList &List = OtherGlobalValInfoLists.second;
 
     // Assert that the value info list only has one entry, since we shouldn't
     // have duplicate names within a single per-module index.
     assert(List.size() == 1);
     std::unique_ptr<GlobalValueInfo> Info = std::move(List.front());
 
     // Skip if there was no summary section.

lib/Transforms/IPO/FunctionImport.cpp

selectCallee(const GlobalValueInfoList &CalleeInfoList, unsigned Threshold) {
   if (It == CalleeInfoList.end())
     return nullptr;
 
   return cast<FunctionSummary>((*It)->summary());
 }
 
 /// Return the summary for the function \p GUID that fits the \p Threshold, or
 /// null if there's no match.
-static const FunctionSummary *selectCallee(uint64_t GUID, unsigned Threshold,
+static const FunctionSummary *selectCallee(GlobalValue::GUID GUID,
+                                           unsigned Threshold,
                                            const ModuleSummaryIndex &Index) {
   auto CalleeInfoList = Index.findGlobalValueInfoList(GUID);
   if (CalleeInfoList == Index.end()) {
     return nullptr; // This function does not have a summary
   }
   return selectCallee(CalleeInfoList->second, Threshold);
 }
 
 /// Return true if the global \p GUID is exported by module \p ExportModulePath.
 static bool isGlobalExported(const ModuleSummaryIndex &Index,
-                             StringRef ExportModulePath, uint64_t GUID) {
+                             StringRef ExportModulePath,
+                             GlobalValue::GUID GUID) {
   auto CalleeInfoList = Index.findGlobalValueInfoList(GUID);
   if (CalleeInfoList == Index.end())
     // This global does not have a summary, it is not part of the ThinLTO
     // process
     return false;
   auto DefinedInCalleeModule = llvm::find_if(
       CalleeInfoList->second,
       [&](const std::unique_ptr<GlobalValueInfo> &GlobInfo) {
         auto *Summary = GlobInfo->summary();
         assert(Summary && "Unexpected GlobalValueInfo without summary");
         return Summary->modulePath() == ExportModulePath;
       });
   return (DefinedInCalleeModule != CalleeInfoList->second.end());
 }
 
 using EdgeInfo = std::pair<const FunctionSummary *, unsigned /* Threshold */>;
 
 /// Compute the list of functions to import for a given caller. Mark these
 /// imported functions and the symbols they reference in their source module as
 /// exported from their source module.
 static void computeImportForFunction(
     StringRef ModulePath, const FunctionSummary &Summary,
     const ModuleSummaryIndex &Index, unsigned Threshold,
-    const std::map<uint64_t, FunctionSummary *> &DefinedFunctions,
+    const std::map<GlobalValue::GUID, FunctionSummary *> &DefinedFunctions,
     SmallVectorImpl<EdgeInfo> &Worklist,
     FunctionImporter::ImportMapTy &ImportsForModule,
     StringMap<FunctionImporter::ExportSetTy> &ExportLists) {
   for (auto &Edge : Summary.calls()) {
     auto GUID = Edge.first;
     DEBUG(dbgs() << " edge -> " << GUID << " Threshold:" << Threshold << "\n");
 
     if (DefinedFunctions.count(GUID)) {
static void computeImportForFunction(
   }
 }
 
 /// Given the list of globals defined in a module, compute the list of imports
 /// as well as the list of "exports", i.e. the list of symbols referenced from
 /// another module (that may require promotion).
 static void ComputeImportForModule(
     StringRef ModulePath,
-    const std::map<uint64_t, FunctionSummary *> &DefinedFunctions,
+    const std::map<GlobalValue::GUID, FunctionSummary *> &DefinedFunctions,
     const ModuleSummaryIndex &Index,
     FunctionImporter::ImportMapTy &ImportsForModule,
     StringMap<FunctionImporter::ExportSetTy> &ExportLists) {
   // Worklist contains the list of function imported in this module, for which
   // we will analyse the callees and may import further down the callgraph.
   SmallVector<EdgeInfo, 128> Worklist;
 
   // Populate the worklist with the import for the functions in the current

 void llvm::ComputeCrossModuleImport(
     const ModuleSummaryIndex &Index,
     StringMap<FunctionImporter::ImportMapTy> &ImportLists,
     StringMap<FunctionImporter::ExportSetTy> &ExportLists) {
   auto ModuleCount = Index.modulePaths().size();
 
   // Collect for each module the list of function it defines.
   // GUID -> Summary
-  StringMap<std::map<uint64_t, FunctionSummary *>> Module2FunctionInfoMap(
-      ModuleCount);
+  StringMap<std::map<GlobalValue::GUID, FunctionSummary *>>
+      Module2FunctionInfoMap(ModuleCount);
 
   for (auto &GlobalList : Index) {
     auto GUID = GlobalList.first;
     for (auto &GlobInfo : GlobalList.second) {
       auto *Summary = dyn_cast_or_null<FunctionSummary>(GlobInfo->summary());
       if (!Summary)
         /// Ignore global variable, focus on functions
         continue;