[FuzzMutate] Allow subclass of InsertFunctionStrategy to select function

[oakrc]

Summary

This revision allows subclasses to customize which function is used in
InsertFunctionStrategy::mutate(). This is useful for new custom strategies
that may insert a specific kind of function (e.g. intrinsics) but don't
otherwise need to modify how the function is called. Now instead of rewriting
mutate(), such new strategy only needs to override chooseFunction().

llvm/include/llvm/FuzzMutate/IRMutator.h

 public:
   uint64_t getWeight(size_t CurrentSize, size_t MaxSize,
                      uint64_t CurrentWeight) override {
     return 10;
   }
 
   using IRMutationStrategy::mutate;
   void mutate(BasicBlock &BB, RandomIRBuilder &IB) override;
+
+protected:
+  /// @brief Chooses a function to call from the given module
+  /// @param M module from which a function is selected
+  /// @param IB random IR builder
+  /// @return the function to call, or nullptr to create a new function
+  /// declaration
+  virtual Function *chooseFunction(Module *M, RandomIRBuilder &IB);
 };
 
 /// Strategy to split a random block and insert a random CFG in between.
 class InsertCFGStrategy : public IRMutationStrategy {
 private:
   uint64_t MaxNumCases;
   enum CFGToSink { Return, DirectSink, SinkOrSelfLoop, EndOfCFGToLink };
 

llvm/lib/FuzzMutate/IRMutator.cpp

static uint64_t getUniqueCaseValue(SmallSet<uint64_t, 4> &CasesTaken,
   uint64_t tmp;
   do {
     tmp = uniform<uint64_t>(IB.Rand, 0, MaxValue);
   } while (CasesTaken.count(tmp) != 0);
   CasesTaken.insert(tmp);
   return tmp;
 }
 
-void InsertFunctionStrategy::mutate(BasicBlock &BB, RandomIRBuilder &IB) {
-  Module *M = BB.getParent()->getParent();
+Function *InsertFunctionStrategy::chooseFunction(Module *M, RandomIRBuilder &IB) {
   // If nullptr is selected, we will create a new function declaration.
   SmallVector<Function *, 32> Functions({nullptr});
   for (Function &F : M->functions()) {
     Functions.push_back(&F);
   }
-
   auto RS = makeSampler(IB.Rand, Functions);
-  Function *F = RS.getSelection();
+  return RS.getSelection();
+}
+
+void InsertFunctionStrategy::mutate(BasicBlock &BB, RandomIRBuilder &IB) {
+  Module *M = BB.getParent()->getParent();
+  Function *F = chooseFunction(M, IB);
   // Some functions accept metadata type or token type as arguments.
   // We don't call those functions for now.
   // For example, `@llvm.dbg.declare(metadata, metadata, metadata)`
   // https://llvm.org/docs/SourceLevelDebugging.html#llvm-dbg-declare
   auto IsUnsupportedTy = [](Type *T) {
     return T->isMetadataTy() || T->isTokenTy();
   };
   if (!F || IsUnsupportedTy(F->getReturnType()) ||