[ExecutionEngine] Add JITSymbolFlags::fromSummary(GlobalValueSummary*)

[sgraenitz]

Summary

A function that creates JITSymbolFlags from a GlobalValueSummary. Similar functions exist: fromGlobalValue(), fromObjectSymbol()

[lhames]

LGTM! Thanks Stefan!

[sgraenitz]

Thanks for your review Lang. Will land it soon.

llvm/examples/ThinLtoJIT/ModuleIndex.cpp

ModuleIndex::fetchModuleInfo(const SymbolLookupSet &Symbols,
   for (const auto &KV : Symbols) {
     StringRef Name = stripManglePrefix(KV.first, GlobalManglePrefix);
     auto Guid = GlobalValue::getGUID(Name);
 
     // Append symbols we know. Ignore foreign symbols.
     if (GlobalValueSummary *S = getSummary(Guid)) {
       ModuleInfo &MI = MIs[S->modulePath()];
 
-      // TODO: Infer symbol flags from the ThinLTO module summary.
+      MI.SymbolFlags[KV.first] = JITSymbolFlags::fromSummary(S);
       MI.Guids.push_back(Guid);
 
       if (!isa<FunctionSummary>(S))
         MI.AllCallable = false;
     }
   }
   return MIs;
 }

llvm/include/llvm/ExecutionEngine/JITSymbol.h

 #include "llvm/ADT/BitmaskEnum.h"
 #include "llvm/ADT/FunctionExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Error.h"
 
 namespace llvm {
 
 class GlobalValue;
+class GlobalValueSummary;
 
 namespace object {
 
 class SymbolRef;
 
 } // end namespace object
 
 /// Represents an address in the target process's address space.
public:
 
   /// Return a reference to the target-specific flags.
   const TargetFlagsType& getTargetFlags() const { return TargetFlags; }
 
   /// Construct a JITSymbolFlags value based on the flags of the given global
   /// value.
   static JITSymbolFlags fromGlobalValue(const GlobalValue &GV);
 
+  /// Construct a JITSymbolFlags value based on the flags of the given global
+  /// value summary.
+  static JITSymbolFlags fromSummary(GlobalValueSummary *S);
+
   /// Construct a JITSymbolFlags value based on the flags of the given libobject
   /// symbol.
   static Expected<JITSymbolFlags>
   fromObjectSymbol(const object::SymbolRef &Symbol);
 
 private:
   TargetFlagsType TargetFlags = 0;
   FlagNames Flags = None;

llvm/lib/ExecutionEngine/RuntimeDyld/JITSymbol.cpp

 //===----------- JITSymbol.cpp - JITSymbol class implementation -----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // JITSymbol class implementation plus helper functions.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ExecutionEngine/JITSymbol.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GlobalAlias.h"
 #include "llvm/IR/GlobalValue.h"
+#include "llvm/IR/ModuleSummaryIndex.h"
 #include "llvm/Object/ObjectFile.h"
 
 using namespace llvm;
 
 JITSymbolFlags llvm::JITSymbolFlags::fromGlobalValue(const GlobalValue &GV) {
   JITSymbolFlags Flags = JITSymbolFlags::None;
   if (GV.hasWeakLinkage() || GV.hasLinkOnceLinkage())
     Flags |= JITSymbolFlags::Weak;
   if (GV.hasCommonLinkage())
     Flags |= JITSymbolFlags::Common;
   if (!GV.hasLocalLinkage() && !GV.hasHiddenVisibility())
     Flags |= JITSymbolFlags::Exported;
 
   if (isa<Function>(GV))
     Flags |= JITSymbolFlags::Callable;
   else if (isa<GlobalAlias>(GV) &&
            isa<Function>(cast<GlobalAlias>(GV).getAliasee()))
     Flags |= JITSymbolFlags::Callable;
 
   return Flags;
 }
 
+JITSymbolFlags llvm::JITSymbolFlags::fromSummary(GlobalValueSummary *S) {
+  JITSymbolFlags Flags = JITSymbolFlags::None;
+  auto L = S->linkage();
+  if (GlobalValue::isWeakLinkage(L) || GlobalValue::isLinkOnceLinkage(L))
+    Flags |= JITSymbolFlags::Weak;
+  if (GlobalValue::isCommonLinkage(L))
+    Flags |= JITSymbolFlags::Common;
+  if (GlobalValue::isExternalLinkage(L) || GlobalValue::isExternalWeakLinkage(L))
+    Flags |= JITSymbolFlags::Exported;
+
+  if (isa<FunctionSummary>(S))
+    Flags |= JITSymbolFlags::Callable;
+
+  return Flags;
+}
+
 Expected<JITSymbolFlags>
 llvm::JITSymbolFlags::fromObjectSymbol(const object::SymbolRef &Symbol) {
   JITSymbolFlags Flags = JITSymbolFlags::None;
   if (Symbol.getFlags() & object::BasicSymbolRef::SF_Weak)
     Flags |= JITSymbolFlags::Weak;
   if (Symbol.getFlags() & object::BasicSymbolRef::SF_Common)
     Flags |= JITSymbolFlags::Common;
   if (Symbol.getFlags() & object::BasicSymbolRef::SF_Exported)