Make the hardcoded Threshold value in capture tracking configurable via a hidden option

[pcwalton]

Summary

It was found that the Rust "serde" framework benefits from higher thresholds than the default value of 20. See discussion:

    
https://github.com/rust-lang/rust/issues/45068

I discussed with @sunfish about whether it was better to make this an option or fix the TODO, but I was told that the TODO is blocked on the new pass manager, so I went with this quick fix.

Please feel free to adjust reviewers as necessary. Thank you :)

[davide]

I think this is fine for the current pass manager infrastructure. Can you please add a test?

[whitequark]

Indeed, needs a test.

lib/Analysis/CaptureTracking.cpp

 #include "llvm/IR/CallSite.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
 
 using namespace llvm;
 
+/// TODO: Write a new FunctionPass AliasAnalysis so that it can keep
+/// a cache. Then we can move the code from BasicAliasAnalysis into
+/// that path, and remove this threshold.
+static cl::opt<unsigned> Threshold(
+    "capture-tracking-threshold", cl::Hidden, cl::init(20),
+    cl::desc("The maximum number of uses that the capture tracker"
+             "will consider trying to walk past (default = 20)"));
+
 CaptureTracker::~CaptureTracker() {}
 
 bool CaptureTracker::shouldExplore(const Use *U) { return true; }
 
 namespace {
   struct SimpleCaptureTracker : public CaptureTracker {
     explicit SimpleCaptureTracker(bool ReturnCaptures)
       : ReturnCaptures(ReturnCaptures), Captured(false) {}
bool llvm::PointerMayBeCapturedBefore(const Value *V, bool ReturnCaptures,
   CapturesBefore CB(ReturnCaptures, I, DT, IncludeI, OBB);
   PointerMayBeCaptured(V, &CB);
 
   if (UseNewOBB)
     delete OBB;
   return CB.Captured;
 }
 
-/// TODO: Write a new FunctionPass AliasAnalysis so that it can keep
-/// a cache. Then we can move the code from BasicAliasAnalysis into
-/// that path, and remove this threshold.
-static int const Threshold = 20;
-
 void llvm::PointerMayBeCaptured(const Value *V, CaptureTracker *Tracker) {
   assert(V->getType()->isPointerTy() && "Capture is for pointers only!");
-  SmallVector<const Use *, Threshold> Worklist;
-  SmallSet<const Use *, Threshold> Visited;
+  SmallVector<const Use *, 20> Worklist;
+  SmallSet<const Use *, 20> Visited;
   int Count = 0;
 
   for (const Use &U : V->uses()) {
     // If there are lots of uses, conservatively say that the value
     // is captured to avoid taking too much compile time.
     if (Count++ >= Threshold)
       return Tracker->tooManyUses();