Don't print uselistorder in --print-changed

[aeubanks]

Summary

Using uselistorders is fairly niche, it shouldn't be on by default and mostly just clutters the output.

[jamieschmeiser]

As I recall, I added this in based on comments in the review and I am fine with removing it. However, the parameter to unWrapAndPrint was added to preserve existing function and if this is removed, then the parameter should also be removed as it will always be false. The parameter can be dropped from the call to print also, as it defaults to false.

[aeubanks]

address comments

[ychen]

I was suggesting this to catch non-determinism issues like the one D64866 fixed. Sounds good to me to make it off by default. Any way to make it opt-in? Making it part of API (add a field to PrintPassOptions) would be the best but it could be a follow-up patch with a FIXME added to this patch.

[aeubanks]

In D111282#3048567, @ychen wrote:

I was suggesting this to catch non-determinism issues like the one D64866 fixed. Sounds good to me to make it off by default. Any way to make it opt-in? Making it part of API (add a field to PrintPassOptions) would be the best but it could be a follow-up patch with a FIXME added to this patch.

Yeah, adding it as a separate flag sounds good if anybody needs it

[jamieschmeiser]

LGTM, thanks

llvm/lib/Passes/StandardInstrumentations.cpp

 }
 
 void printIR(raw_ostream &OS, const Function *F) {
   if (!isFunctionInPrintList(F->getName()))
     return;
   OS << *F;
 }
 
-void printIR(raw_ostream &OS, const Module *M,
-             bool ShouldPreserveUseListOrder = false) {
+void printIR(raw_ostream &OS, const Module *M) {
   if (isFunctionInPrintList("*") || forcePrintModuleIR()) {
-    M->print(OS, nullptr, ShouldPreserveUseListOrder);
+    M->print(OS, nullptr);
   } else {
     for (const auto &F : M->functions()) {
       printIR(OS, &F);
     }
   }
 }
 
 void printIR(raw_ostream &OS, const LazyCallGraph::SCC *C) {
if (any_isa<const Loop *>(IR)) {
     const Loop *L = any_cast<const Loop *>(IR);
     return isFunctionInPrintList(L->getHeader()->getParent()->getName());
   }
   llvm_unreachable("Unknown wrapped IR type");
 }
 
 /// Generic IR-printing helper that unpacks a pointer to IRUnit wrapped into
 /// llvm::Any and does actual print job.
-void unwrapAndPrint(raw_ostream &OS, Any IR,
-                    bool ShouldPreserveUseListOrder = false) {
+void unwrapAndPrint(raw_ostream &OS, Any IR) {
   if (!shouldPrintIR(IR))
     return;
 
   if (forcePrintModuleIR()) {
     auto *M = unwrapModule(IR);
     assert(M && "should have unwrapped module");
-    printIR(OS, M, ShouldPreserveUseListOrder);
+    printIR(OS, M);
     return;
   }
 
   if (any_isa<const Module *>(IR)) {
     const Module *M = any_cast<const Module *>(IR);
-    printIR(OS, M, ShouldPreserveUseListOrder);
+    printIR(OS, M);
     return;
   }
 
   if (any_isa<const Function *>(IR)) {
     const Function *F = any_cast<const Function *>(IR);
     printIR(OS, F);
     return;
   }

 
 template <typename IRUnitT>
 void TextChangeReporter<IRUnitT>::handleInitialIR(Any IR) {
   // Always print the module.
   // Unwrap and print directly to avoid filtering problems in general routines.
   auto *M = unwrapModule(IR, /*Force=*/true);
   assert(M && "Expected module to be unwrapped when forced.");
   Out << "*** IR Dump At Start ***\n";
-  M->print(Out, nullptr,
-           /*ShouldPreserveUseListOrder=*/true);
+  M->print(Out, nullptr);
 }
 
 template <typename IRUnitT>
 void TextChangeReporter<IRUnitT>::omitAfter(StringRef PassID,
                                             std::string &Name) {
   Out << formatv("*** IR Dump After {0} on {1} omitted because no change ***\n",
                  PassID, Name);
 }
void IRChangedPrinter::registerCallbacks(PassInstrumentationCallbacks &PIC) {
   if (PrintChanged == ChangePrinter::PrintChangedVerbose ||
       PrintChanged == ChangePrinter::PrintChangedQuiet)
     TextChangeReporter<std::string>::registerRequiredCallbacks(PIC);
 }
 
 void IRChangedPrinter::generateIRRepresentation(Any IR, StringRef PassID,
                                                 std::string &Output) {
   raw_string_ostream OS(Output);
-  unwrapAndPrint(OS, IR,
-                 /*ShouldPreserveUseListOrder=*/true);
+  unwrapAndPrint(OS, IR);
   OS.str();
 }
 
 void IRChangedPrinter::handleAfter(StringRef PassID, std::string &Name,
                                    const std::string &Before,
                                    const std::string &After, Any) {
   // Report the IR before the changes when requested.
   if (PrintChangedBefore)