bugpoint: Add option to disable attribute removal

[arsenm]

Summary

This takes a long time and never reduces anything useful for me
(e.g. I've been waiting for 3 hours on a testcase and it hasn't found
any attributes to remove yet). This should probably start by assuming
no attributes matter, and adding back.

[efriedma]

Maybe it would be helpful to change when attribute removal runs? It would probably take a lot less time after unnecessary instructions are removed.

[arsenm]

f7b3c7f682de33704a887f74ee175375bf1eddf5

IME I often add attributes to reduce programs, so this might even be backwards

[arsenm]

This seems to be missing from upstream? I'm not sure where I pushed this

[arsenm]

Really pushed as 6f06eda070eb574ad3ad6612f037e1fab7a1f0db

test/BugPoint/func-attrs.ll

 ; RUN: bugpoint -load %llvmshlibdir/BugpointPasses%shlibext %s -output-prefix %t -bugpoint-crashfuncattr -silence-passes
-; RUN: llvm-dis %t-reduced-simplified.bc -o - | FileCheck %s
+; RUN: llvm-dis %t-reduced-simplified.bc -o - | FileCheck -check-prefixes=ALL,ENABLED %s
+; RUN: bugpoint -disable-attribute-remove -load %llvmshlibdir/BugpointPasses%shlibext %s -output-prefix %t -bugpoint-crashfuncattr -silence-passes
+; RUN: llvm-dis %t-reduced-simplified.bc -o - | FileCheck -check-prefixes=ALL,DISABLED %s
+
 ; REQUIRES: plugins
 
-; CHECK: f() #[[ATTRS:[0-9]+]]
+; ALL: f() #[[ATTRS:[0-9]+]]
 define void @f() #0 {
   ret void
 }
 
-; CHECK: attributes #[[ATTRS]] = { "bugpoint-crash" }
-attributes #0 = { noinline "bugpoint-crash" "no-frame-pointer-elim-non-leaf" }
+; ENABLED: attributes #[[ATTRS]] = { "bugpoint-crash" }
+; DISABLED: attributes #[[ATTRS]] = { noinline "bugpoint-crash" "no-frame-pointer-elim-non-leaf" }
+attributes #0 = { noinline "bugpoint-crash" "no-frame-pointer-elim-non-leaf" }
 No newline at end of file

tools/bugpoint/CrashDebugger.cpp

 namespace {
 cl::opt<bool> KeepMain("keep-main",
                        cl::desc("Force function reduction to keep main"),
                        cl::init(false));
 cl::opt<bool> NoGlobalRM("disable-global-remove",
                          cl::desc("Do not remove global variables"),
                          cl::init(false));
 
+cl::opt<bool> NoAttributeRM("disable-attribute-remove",
+                         cl::desc("Do not remove function attributes"),
+                         cl::init(false));
+
 cl::opt<bool> ReplaceFuncsWithNull(
     "replace-funcs-with-null",
     cl::desc("When stubbing functions, replace all uses will null"),
     cl::init(false));
 cl::opt<bool> DontReducePassList("disable-pass-list-reduction",
                                  cl::desc("Skip pass list reduction steps"),
                                  cl::init(false));
 
Expected<bool> Result =
         ReduceCrashingFunctions(BD, TestFn).reduceList(Functions);
     if (Error E = Result.takeError())
       return E;
 
     if (Functions.size() < OldSize)
       BD.EmitProgressBitcode(BD.getProgram(), "reduced-function");
   }
 
+  if (!NoAttributeRM) {
     // For each remaining function, try to reduce that function's attributes.
     std::vector<std::string> FunctionNames;
     for (Function &F : BD.getProgram())
       FunctionNames.push_back(F.getName());
 
     if (!FunctionNames.empty() && !BugpointIsInterrupted) {
-    outs() << "\n*** Attempting to reduce the number of function attributes in "
-              "the testcase\n";
+      outs() << "\n*** Attempting to reduce the number of function attributes"
+                " in the testcase\n";
 
       unsigned OldSize = 0;
       unsigned NewSize = 0;
       for (std::string &Name : FunctionNames) {
         Function *Fn = BD.getProgram().getFunction(Name);
         assert(Fn && "Could not find funcion?");
 
         std::vector<Attribute> Attrs;
         for (Attribute A : Fn->getAttributes().getFnAttributes())
           Attrs.push_back(A);
 
         OldSize += Attrs.size();
         Expected<bool> Result =
           ReduceCrashingFunctionAttributes(BD, Name, TestFn).reduceList(Attrs);
         if (Error E = Result.takeError())
           return E;
 
         NewSize += Attrs.size();
       }
 
       if (OldSize < NewSize)
         BD.EmitProgressBitcode(BD.getProgram(), "reduced-function-attributes");
     }
+  }
 
   // Attempt to change conditional branches into unconditional branches to
   // eliminate blocks.
   if (!DisableSimplifyCFG && !BugpointIsInterrupted) {
     std::vector<const BasicBlock *> Blocks;
     for (Function &F : BD.getProgram())
       for (BasicBlock &BB : F)
         Blocks.push_back(&BB);