From 5bfb7c406db8fc3d18342b8bb7e99d9069b39591 Mon Sep 17 00:00:00 2001
From: Simon Schuster <git@rationality.eu>
Date: Sat, 22 Apr 2017 16:58:57 +0200
Subject: [PATCH] Export function linkage information to PMLs

This commit exports a functions LinkageType to PML for both
MachineFunctions and BitcodeFunctions.
---
 include/llvm/PML.h        | 32 +++++++++++++++++++++++++++++++-
 lib/CodeGen/PMLExport.cpp |  2 ++
 2 files changed, 33 insertions(+), 1 deletion(-)

diff --git a/include/llvm/PML.h b/include/llvm/PML.h
index 75ca94dcb15..5ae251c4a99 100644
--- a/include/llvm/PML.h
+++ b/include/llvm/PML.h
@@ -420,6 +420,33 @@ struct MappingTraits<Subfunction*> {
 };
 YAML_IS_PTR_SEQUENCE_VECTOR(Subfunction)
 
+template <>
+struct ScalarEnumerationTraits<llvm::GlobalValue::LinkageTypes> {
+  static void enumeration(IO &io, llvm::GlobalValue::LinkageTypes &value) {
+    ///< Externally visible function
+    io.enumCase(value, "ExternalLinkage", llvm::GlobalValue::ExternalLinkage);
+    ///< Available for inspection, not emission.
+    io.enumCase(value, "AvailableExternallyLinkage", llvm::GlobalValue::AvailableExternallyLinkage);
+    ///< Keep one copy of function when linking (inline)
+    io.enumCase(value, "LinkOnceAnyLinkage", llvm::GlobalValue::LinkOnceAnyLinkage);
+    ///< Same, but only replaced by something equivalent.
+    io.enumCase(value, "LinkOnceODRLinkage", llvm::GlobalValue::LinkOnceODRLinkage);
+    ///< Keep one copy of named function when linking (weak)
+    io.enumCase(value, "WeakAnyLinkage", llvm::GlobalValue::WeakAnyLinkage);
+    ///< Same, but only replaced by something equivalent.
+    io.enumCase(value, "WeakODRLinkage", llvm::GlobalValue::WeakODRLinkage);
+    ///< Special purpose, only applies to global arrays
+    io.enumCase(value, "AppendingLinkage", llvm::GlobalValue::AppendingLinkage);
+    ///< Rename collisions when linking (static functions).
+    io.enumCase(value, "InternalLinkage", llvm::GlobalValue::InternalLinkage);
+    ///< Like Internal, but omit from symbol table.
+    io.enumCase(value, "PrivateLinkage", llvm::GlobalValue::PrivateLinkage);
+    ///< ExternalWeak linkage description.
+    io.enumCase(value, "ExternalWeakLinkage", llvm::GlobalValue::ExternalWeakLinkage);
+    ///< Tentative definitions.
+    io.enumCase(value, "CommonLinkage", llvm::GlobalValue::CommonLinkage);
+  }
+};
 
 /// basic functions
 template <typename BlockT>
@@ -431,6 +458,7 @@ struct Function {
   std::vector<Argument*> Arguments;
   std::vector<BlockT*> Blocks;
   std::vector<Subfunction*> Subfunctions;
+  llvm::GlobalValue::LinkageTypes Linkage = llvm::GlobalValue::ExternalLinkage;
 
   Function(StringRef name) : FunctionName(name), Level(level_bitcode) {}
   Function(uint64_t name)  : FunctionName(name), Level(level_bitcode) {}
@@ -452,8 +480,9 @@ struct Function {
     Subfunctions.push_back(S);
     return S;
   }
+
 private:
-  Function(const Function<BlockT>&);            // Disable copy constructor  
+  Function(const Function<BlockT>&);            // Disable copy constructor
   Function* operator=(const Function<BlockT>&); // Disable assignment
 
 };
@@ -468,6 +497,7 @@ struct MappingTraits< Function<BlockT>* > {
     io.mapOptional("hash",        Fn->Hash);
     io.mapRequired("blocks",      Fn->Blocks);
     io.mapOptional("subfunctions",Fn->Subfunctions);
+    io.mapOptional("linkage",     Fn->Linkage, llvm::GlobalValue::ExternalLinkage);
   }
 };
 YAML_IS_PTR_SEQUENCE_VECTOR_1(Function)
diff --git a/lib/CodeGen/PMLExport.cpp b/lib/CodeGen/PMLExport.cpp
index 53212fb3ea8..e516bfe8960 100644
--- a/lib/CodeGen/PMLExport.cpp
+++ b/lib/CodeGen/PMLExport.cpp
@@ -240,6 +240,7 @@ void PMLBitcodeExport::serialize(MachineFunction &MF)
   // create PML bitcode function
   yaml::BitcodeFunction *F = new yaml::BitcodeFunction(Fn->getName());
   F->Level = yaml::level_bitcode;
+  F->Linkage = Fn->getLinkage();
   yaml::BitcodeBlock *B;
 
 
@@ -427,6 +428,7 @@ void PMLMachineExport::serialize(MachineFunction &MF)
 
   PMF->MapsTo = yaml::Name(MF.getFunction()->getName());
   PMF->Level = yaml::level_machinecode;
+  PMF->Linkage = F->getLinkage();
   yaml::MachineBlock *B;
 
   // export argument-register mapping if available
-- 
GitLab