[Polly] [ScopDetection] Allow passing multiple functions to `-polly-only-func`.

[bollu]

Summary

• This is useful to run optimisations on only certain functions.
• Perhaps we should change the name to -polly-only-funcs, and related names should be made plural as well [bikeshed].

[grosser]

I think we can keep the command line option, but feel free to change its description to document that multiple strings are possible.

polly/trunk/lib/Analysis/ScopDetection.cpp

 bool polly::PollyProcessUnprofitable;
 static cl::opt<bool, true> XPollyProcessUnprofitable(
     "polly-process-unprofitable",
     cl::desc(
         "Process scops that are unlikely to benefit from Polly optimizations."),
     cl::location(PollyProcessUnprofitable), cl::init(false), cl::ZeroOrMore,
     cl::cat(PollyCategory));
 
-static cl::opt<std::string> OnlyFunction(
+static cl::list<std::string> OnlyFunctions(
     "polly-only-func",
-    cl::desc("Only run on functions that contain a certain string"),
-    cl::value_desc("string"), cl::ValueRequired, cl::init(""),
-    cl::cat(PollyCategory));
+    cl::desc("Only run on functions that contain a certain string. "
+             "Multiple strings can be comma separated. "
+             "Scop detection will run on all functions that contain "
+             "any of the strings provided."),
+    cl::ZeroOrMore, cl::CommaSeparated, cl::cat(PollyCategory));
 
 static cl::opt<bool>
     AllowFullFunction("polly-detect-full-functions",
                       cl::desc("Allow the detection of full functions"),
                       cl::init(false), cl::cat(PollyCategory));
 
 static cl::opt<std::string> OnlyRegion(
     "polly-only-region",
DP << "Scop location is unknown. Compile with debug info "
           "(-g) to get more precise information. ";
     return;
   }
 
   DP << FileName << ":" << EntryLine << ": Start of scop\n";
   DP << FileName << ":" << ExitLine << ": End of scop";
 }
 
+static bool IsFnNameListedInOnlyFunctions(StringRef FnName) {
+  for (auto Name : OnlyFunctions)
+    if (FnName.count(Name) > 0)
+      return true;
+  return false;
+}
 //===----------------------------------------------------------------------===//
 // ScopDetection.
 
 ScopDetection::ScopDetection(Function &F, const DominatorTree &DT,
                              ScalarEvolution &SE, LoopInfo &LI, RegionInfo &RI,
                              AliasAnalysis &AA)
     : DT(DT), SE(SE), LI(LI), RI(RI), AA(AA) {
 
   if (!PollyProcessUnprofitable && LI.empty())
     return;
 
   Region *TopRegion = RI.getTopLevelRegion();
 
-  if (OnlyFunction != "" && !F.getName().count(OnlyFunction))
+  if (OnlyFunctions.size() > 0 && !IsFnNameListedInOnlyFunctions(F.getName()))
     return;
 
   if (!isValidFunction(F))
     return;
 
   findScops(*TopRegion);
 
   NumScopRegions += ValidRegions.size();

polly/trunk/test/ScopDetect/only_func_flag.ll

+; RUN: opt %loadPolly -polly-scops  -analyze -polly-only-func=f,g < %s | FileCheck %s
+;
+; Check that the flag `-polly-only-func` limits analysis to `f` and `g`.
+;
+; CHECK:      Function: f
+; CHECK-NEXT:    Region: %for.cond---%for.end
+;
+; CHECK:      Function: g
+; CHECK-NEXT:    Region: %for.cond---%for.end
+;
+; CHECK-NOT:      Function: h
+;
+; void f(int* sum) {
+;   for (int i = 0; i <= 100; i++)
+;     sum += i * 3;
+; }
+; void g(int* sum) {
+;   for (int i = 0; i <= 100; i++)
+;     sum += i * 3;
+; }
+; void h(int* sum) {
+;   for (int i = 0; i <= 100; i++)
+;     sum += i * 3;
+; }
+target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-n32-S64"
+
+define void @f(i32* %sum) {
+entry:
+  br label %entry.split1
+
+entry.split1:                                     ; preds = %entry
+  br label %entry.split
+
+entry.split:                                      ; preds = %entry.split1
+  br label %for.cond
+
+for.cond:                                         ; preds = %for.cond, %entry.split
+  %i1.0 = phi i32 [ 0, %entry.split ], [ %inc, %for.cond ]
+  %sum.reload = load i32, i32* %sum
+  %mul = mul nsw i32 %i1.0, 3
+  %add = add nsw i32 %sum.reload, %mul
+  %inc = add nsw i32 %i1.0, 1
+  store i32 %add, i32* %sum
+  %cmp = icmp slt i32 %i1.0, 100
+  br i1 %cmp, label %for.cond, label %for.end
+
+for.end:                                          ; preds = %for.cond
+  ret void
+}
+
+
+define void @g(i32* %sum) {
+entry:
+  br label %entry.split1
+
+entry.split1:                                     ; preds = %entry
+  br label %entry.split
+
+entry.split:                                      ; preds = %entry.split1
+  br label %for.cond
+
+for.cond:                                         ; preds = %for.cond, %entry.split
+  %i1.0 = phi i32 [ 0, %entry.split ], [ %inc, %for.cond ]
+  %sum.reload = load i32, i32* %sum
+  %mul = mul nsw i32 %i1.0, 3
+  %add = add nsw i32 %sum.reload, %mul
+  %inc = add nsw i32 %i1.0, 1
+  store i32 %add, i32* %sum
+  %cmp = icmp slt i32 %i1.0, 100
+  br i1 %cmp, label %for.cond, label %for.end
+
+for.end:                                          ; preds = %for.cond
+  ret void
+}
+
+
+define void @h(i32* %sum) {
+entry:
+  br label %entry.split1
+
+entry.split1:                                     ; preds = %entry
+  br label %entry.split
+
+entry.split:                                      ; preds = %entry.split1
+  br label %for.cond
+
+for.cond:                                         ; preds = %for.cond, %entry.split
+  %i1.0 = phi i32 [ 0, %entry.split ], [ %inc, %for.cond ]
+  %sum.reload = load i32, i32* %sum
+  %mul = mul nsw i32 %i1.0, 3
+  %add = add nsw i32 %sum.reload, %mul
+  %inc = add nsw i32 %i1.0, 1
+  store i32 %add, i32* %sum
+  %cmp = icmp slt i32 %i1.0, 100
+  br i1 %cmp, label %for.cond, label %for.end
+
+for.end:                                          ; preds = %for.cond
+  ret void
+}
+