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("deps",

[Mark Seaborn, 2016/03/29 15:29:39]

Remember that this is an option for the 'opt' tool.  "-deps" is a bit too
generic.  How about "-convert-to-pso-deps"?

[Sean Klein, 2016/03/29 17:58:29]

Done.

+                      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 (unsigned i = 0; i != LibraryDependencies.size(); ++i) {

[Mark Seaborn, 2016/03/29 15:29:39]

You can use "for (... : LibrariesDependencies)"

[Sean Klein, 2016/03/29 17:58:29]

Done.

+    DependenciesList.append(LibraryDependencies[i]);
+    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),
+
+    // Dependencies List

[Mark Seaborn, 2016/03/29 15:40:06]

When you rebase, this should go at the end, after the TLS template fields, so as
not to break when rolled in.

[Sean Klein, 2016/03/29 17:58:29]

Do you mean that I should place these fields after the
"PsoRoot.push_back(FieldVal)" below? This CL is up-to-date.

[Mark Seaborn, 2016/03/29 18:50:44]

Yes, that would be better in the sense that it avoids the need for a 2-sided
change -- i.e. it avoids the need to update pll_root.h at the same time.  That
also means you can run the trybots for this change.

(We can reorder these fields to have a more coherent order at some point in the
future.)
Ah yes, I forgot that the TLS fields are added via push_back() rather than in
this initialiser.

+    ConstantInt::get(IntPtrType, LibraryDependencies.size()),
+    DependenciesListVar,
   };
   for (auto FieldVal : PsoRootTlsFields)
     PsoRoot.push_back(FieldVal);
   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();
 }