[bugpoint] Clean up type names at the very end

[loladiro]

Summary

When we roundtrip through bitcode, type names end up duplicated, so
types get renamed, causing very long chains of numbers at the end.
We could fix this by using a separate context for each step, but that
is a decently large change, and would also be slower. Instead, just
insert a post process step to try to rename types to something shorter.

[jeroen.dobbelaere]

Any chance an updated version of this improvement can be added to bugpoint ?

tools/bugpoint/CrashDebugger.cpp

if (InstructionsToSkipBeforeDeleting) {
       goto TryAgain;
     }
 
   } while (Simplification);
   BD.EmitProgressBitcode(BD.getProgram(), "reduced-instructions");
   return Error::success();
 }
 
+static void DoTypeNameCleanup(Module *M) {
+  // When we roundtrip types through bitcode, those end up being not unique,
+  // so they get renamed, causing really long chains of type.123.234.342.etc.
+  // Instead of this, find the part of the name that is not just numbers and use
+  // that as the type name.
+  std::vector<StructType *> Types = M->getIdentifiedStructTypes();
+  for (StructType *T : Types) {
+    StringRef Name = T->getName();
+    // Count the number of characters that are either dots or numbers from the
+    // end.
+    const uint8_t *cur, *end;
+    cur = end = Name.bytes_end() - 1;
+    while (cur > Name.bytes_begin() && (*cur == '.' || isdigit(*cur)))
+      --cur;
+    T->setName(Name.drop_back(end - cur));
+  }
+}
+
 /// DebugACrash - Given a predicate that determines whether a component crashes
 /// on a program, try to destructively reduce the program while still keeping
 /// the predicate true.
 static Error DebugACrash(BugDriver &BD,
                          bool (*TestFn)(const BugDriver &, Module *)) {
   // See if we can get away with nuking some of the global variable initializers
   // in the program...
   if (!NoGlobalRM)
static Error DebugACrash(BugDriver &BD,
   if (!BugpointIsInterrupted) {
     outs() << "\n*** Attempting to perform final cleanups: ";
     Module *M = CloneModule(BD.getProgram()).release();
     M = BD.performFinalCleanups(M, true).release();
 
     // Find out if the pass still crashes on the cleaned up program...
     if (TestFn(BD, M)) {
       BD.setNewProgram(M); // Yup, it does, keep the reduced version...
+
+      // Bugpoints makes a mess of type names. Try to clean them up.
+      DoTypeNameCleanup(M);
+
+      // In principle something could depend on names, I suppose
+      if (!TestFn(BD, M)) {
+        return make_error<StringError>("Cleaning up type names hides bug",
+                                       inconvertibleErrorCode());
+      }
     } else {
       delete M;
     }
   }
 
   BD.EmitProgressBitcode(BD.getProgram(), "reduced-simplified");
 
   return Error::success();