PNaCl Dynamic Linking: Storing dependencies from command line in PLL.

lib/Transforms/NaCl/ConvertToPSO.cpp

 //===- ConvertToPSO.cpp - Convert module to a PNaCl PSO--------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // The ConvertToPSO pass is part of an implementation of dynamic
@@ skipping 44 matching lines @@
   //
   // For the time being, this is intended only as a convenience for making
   // cross-repo changes, because the PSO format is interpreted by code in
   // the native_client repo.  The PSO format is not intended to be stable
   // yet.
   //
   // If the format is changed in a compatible way, an alternative is to
   // increment TOOLCHAIN_FEATURE_VERSION instead.
   const int PSOFormatVersion = 2;
 
+  // Command line arguments consist of a list of PLL dependencies.
+  static cl::list<std::string>
+  LibraryDependencies("convert-to-pso-deps",
+                      cl::CommaSeparated,
+                      cl::desc("The dependencies of the PLL being built"),
+                      cl::value_desc("PLL to list as dependency"));
+
   // This is a ModulePass because it inherently operates on a whole module.
   class ConvertToPSO : public ModulePass {
   public:
     static char ID; // Pass identification, replacement for typeid
     ConvertToPSO() : ModulePass(ID) {
       initializeConvertToPSOPass(*PassRegistry::getPassRegistry());
     }
 
     virtual bool runOnModule(Module &M);
   };
@@ skipping 569 matching lines @@
   // This lets us remove the "NumChainEntries" field from the PsoRoot.
   assert(NumChainEntries == ExportPtrs.size() && "Malformed export hash table");
 
   // Set up string of exported names.
   Constant *StringTableArray = ConstantDataArray::getString(
       C, StringRef(StringTable.data(), StringTable.size()), false);
   Constant *StringTableVar = new GlobalVariable(
       M, StringTableArray->getType(), true, GlobalValue::InternalLinkage,
       StringTableArray, "string_table");
 
+  // Set up string of PLL dependencies.
+  SmallString<1024> DependenciesList;
+  for (auto dependency : LibraryDependencies) {
+    DependenciesList.append(dependency);
+    DependenciesList.push_back(0);
+  }
+  Constant *DependenciesListArray = ConstantDataArray::getString(
+      C, StringRef(DependenciesList.data(), DependenciesList.size()), false);
+  Constant *DependenciesListVar = new GlobalVariable(
+      M, DependenciesListArray->getType(), true, GlobalValue::InternalLinkage,
+      DependenciesListArray, "dependencies_list");
+
   SmallVector<Constant *, 32> PsoRoot = {
     ConstantInt::get(IntPtrType, PSOFormatVersion),
 
     // String Table
     StringTableVar,
 
     // Exports
     createArray(M, "export_ptrs", &ExportPtrs, PtrType),
     createArray(M, "export_names", &ExportNames, IntPtrType),
     ConstantInt::get(IntPtrType, ExportPtrs.size()),
 
     // Imports
     createArray(M, "import_ptrs", &ImportPtrs, PtrType),
     createArray(M, "import_names", &ImportNames, IntPtrType),
     ConstantInt::get(IntPtrType, ImportPtrs.size()),
 
     // Hash Table (for quick string lookup of exports)
     ConstantInt::get(IntPtrType, NumBuckets),
     createDataArray(M, "hash_buckets", &HashBuckets),
     createDataArray(M, "hash_chains", &HashChains),
 
     // Bloom Filter (for quick string lookup rejection of exports)
     ConstantInt::get(IntPtrType, MaskWords - 1),
     ConstantInt::get(IntPtrType, Shift2),
     createDataArray(M, "bloom_filter", &BloomFilter),
   };
   for (auto FieldVal : PsoRootTlsFields)
     PsoRoot.push_back(FieldVal);
+
+  // Dependencies List
+  PsoRoot.push_back(ConstantInt::get(IntPtrType, LibraryDependencies.size()));
+  PsoRoot.push_back(DependenciesListVar);
+
   Constant *PsoRootConst = ConstantStruct::getAnon(PsoRoot);
   new GlobalVariable(
       M, PsoRootConst->getType(), true, GlobalValue::ExternalLinkage,
       PsoRootConst, "__pnacl_pso_root");
 
   // As soon as we have finished exporting aliases, we can resolve them.
   ModulePass *AliasPass = createResolveAliasesPass();
   AliasPass->runOnModule(M);
   delete AliasPass;
 
   return true;
 }
 
 ModulePass *llvm::createConvertToPSOPass() {
   return new ConvertToPSO();
 }