RNG: Take pass name as argument instead of pass pointer.

[ddcc]

Summary

With the new pass manager, it is not possible to obtain a pointer to the pass.

[ddcc]

ping

llvm/include/llvm/IR/Module.h

/// @{
   /// RNG can be seeded via -rng-seed=<uint64> and is salted with the
   /// ModuleID and the provided pass salt. The returned RNG should not
   /// be shared across threads or passes.
   ///
   /// A unique RNG per pass ensures a reproducible random stream even
   /// when other randomness consuming passes are added or removed. In
   /// addition, the random stream will be reproducible across LLVM
   /// versions when the pass does not change.
-  std::unique_ptr<RandomNumberGenerator> createRNG(const Pass* P) const;
+  std::unique_ptr<RandomNumberGenerator> createRNG(const StringRef Name) const;
 
   /// Return true if size-info optimization remark is enabled, false
   /// otherwise.
   bool shouldEmitInstrCountChangedRemark() {
     return getContext().getDiagHandlerPtr()->isAnalysisRemarkEnabled(
         "size-info");
   }
 

llvm/lib/IR/Module.cpp

Module::~Module() {
   Context.removeModule(this);
   dropAllReferences();
   GlobalList.clear();
   FunctionList.clear();
   AliasList.clear();
   IFuncList.clear();
 }
 
-std::unique_ptr<RandomNumberGenerator> Module::createRNG(const Pass* P) const {
-  SmallString<32> Salt(P->getPassName());
+std::unique_ptr<RandomNumberGenerator>
+Module::createRNG(const StringRef Name) const {
+  SmallString<32> Salt(Name);
 
   // This RNG is guaranteed to produce the same random stream only
   // when the Module ID and thus the input filename is the same. This
   // might be problematic if the input filename extension changes
   // (e.g. from .c to .bc or .ll).
   //
   // We could store this salt in NamedMetadata, but this would make
   // the parameter non-const. This would unfortunately make this
   // interface unusable by any Machine passes, since they only have a
   // const reference to their IR Module. Alternatively we can always
   // store salt metadata from the Module constructor.
   Salt += sys::path::filename(getModuleIdentifier());
 
-  return std::unique_ptr<RandomNumberGenerator>(new RandomNumberGenerator(Salt));
+  return std::unique_ptr<RandomNumberGenerator>(
+      new RandomNumberGenerator(Salt));
 }
 
 /// getNamedValue - Return the first global value in the module with
 /// the specified name, of arbitrary type.  This method returns null
 /// if a global with the specified name is not found.
 GlobalValue *Module::getNamedValue(StringRef Name) const {
   return cast_or_null<GlobalValue>(getValueSymbolTable().lookup(Name));
 }

llvm/unittests/IR/ModuleTest.cpp

TEST(ModuleTest, randomNumberGenerator) {
 
   Module M("R", Context);
 
   std::uniform_int_distribution<int> dist;
   const size_t NBCheck = 10;
 
   std::array<int, NBCheck> RandomStreams[2];
   for (auto &RandomStream : RandomStreams) {
-    std::unique_ptr<RandomNumberGenerator> RNG = M.createRNG(&DP);
+    std::unique_ptr<RandomNumberGenerator> RNG = M.createRNG(DP->getPassName());
     std::generate(RandomStream.begin(), RandomStream.end(),
                   [&]() { return dist(*RNG); });
   }
 
   EXPECT_TRUE(std::equal(RandomStreams[0].begin(), RandomStreams[0].end(),
                          RandomStreams[1].begin()));
 }
 
 } // end namespace