[llvm] Address base discriminator overflow in X86DiscriminateMemOps

[mtrofin]

Summary

Macros are expanded on a single line. In case of large expansions,
with sufficiently many instructions with memory operands (and when
-fdebug-info-for-profiling is requested), we may be unable to generate
new base discriminator values - new values overflow (base
discriminators may not be larger than 2^12).

This CL warns instead of asserting in such a case. A subsequent CL
will add APIs to check for overflow before creating new debug info.

See https://bugs.llvm.org/show_bug.cgi?id=39890

llvm/trunk/lib/Target/X86/X86DiscriminateMemOps.cpp

 #include "X86Subtarget.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/ProfileData/SampleProf.h"
 #include "llvm/ProfileData/SampleProfReader.h"
 #include "llvm/Transforms/IPO/SampleProfile.h"
 using namespace llvm;
 
+#define DEBUG_TYPE "x86-discriminate-memops"
+
 namespace {
 
 using Location = std::pair<StringRef, unsigned>;
 
 Location diToLocation(const DILocation *Loc) {
   return std::make_pair(Loc->getFilename(), Loc->getLine());
 }
 
for (auto &MI : MBB) {
       const std::pair<DenseSet<unsigned>::iterator, bool> TryInsert =
           Set.insert(DI->getBaseDiscriminator());
       if (!TryInsert.second) {
         DI = DI->setBaseDiscriminator(++MemOpDiscriminators[diToLocation(DI)]);
         updateDebugInfo(&MI, DI);
         Changed = true;
         const std::pair<DenseSet<unsigned>::iterator, bool> MustInsert =
             Set.insert(DI->getBaseDiscriminator());
-        (void)MustInsert; // silence warning.
-        assert(MustInsert.second &&
-               "New discriminator shouldn't be present in set");
+        // FIXME (mtrofin): check if the to-be inserted base discriminator can
+        // be added. This requires a new API on DILocation.
+        // The assumption is that this scenario is infrequent/OK not to support.
+        // If evidence points otherwise, we can explore synthesize unique DIs by
+        // adding fake line numbers.
+        if (!MustInsert.second) {
+          LLVM_DEBUG(dbgs()
+                     << "Unable to create a unique discriminator in "
+                     << DI->getFilename() << " Line: " << DI->getLine()
+                     << " Column: " << DI->getColumn()
+                     << ". This is likely due to a large macro expansion.\n");
+        }
       }
 
       // Bump the reference DI to avoid cramming discriminators on line 0.
       // FIXME(mtrofin): pin ReferenceDI on blocks or first instruction with DI
       // in a block. It's more consistent than just relying on the last memop
       // instruction we happened to see.
       ReferenceDI = DI;
     }
   }
   return Changed;
 }
 
 FunctionPass *llvm::createX86DiscriminateMemOpsPass() {
   return new X86DiscriminateMemOps();
 }