[llvm-mca] Fix duplicate symbols error

[michaelmaitland]

Summary

Parsing instruments and analysis regions causes us to see the same
labels two times since we parse the same file twice under the same
context.

This change creates a seperate context for instrument parsing
and another for analysis region parsing. I will post a follow up
commit once I get some free cycles to parse analysis regions and
instruments in one parsing pass under a single context.

[andreadb]

LGTM. Thanks!

llvm/test/tools/llvm-mca/X86/Generic/no-duplicate-symbols.s

+# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=x86-64 < %s 2>&1 | FileCheck %s
+
+# This test checks that https://github.com/llvm/llvm-project/issues/62528 is resolved.
+foo:
+  pushq   %rbp
+
+# CHECK-NOT:      <stdin>:4:1: error: symbol 'foo' is already defined
+

llvm/tools/llvm-mca/llvm-mca.cpp

std::unique_ptr<MCAsmInfo> MAI(
       TheTarget->createMCAsmInfo(*MRI, TripleName, MCOptions));
   assert(MAI && "Unable to create target asm info!");
 
   SourceMgr SrcMgr;
 
   // Tell SrcMgr about this buffer, which is what the parser will pick up.
   SrcMgr.AddNewSourceBuffer(std::move(*BufferPtr), SMLoc());
 
-  MCContext Ctx(TheTriple, MAI.get(), MRI.get(), STI.get(), &SrcMgr);
-  std::unique_ptr<MCObjectFileInfo> MOFI(
-      TheTarget->createMCObjectFileInfo(Ctx, /*PIC=*/false));
-  Ctx.setObjectFileInfo(MOFI.get());
-
   std::unique_ptr<buffer_ostream> BOS;
 
   std::unique_ptr<MCInstrInfo> MCII(TheTarget->createMCInstrInfo());
   assert(MCII && "Unable to create instruction info!");
 
   std::unique_ptr<MCInstrAnalysis> MCIA(
       TheTarget->createMCInstrAnalysis(MCII.get()));
 
if (!IPtemp) {
     WithColor::error()
         << "unable to create instruction printer for target triple '"
         << TheTriple.normalize() << "' with assembly variant "
         << IPtempOutputAsmVariant << ".\n";
     return 1;
   }
 
   // Parse the input and create CodeRegions that llvm-mca can analyze.
-  mca::AsmAnalysisRegionGenerator CRG(*TheTarget, SrcMgr, Ctx, *MAI, *STI,
+  MCContext ACtx(TheTriple, MAI.get(), MRI.get(), STI.get(), &SrcMgr);
+  std::unique_ptr<MCObjectFileInfo> AMOFI(
+      TheTarget->createMCObjectFileInfo(ACtx, /*PIC=*/false));
+  ACtx.setObjectFileInfo(AMOFI.get());
+  mca::AsmAnalysisRegionGenerator CRG(*TheTarget, SrcMgr, ACtx, *MAI, *STI,
                                       *MCII);
   Expected<const mca::AnalysisRegions &> RegionsOrErr =
       CRG.parseAnalysisRegions(std::move(IPtemp));
   if (!RegionsOrErr) {
     if (auto Err =
             handleErrors(RegionsOrErr.takeError(), [](const StringError &E) {
               WithColor::error() << E.getMessage() << '\n';
             })) {
int main(int argc, char **argv) {
   if (!IM) {
     // If the target doesn't have its own IM implemented (or the -disable-cb
     // flag is set) then we use the base class (which does nothing).
     IM = std::make_unique<mca::InstrumentManager>(*STI, *MCII);
   }
 
   // Parse the input and create InstrumentRegion that llvm-mca
   // can use to improve analysis.
-  mca::AsmInstrumentRegionGenerator IRG(*TheTarget, SrcMgr, Ctx, *MAI, *STI,
+  MCContext ICtx(TheTriple, MAI.get(), MRI.get(), STI.get(), &SrcMgr);
+  std::unique_ptr<MCObjectFileInfo> IMOFI(
+      TheTarget->createMCObjectFileInfo(ICtx, /*PIC=*/false));
+  ICtx.setObjectFileInfo(IMOFI.get());
+  mca::AsmInstrumentRegionGenerator IRG(*TheTarget, SrcMgr, ICtx, *MAI, *STI,
                                         *MCII, *IM);
   Expected<const mca::InstrumentRegions &> InstrumentRegionsOrErr =
       IRG.parseInstrumentRegions(std::move(IPtemp));
   if (!InstrumentRegionsOrErr) {
     if (auto Err = handleErrors(InstrumentRegionsOrErr.takeError(),
                                 [](const StringError &E) {
                                   WithColor::error() << E.getMessage() << '\n';
                                 })) {
int main(int argc, char **argv) {
   mca::PipelineOptions PO(MicroOpQueue, DecoderThroughput, DispatchWidth,
                           RegisterFileSize, LoadQueueSize, StoreQueueSize,
                           AssumeNoAlias, EnableBottleneckAnalysis);
 
   // Number each region in the sequence.
   unsigned RegionIdx = 0;
 
   std::unique_ptr<MCCodeEmitter> MCE(
-      TheTarget->createMCCodeEmitter(*MCII, Ctx));
+      TheTarget->createMCCodeEmitter(*MCII, ACtx));
   assert(MCE && "Unable to create code emitter!");
 
   std::unique_ptr<MCAsmBackend> MAB(TheTarget->createMCAsmBackend(
       *STI, *MRI, mc::InitMCTargetOptionsFromFlags()));
   assert(MAB && "Unable to create asm backend!");
 
   json::Object JSONOutput;
   for (const std::unique_ptr<mca::AnalysisRegion> &Region : Regions) {