[FuncSpec] Option for specializing const globals and function pointers.

[SjoerdMeijer]

Summary

In anticipation of D104365 that adds support for constant integers, this adds and option to enable specialisation for constant globals and function pointers. This more fine grain control may also be useful for testing.

[ChuanqiXu]

llvm/lib/Transforms/IPO/FunctionSpecialization.cpp

488

When would V != A become false? It looks always true to me.

BTW, since !Solver.getLatticeValueFor(V).isConstant() would be true for normal constant, it wouldn't run into the following condition in my minds.

llvm/lib/Transforms/IPO/FunctionSpecialization.cpp

cl::desc("The maximum number of clones allowed for a single function "
              "specialization"),
     cl::init(3));
 
 static cl::opt<unsigned>
     AvgLoopIterationCount("func-specialization-avg-iters-cost", cl::Hidden,
                           cl::desc("Average loop iteration count cost"),
                           cl::init(10));
 
+static cl::opt<bool> SpecializeConstGlobals(
+    "function-specialization-const-globals", cl::init(true), cl::Hidden,
+    cl::desc("Enable function specialization for constant globals and function "
+             "pointers"));
+
 // Helper to check if \p LV is either overdefined or a constant int.
 static bool isOverdefined(const ValueLatticeElement &LV) {
   return !LV.isUnknownOrUndef() && !LV.isConstant();
 }
 
 class FunctionSpecializer {
 
   /// The IPSCCP Solver.
for (User *U : F->users()) {
         if (!GV->getValueType()->isSingleValueType()) {
           return false;
         }
       }
 
       // Get the lattice value for the value the call site passes to the
       // argument. If this value is not constant, move on to the next call
       // site. Additionally, set the AllConstant flag to false.
       if (V != A && !Solver.getLatticeValueFor(V).isConstant()) {
         AllConstant = false;
         continue;
       }
 
-      // Add the constant to the set.
-      if (auto *C = dyn_cast<Constant>(CS.getArgOperand(A->getArgNo())))
+      // Add the constant global or function pointer to the set.
+      auto *C = dyn_cast<Constant>(CS.getArgOperand(A->getArgNo()));
+      if (C && SpecializeConstGlobals)
         Constants.push_back(C);
     }
 
     // If the argument can only take on constant values, AllConstant will be
     // true.
     return AllConstant;
   }
 

llvm/test/Transforms/FunctionSpecialization/function-specialization3.ll

 ; RUN: opt -function-specialization -func-specialization-avg-iters-cost=3 -S < %s | \
 ; RUN:   FileCheck %s --check-prefixes=COMMON,DISABLED
-; RUN: opt -function-specialization -force-function-specialization -S < %s | \
+; RUN: opt -function-specialization -force-function-specialization -function-specialization-const-globals=0 -S < %s | \
+; RUN:   FileCheck %s --check-prefixes=COMMON,DISABLED
+; RUN: opt -function-specialization -force-function-specialization -function-specialization-const-globals=1 -S < %s | \
 ; RUN:   FileCheck %s --check-prefixes=COMMON,FORCE
 ; RUN: opt -function-specialization -func-specialization-avg-iters-cost=3 -force-function-specialization -S < %s | \
 ; RUN:   FileCheck %s --check-prefixes=COMMON,FORCE
 
 ; Test for specializing a constant global.
 
 target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"