diff --git a/include/llvm/PML.h b/include/llvm/PML.h
index 75ca94dcb153f6b7378ea3b77675f073c613fc6b..5ae251c4a992f2d57e276eba2a5d7a1338f7a649 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 53212fb3ea85f21c5282a8d370bc5bc1214ed4e3..e516bfe89603c3971157263b4eecadf48ce012f7 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