[PGO] Make negative pgo-warn-mismatch{,-comdat} options positive `-pgo-warn-mismatch=false` replaces `-no-pgo-warn-mismatch=false`.

llvm/lib/LTO/LTOBackend.cpp

static cl::opt<LTOBitcodeEmbedding> EmbedBitcode(
     cl::desc("Embed LLVM bitcode in object files produced by LTO"));
 
 static cl::opt<bool> ThinLTOAssumeMerged(
     "thinlto-assume-merged", cl::init(false),
     cl::desc("Assume the input has already undergone ThinLTO function "
              "importing and the other pre-optimization pipeline changes."));
 
 namespace llvm {
-extern cl::opt<bool> NoPGOWarnMismatch;
+extern cl::opt<bool> PGOWarnMismatch;
 }
 
 [[noreturn]] static void reportOpenError(StringRef Path, Twine Msg) {
   errs() << "failed to open " << Path << ": " << Msg << '\n';
   errs().flush();
   exit(1);
 }
 
static void runNewPMPasses(const Config &Conf, Module &Mod, TargetMachine *TM,
   else if (Conf.RunCSIRInstr) {
     PGOOpt = PGOOptions("", Conf.CSIRProfile, Conf.ProfileRemapping,
                         PGOOptions::IRUse, PGOOptions::CSIRInstr,
                         Conf.AddFSDiscriminator);
   } else if (!Conf.CSIRProfile.empty()) {
     PGOOpt = PGOOptions(Conf.CSIRProfile, "", Conf.ProfileRemapping,
                         PGOOptions::IRUse, PGOOptions::CSIRUse,
                         Conf.AddFSDiscriminator);
-    NoPGOWarnMismatch = !Conf.PGOWarnMismatch;
+    PGOWarnMismatch = Conf.PGOWarnMismatch;
   } else if (Conf.AddFSDiscriminator) {
     PGOOpt = PGOOptions("", "", "", PGOOptions::NoAction,
                         PGOOptions::NoCSAction, true);
   }
 
   LoopAnalysisManager LAM;
   FunctionAnalysisManager FAM;
   CGSCCAnalysisManager CGAM;

llvm/lib/Transforms/Instrumentation/PGOInstrumentation.cpp

static cl::opt<bool>
     PGOWarnMissing("pgo-warn-missing-function", cl::init(false), cl::Hidden,
                    cl::desc("Use this option to turn on/off "
                             "warnings about missing profile data for "
                             "functions."));
 
 namespace llvm {
 // Command line option to enable/disable the warning about a hash mismatch in
 // the profile data.
-cl::opt<bool>
-    NoPGOWarnMismatch("no-pgo-warn-mismatch", cl::init(false), cl::Hidden,
-                      cl::desc("Use this option to turn off/on "
-                               "warnings about profile cfg mismatch."));
+cl::opt<bool> PGOWarnMismatch("pgo-warn-mismatch", cl::init(true), cl::Hidden,
+                              cl::desc("Warn about profile cfg mismatch"));
 } // namespace llvm
 
 // Command line option to enable/disable the warning about a hash mismatch in
 // the profile data for Comdat functions, which often turns out to be false
 // positive due to the pre-instrumentation inline.
 static cl::opt<bool>
-    NoPGOWarnMismatchComdat("no-pgo-warn-mismatch-comdat", cl::init(true),
-                            cl::Hidden,
-                            cl::desc("The option is used to turn on/off "
-                                     "warnings about hash mismatch for comdat "
-                                     "functions."));
+    PGOWarnMismatchComdat("pgo-warn-mismatch-comdat", cl::init(false),
+                          cl::desc("Warn about hash mismatch for comdat "
+                                   "functions"));
 
 // Command line option to enable/disable select instruction instrumentation.
 static cl::opt<bool>
     PGOInstrSelect("pgo-instr-select", cl::init(true), cl::Hidden,
                    cl::desc("Use this option to turn on/off SELECT "
                             "instruction instrumentation. "));
 
 // Command line option to turn on CFG dot or text dump of raw profile counts
handleAllErrors(std::move(E), [&](const InstrProfError &IPE) {
       if (Err == instrprof_error::unknown_function) {
         IsCS ? NumOfCSPGOMissing++ : NumOfPGOMissing++;
         SkipWarning = !PGOWarnMissing;
         LLVM_DEBUG(dbgs() << "unknown function");
       } else if (Err == instrprof_error::hash_mismatch ||
                  Err == instrprof_error::malformed) {
         IsCS ? NumOfCSPGOMismatch++ : NumOfPGOMismatch++;
         SkipWarning =
-            NoPGOWarnMismatch ||
-            (NoPGOWarnMismatchComdat &&
+            !PGOWarnMismatch ||
+            (!PGOWarnMismatchComdat &&
              (F.hasComdat() ||
               F.getLinkage() == GlobalValue::AvailableExternallyLinkage));
         LLVM_DEBUG(dbgs() << "hash mismatch (skip=" << SkipWarning << ")");
         // Emit function metadata indicating PGO profile mismatch.
         annotateFunctionWithHashMismatch(F, M->getContext());
       }
 
       LLVM_DEBUG(dbgs() << " IsCS=" << IsCS << "\n");