1 //===-- llvm-mca.cpp - Machine Code Analyzer -------------------*- C++ -* -===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This utility is a simple driver that allows static performance analysis on 10 // machine code similarly to how IACA (Intel Architecture Code Analyzer) works. 11 // 12 // llvm-mca [options] <file-name> 13 // -march <type> 14 // -mcpu <cpu> 15 // -o <file> 16 // 17 // The target defaults to the host target. 18 // The cpu defaults to the 'native' host cpu. 19 // The output defaults to standard output. 20 // 21 //===----------------------------------------------------------------------===// 22 23 #include "CodeRegion.h" 24 #include "CodeRegionGenerator.h" 25 #include "PipelinePrinter.h" 26 #include "Views/BottleneckAnalysis.h" 27 #include "Views/DispatchStatistics.h" 28 #include "Views/InstructionInfoView.h" 29 #include "Views/RegisterFileStatistics.h" 30 #include "Views/ResourcePressureView.h" 31 #include "Views/RetireControlUnitStatistics.h" 32 #include "Views/SchedulerStatistics.h" 33 #include "Views/SummaryView.h" 34 #include "Views/TimelineView.h" 35 #include "llvm/MC/MCAsmBackend.h" 36 #include "llvm/MC/MCAsmInfo.h" 37 #include "llvm/MC/MCCodeEmitter.h" 38 #include "llvm/MC/MCContext.h" 39 #include "llvm/MC/MCObjectFileInfo.h" 40 #include "llvm/MC/MCRegisterInfo.h" 41 #include "llvm/MC/MCSubtargetInfo.h" 42 #include "llvm/MC/MCTargetOptionsCommandFlags.h" 43 #include "llvm/MC/TargetRegistry.h" 44 #include "llvm/MCA/CodeEmitter.h" 45 #include "llvm/MCA/Context.h" 46 #include "llvm/MCA/CustomBehaviour.h" 47 #include "llvm/MCA/InstrBuilder.h" 48 #include "llvm/MCA/Pipeline.h" 49 #include "llvm/MCA/Stages/EntryStage.h" 50 #include "llvm/MCA/Stages/InstructionTables.h" 51 #include "llvm/MCA/Support.h" 52 #include "llvm/Support/CommandLine.h" 53 #include "llvm/Support/ErrorHandling.h" 54 #include "llvm/Support/ErrorOr.h" 55 #include "llvm/Support/FileSystem.h" 56 #include "llvm/Support/InitLLVM.h" 57 #include "llvm/Support/MemoryBuffer.h" 58 #include "llvm/Support/SourceMgr.h" 59 #include "llvm/Support/TargetSelect.h" 60 #include "llvm/Support/ToolOutputFile.h" 61 #include "llvm/Support/WithColor.h" 62 #include "llvm/TargetParser/Host.h" 63 64 using namespace llvm; 65 66 static mc::RegisterMCTargetOptionsFlags MOF; 67 68 static cl::OptionCategory ToolOptions("Tool Options"); 69 static cl::OptionCategory ViewOptions("View Options"); 70 71 static cl::opt<std::string> InputFilename(cl::Positional, 72 cl::desc("<input file>"), 73 cl::cat(ToolOptions), cl::init("-")); 74 75 static cl::opt<std::string> OutputFilename("o", cl::desc("Output filename"), 76 cl::init("-"), cl::cat(ToolOptions), 77 cl::value_desc("filename")); 78 79 static cl::opt<std::string> 80 ArchName("march", 81 cl::desc("Target architecture. " 82 "See -version for available targets"), 83 cl::cat(ToolOptions)); 84 85 static cl::opt<std::string> 86 TripleName("mtriple", 87 cl::desc("Target triple. See -version for available targets"), 88 cl::cat(ToolOptions)); 89 90 static cl::opt<std::string> 91 MCPU("mcpu", 92 cl::desc("Target a specific cpu type (-mcpu=help for details)"), 93 cl::value_desc("cpu-name"), cl::cat(ToolOptions), cl::init("native")); 94 95 static cl::list<std::string> 96 MATTRS("mattr", cl::CommaSeparated, 97 cl::desc("Target specific attributes (-mattr=help for details)"), 98 cl::value_desc("a1,+a2,-a3,..."), cl::cat(ToolOptions)); 99 100 static cl::opt<bool> PrintJson("json", 101 cl::desc("Print the output in json format"), 102 cl::cat(ToolOptions), cl::init(false)); 103 104 static cl::opt<int> 105 OutputAsmVariant("output-asm-variant", 106 cl::desc("Syntax variant to use for output printing"), 107 cl::cat(ToolOptions), cl::init(-1)); 108 109 static cl::opt<bool> 110 PrintImmHex("print-imm-hex", cl::cat(ToolOptions), cl::init(false), 111 cl::desc("Prefer hex format when printing immediate values")); 112 113 static cl::opt<unsigned> Iterations("iterations", 114 cl::desc("Number of iterations to run"), 115 cl::cat(ToolOptions), cl::init(0)); 116 117 static cl::opt<unsigned> 118 DispatchWidth("dispatch", cl::desc("Override the processor dispatch width"), 119 cl::cat(ToolOptions), cl::init(0)); 120 121 static cl::opt<unsigned> 122 RegisterFileSize("register-file-size", 123 cl::desc("Maximum number of physical registers which can " 124 "be used for register mappings"), 125 cl::cat(ToolOptions), cl::init(0)); 126 127 static cl::opt<unsigned> 128 MicroOpQueue("micro-op-queue-size", cl::Hidden, 129 cl::desc("Number of entries in the micro-op queue"), 130 cl::cat(ToolOptions), cl::init(0)); 131 132 static cl::opt<unsigned> 133 DecoderThroughput("decoder-throughput", cl::Hidden, 134 cl::desc("Maximum throughput from the decoders " 135 "(instructions per cycle)"), 136 cl::cat(ToolOptions), cl::init(0)); 137 138 static cl::opt<bool> 139 PrintRegisterFileStats("register-file-stats", 140 cl::desc("Print register file statistics"), 141 cl::cat(ViewOptions), cl::init(false)); 142 143 static cl::opt<bool> PrintDispatchStats("dispatch-stats", 144 cl::desc("Print dispatch statistics"), 145 cl::cat(ViewOptions), cl::init(false)); 146 147 static cl::opt<bool> 148 PrintSummaryView("summary-view", cl::Hidden, 149 cl::desc("Print summary view (enabled by default)"), 150 cl::cat(ViewOptions), cl::init(true)); 151 152 static cl::opt<bool> PrintSchedulerStats("scheduler-stats", 153 cl::desc("Print scheduler statistics"), 154 cl::cat(ViewOptions), cl::init(false)); 155 156 static cl::opt<bool> 157 PrintRetireStats("retire-stats", 158 cl::desc("Print retire control unit statistics"), 159 cl::cat(ViewOptions), cl::init(false)); 160 161 static cl::opt<bool> PrintResourcePressureView( 162 "resource-pressure", 163 cl::desc("Print the resource pressure view (enabled by default)"), 164 cl::cat(ViewOptions), cl::init(true)); 165 166 static cl::opt<bool> PrintTimelineView("timeline", 167 cl::desc("Print the timeline view"), 168 cl::cat(ViewOptions), cl::init(false)); 169 170 static cl::opt<unsigned> TimelineMaxIterations( 171 "timeline-max-iterations", 172 cl::desc("Maximum number of iterations to print in timeline view"), 173 cl::cat(ViewOptions), cl::init(0)); 174 175 static cl::opt<unsigned> 176 TimelineMaxCycles("timeline-max-cycles", 177 cl::desc("Maximum number of cycles in the timeline view, " 178 "or 0 for unlimited. Defaults to 80 cycles"), 179 cl::cat(ViewOptions), cl::init(80)); 180 181 static cl::opt<bool> 182 AssumeNoAlias("noalias", 183 cl::desc("If set, assume that loads and stores do not alias"), 184 cl::cat(ToolOptions), cl::init(true)); 185 186 static cl::opt<unsigned> LoadQueueSize("lqueue", 187 cl::desc("Size of the load queue"), 188 cl::cat(ToolOptions), cl::init(0)); 189 190 static cl::opt<unsigned> StoreQueueSize("squeue", 191 cl::desc("Size of the store queue"), 192 cl::cat(ToolOptions), cl::init(0)); 193 194 static cl::opt<bool> 195 PrintInstructionTables("instruction-tables", 196 cl::desc("Print instruction tables"), 197 cl::cat(ToolOptions), cl::init(false)); 198 199 static cl::opt<bool> PrintInstructionInfoView( 200 "instruction-info", 201 cl::desc("Print the instruction info view (enabled by default)"), 202 cl::cat(ViewOptions), cl::init(true)); 203 204 static cl::opt<bool> EnableAllStats("all-stats", 205 cl::desc("Print all hardware statistics"), 206 cl::cat(ViewOptions), cl::init(false)); 207 208 static cl::opt<bool> 209 EnableAllViews("all-views", 210 cl::desc("Print all views including hardware statistics"), 211 cl::cat(ViewOptions), cl::init(false)); 212 213 static cl::opt<bool> EnableBottleneckAnalysis( 214 "bottleneck-analysis", 215 cl::desc("Enable bottleneck analysis (disabled by default)"), 216 cl::cat(ViewOptions), cl::init(false)); 217 218 static cl::opt<bool> ShowEncoding( 219 "show-encoding", 220 cl::desc("Print encoding information in the instruction info view"), 221 cl::cat(ViewOptions), cl::init(false)); 222 223 static cl::opt<bool> ShowBarriers( 224 "show-barriers", 225 cl::desc("Print memory barrier information in the instruction info view"), 226 cl::cat(ViewOptions), cl::init(false)); 227 228 static cl::opt<bool> DisableCustomBehaviour( 229 "disable-cb", 230 cl::desc( 231 "Disable custom behaviour (use the default class which does nothing)."), 232 cl::cat(ViewOptions), cl::init(false)); 233 234 static cl::opt<bool> DisableInstrumentManager( 235 "disable-im", 236 cl::desc("Disable instrumentation manager (use the default class which " 237 "ignores instruments.)."), 238 cl::cat(ViewOptions), cl::init(false)); 239 240 namespace { 241 242 const Target *getTarget(const char *ProgName) { 243 if (TripleName.empty()) 244 TripleName = Triple::normalize(sys::getDefaultTargetTriple()); 245 Triple TheTriple(TripleName); 246 247 // Get the target specific parser. 248 std::string Error; 249 const Target *TheTarget = 250 TargetRegistry::lookupTarget(ArchName, TheTriple, Error); 251 if (!TheTarget) { 252 errs() << ProgName << ": " << Error; 253 return nullptr; 254 } 255 256 // Update TripleName with the updated triple from the target lookup. 257 TripleName = TheTriple.str(); 258 259 // Return the found target. 260 return TheTarget; 261 } 262 263 ErrorOr<std::unique_ptr<ToolOutputFile>> getOutputStream() { 264 if (OutputFilename == "") 265 OutputFilename = "-"; 266 std::error_code EC; 267 auto Out = std::make_unique<ToolOutputFile>(OutputFilename, EC, 268 sys::fs::OF_TextWithCRLF); 269 if (!EC) 270 return std::move(Out); 271 return EC; 272 } 273 } // end of anonymous namespace 274 275 static void processOptionImpl(cl::opt<bool> &O, const cl::opt<bool> &Default) { 276 if (!O.getNumOccurrences() || O.getPosition() < Default.getPosition()) 277 O = Default.getValue(); 278 } 279 280 static void processViewOptions(bool IsOutOfOrder) { 281 if (!EnableAllViews.getNumOccurrences() && 282 !EnableAllStats.getNumOccurrences()) 283 return; 284 285 if (EnableAllViews.getNumOccurrences()) { 286 processOptionImpl(PrintSummaryView, EnableAllViews); 287 if (IsOutOfOrder) 288 processOptionImpl(EnableBottleneckAnalysis, EnableAllViews); 289 processOptionImpl(PrintResourcePressureView, EnableAllViews); 290 processOptionImpl(PrintTimelineView, EnableAllViews); 291 processOptionImpl(PrintInstructionInfoView, EnableAllViews); 292 } 293 294 const cl::opt<bool> &Default = 295 EnableAllViews.getPosition() < EnableAllStats.getPosition() 296 ? EnableAllStats 297 : EnableAllViews; 298 processOptionImpl(PrintRegisterFileStats, Default); 299 processOptionImpl(PrintDispatchStats, Default); 300 processOptionImpl(PrintSchedulerStats, Default); 301 if (IsOutOfOrder) 302 processOptionImpl(PrintRetireStats, Default); 303 } 304 305 // Returns true on success. 306 static bool runPipeline(mca::Pipeline &P) { 307 // Handle pipeline errors here. 308 Expected<unsigned> Cycles = P.run(); 309 if (!Cycles) { 310 WithColor::error() << toString(Cycles.takeError()); 311 return false; 312 } 313 return true; 314 } 315 316 int main(int argc, char **argv) { 317 InitLLVM X(argc, argv); 318 319 // Initialize targets and assembly parsers. 320 InitializeAllTargetInfos(); 321 InitializeAllTargetMCs(); 322 InitializeAllAsmParsers(); 323 InitializeAllTargetMCAs(); 324 325 // Register the Target and CPU printer for --version. 326 cl::AddExtraVersionPrinter(sys::printDefaultTargetAndDetectedCPU); 327 328 // Enable printing of available targets when flag --version is specified. 329 cl::AddExtraVersionPrinter(TargetRegistry::printRegisteredTargetsForVersion); 330 331 cl::HideUnrelatedOptions({&ToolOptions, &ViewOptions}); 332 333 // Parse flags and initialize target options. 334 cl::ParseCommandLineOptions(argc, argv, 335 "llvm machine code performance analyzer.\n"); 336 337 // Get the target from the triple. If a triple is not specified, then select 338 // the default triple for the host. If the triple doesn't correspond to any 339 // registered target, then exit with an error message. 340 const char *ProgName = argv[0]; 341 const Target *TheTarget = getTarget(ProgName); 342 if (!TheTarget) 343 return 1; 344 345 // GetTarget() may replaced TripleName with a default triple. 346 // For safety, reconstruct the Triple object. 347 Triple TheTriple(TripleName); 348 349 ErrorOr<std::unique_ptr<MemoryBuffer>> BufferPtr = 350 MemoryBuffer::getFileOrSTDIN(InputFilename); 351 if (std::error_code EC = BufferPtr.getError()) { 352 WithColor::error() << InputFilename << ": " << EC.message() << '\n'; 353 return 1; 354 } 355 356 if (MCPU == "native") 357 MCPU = std::string(llvm::sys::getHostCPUName()); 358 359 // Package up features to be passed to target/subtarget 360 std::string FeaturesStr; 361 if (MATTRS.size()) { 362 SubtargetFeatures Features; 363 for (std::string &MAttr : MATTRS) 364 Features.AddFeature(MAttr); 365 FeaturesStr = Features.getString(); 366 } 367 368 std::unique_ptr<MCSubtargetInfo> STI( 369 TheTarget->createMCSubtargetInfo(TripleName, MCPU, FeaturesStr)); 370 assert(STI && "Unable to create subtarget info!"); 371 if (!STI->isCPUStringValid(MCPU)) 372 return 1; 373 374 if (!STI->getSchedModel().hasInstrSchedModel()) { 375 WithColor::error() 376 << "unable to find instruction-level scheduling information for" 377 << " target triple '" << TheTriple.normalize() << "' and cpu '" << MCPU 378 << "'.\n"; 379 380 if (STI->getSchedModel().InstrItineraries) 381 WithColor::note() 382 << "cpu '" << MCPU << "' provides itineraries. However, " 383 << "instruction itineraries are currently unsupported.\n"; 384 return 1; 385 } 386 387 // Apply overrides to llvm-mca specific options. 388 bool IsOutOfOrder = STI->getSchedModel().isOutOfOrder(); 389 processViewOptions(IsOutOfOrder); 390 391 std::unique_ptr<MCRegisterInfo> MRI(TheTarget->createMCRegInfo(TripleName)); 392 assert(MRI && "Unable to create target register info!"); 393 394 MCTargetOptions MCOptions = mc::InitMCTargetOptionsFromFlags(); 395 std::unique_ptr<MCAsmInfo> MAI( 396 TheTarget->createMCAsmInfo(*MRI, TripleName, MCOptions)); 397 assert(MAI && "Unable to create target asm info!"); 398 399 SourceMgr SrcMgr; 400 401 // Tell SrcMgr about this buffer, which is what the parser will pick up. 402 SrcMgr.AddNewSourceBuffer(std::move(*BufferPtr), SMLoc()); 403 404 std::unique_ptr<buffer_ostream> BOS; 405 406 std::unique_ptr<MCInstrInfo> MCII(TheTarget->createMCInstrInfo()); 407 assert(MCII && "Unable to create instruction info!"); 408 409 std::unique_ptr<MCInstrAnalysis> MCIA( 410 TheTarget->createMCInstrAnalysis(MCII.get())); 411 412 // Need to initialize an MCInstPrinter as it is 413 // required for initializing the MCTargetStreamer 414 // which needs to happen within the CRG.parseAnalysisRegions() call below. 415 // Without an MCTargetStreamer, certain assembly directives can trigger a 416 // segfault. (For example, the .cv_fpo_proc directive on x86 will segfault if 417 // we don't initialize the MCTargetStreamer.) 418 unsigned IPtempOutputAsmVariant = 419 OutputAsmVariant == -1 ? 0 : OutputAsmVariant; 420 std::unique_ptr<MCInstPrinter> IPtemp(TheTarget->createMCInstPrinter( 421 Triple(TripleName), IPtempOutputAsmVariant, *MAI, *MCII, *MRI)); 422 if (!IPtemp) { 423 WithColor::error() 424 << "unable to create instruction printer for target triple '" 425 << TheTriple.normalize() << "' with assembly variant " 426 << IPtempOutputAsmVariant << ".\n"; 427 return 1; 428 } 429 430 // Parse the input and create CodeRegions that llvm-mca can analyze. 431 MCContext ACtx(TheTriple, MAI.get(), MRI.get(), STI.get(), &SrcMgr); 432 std::unique_ptr<MCObjectFileInfo> AMOFI( 433 TheTarget->createMCObjectFileInfo(ACtx, /*PIC=*/false)); 434 ACtx.setObjectFileInfo(AMOFI.get()); 435 mca::AsmAnalysisRegionGenerator CRG(*TheTarget, SrcMgr, ACtx, *MAI, *STI, 436 *MCII); 437 Expected<const mca::AnalysisRegions &> RegionsOrErr = 438 CRG.parseAnalysisRegions(std::move(IPtemp)); 439 if (!RegionsOrErr) { 440 if (auto Err = 441 handleErrors(RegionsOrErr.takeError(), [](const StringError &E) { 442 WithColor::error() << E.getMessage() << '\n'; 443 })) { 444 // Default case. 445 WithColor::error() << toString(std::move(Err)) << '\n'; 446 } 447 return 1; 448 } 449 const mca::AnalysisRegions &Regions = *RegionsOrErr; 450 451 // Early exit if errors were found by the code region parsing logic. 452 if (!Regions.isValid()) 453 return 1; 454 455 if (Regions.empty()) { 456 WithColor::error() << "no assembly instructions found.\n"; 457 return 1; 458 } 459 460 std::unique_ptr<mca::InstrumentManager> IM; 461 if (!DisableInstrumentManager) { 462 IM = std::unique_ptr<mca::InstrumentManager>( 463 TheTarget->createInstrumentManager(*STI, *MCII)); 464 } 465 if (!IM) { 466 // If the target doesn't have its own IM implemented (or the -disable-cb 467 // flag is set) then we use the base class (which does nothing). 468 IM = std::make_unique<mca::InstrumentManager>(*STI, *MCII); 469 } 470 471 // Parse the input and create InstrumentRegion that llvm-mca 472 // can use to improve analysis. 473 MCContext ICtx(TheTriple, MAI.get(), MRI.get(), STI.get(), &SrcMgr); 474 std::unique_ptr<MCObjectFileInfo> IMOFI( 475 TheTarget->createMCObjectFileInfo(ICtx, /*PIC=*/false)); 476 ICtx.setObjectFileInfo(IMOFI.get()); 477 mca::AsmInstrumentRegionGenerator IRG(*TheTarget, SrcMgr, ICtx, *MAI, *STI, 478 *MCII, *IM); 479 Expected<const mca::InstrumentRegions &> InstrumentRegionsOrErr = 480 IRG.parseInstrumentRegions(std::move(IPtemp)); 481 if (!InstrumentRegionsOrErr) { 482 if (auto Err = handleErrors(InstrumentRegionsOrErr.takeError(), 483 [](const StringError &E) { 484 WithColor::error() << E.getMessage() << '\n'; 485 })) { 486 // Default case. 487 WithColor::error() << toString(std::move(Err)) << '\n'; 488 } 489 return 1; 490 } 491 const mca::InstrumentRegions &InstrumentRegions = *InstrumentRegionsOrErr; 492 493 // Early exit if errors were found by the instrumentation parsing logic. 494 if (!InstrumentRegions.isValid()) 495 return 1; 496 497 // Now initialize the output file. 498 auto OF = getOutputStream(); 499 if (std::error_code EC = OF.getError()) { 500 WithColor::error() << EC.message() << '\n'; 501 return 1; 502 } 503 504 unsigned AssemblerDialect = CRG.getAssemblerDialect(); 505 if (OutputAsmVariant >= 0) 506 AssemblerDialect = static_cast<unsigned>(OutputAsmVariant); 507 std::unique_ptr<MCInstPrinter> IP(TheTarget->createMCInstPrinter( 508 Triple(TripleName), AssemblerDialect, *MAI, *MCII, *MRI)); 509 if (!IP) { 510 WithColor::error() 511 << "unable to create instruction printer for target triple '" 512 << TheTriple.normalize() << "' with assembly variant " 513 << AssemblerDialect << ".\n"; 514 return 1; 515 } 516 517 // Set the display preference for hex vs. decimal immediates. 518 IP->setPrintImmHex(PrintImmHex); 519 520 std::unique_ptr<ToolOutputFile> TOF = std::move(*OF); 521 522 const MCSchedModel &SM = STI->getSchedModel(); 523 524 std::unique_ptr<mca::InstrPostProcess> IPP; 525 if (!DisableCustomBehaviour) { 526 // TODO: It may be a good idea to separate CB and IPP so that they can 527 // be used independently of each other. What I mean by this is to add 528 // an extra command-line arg --disable-ipp so that CB and IPP can be 529 // toggled without needing to toggle both of them together. 530 IPP = std::unique_ptr<mca::InstrPostProcess>( 531 TheTarget->createInstrPostProcess(*STI, *MCII)); 532 } 533 if (!IPP) { 534 // If the target doesn't have its own IPP implemented (or the -disable-cb 535 // flag is set) then we use the base class (which does nothing). 536 IPP = std::make_unique<mca::InstrPostProcess>(*STI, *MCII); 537 } 538 539 // Create an instruction builder. 540 mca::InstrBuilder IB(*STI, *MCII, *MRI, MCIA.get(), *IM); 541 542 // Create a context to control ownership of the pipeline hardware. 543 mca::Context MCA(*MRI, *STI); 544 545 mca::PipelineOptions PO(MicroOpQueue, DecoderThroughput, DispatchWidth, 546 RegisterFileSize, LoadQueueSize, StoreQueueSize, 547 AssumeNoAlias, EnableBottleneckAnalysis); 548 549 // Number each region in the sequence. 550 unsigned RegionIdx = 0; 551 552 std::unique_ptr<MCCodeEmitter> MCE( 553 TheTarget->createMCCodeEmitter(*MCII, ACtx)); 554 assert(MCE && "Unable to create code emitter!"); 555 556 std::unique_ptr<MCAsmBackend> MAB(TheTarget->createMCAsmBackend( 557 *STI, *MRI, mc::InitMCTargetOptionsFromFlags())); 558 assert(MAB && "Unable to create asm backend!"); 559 560 json::Object JSONOutput; 561 for (const std::unique_ptr<mca::AnalysisRegion> &Region : Regions) { 562 // Skip empty code regions. 563 if (Region->empty()) 564 continue; 565 566 IB.clear(); 567 568 // Lower the MCInst sequence into an mca::Instruction sequence. 569 ArrayRef<MCInst> Insts = Region->getInstructions(); 570 mca::CodeEmitter CE(*STI, *MAB, *MCE, Insts); 571 572 IPP->resetState(); 573 574 DenseMap<const MCInst *, SmallVector<mca::Instrument *>> 575 InstToInstruments; 576 SmallVector<std::unique_ptr<mca::Instruction>> LoweredSequence; 577 for (const MCInst &MCI : Insts) { 578 SMLoc Loc = MCI.getLoc(); 579 const SmallVector<mca::Instrument *> Instruments = 580 InstrumentRegions.getActiveInstruments(Loc); 581 InstToInstruments.insert({&MCI, Instruments}); 582 583 Expected<std::unique_ptr<mca::Instruction>> Inst = 584 IB.createInstruction(MCI, Instruments); 585 if (!Inst) { 586 if (auto NewE = handleErrors( 587 Inst.takeError(), 588 [&IP, &STI](const mca::InstructionError<MCInst> &IE) { 589 std::string InstructionStr; 590 raw_string_ostream SS(InstructionStr); 591 WithColor::error() << IE.Message << '\n'; 592 IP->printInst(&IE.Inst, 0, "", *STI, SS); 593 SS.flush(); 594 WithColor::note() 595 << "instruction: " << InstructionStr << '\n'; 596 })) { 597 // Default case. 598 WithColor::error() << toString(std::move(NewE)); 599 } 600 return 1; 601 } 602 603 IPP->postProcessInstruction(Inst.get(), MCI); 604 605 LoweredSequence.emplace_back(std::move(Inst.get())); 606 } 607 608 mca::CircularSourceMgr S(LoweredSequence, 609 PrintInstructionTables ? 1 : Iterations); 610 611 if (PrintInstructionTables) { 612 // Create a pipeline, stages, and a printer. 613 auto P = std::make_unique<mca::Pipeline>(); 614 P->appendStage(std::make_unique<mca::EntryStage>(S)); 615 P->appendStage(std::make_unique<mca::InstructionTables>(SM)); 616 617 mca::PipelinePrinter Printer(*P, *Region, RegionIdx, *STI, PO); 618 if (PrintJson) { 619 Printer.addView( 620 std::make_unique<mca::InstructionView>(*STI, *IP, Insts)); 621 } 622 623 // Create the views for this pipeline, execute, and emit a report. 624 if (PrintInstructionInfoView) { 625 Printer.addView(std::make_unique<mca::InstructionInfoView>( 626 *STI, *MCII, CE, ShowEncoding, Insts, *IP, LoweredSequence, 627 ShowBarriers, *IM, InstToInstruments)); 628 } 629 Printer.addView( 630 std::make_unique<mca::ResourcePressureView>(*STI, *IP, Insts)); 631 632 if (!runPipeline(*P)) 633 return 1; 634 635 if (PrintJson) { 636 Printer.printReport(JSONOutput); 637 } else { 638 Printer.printReport(TOF->os()); 639 } 640 641 ++RegionIdx; 642 continue; 643 } 644 645 // Create the CustomBehaviour object for enforcing Target Specific 646 // behaviours and dependencies that aren't expressed well enough 647 // in the tablegen. CB cannot depend on the list of MCInst or 648 // the source code (but it can depend on the list of 649 // mca::Instruction or any objects that can be reconstructed 650 // from the target information). 651 std::unique_ptr<mca::CustomBehaviour> CB; 652 if (!DisableCustomBehaviour) 653 CB = std::unique_ptr<mca::CustomBehaviour>( 654 TheTarget->createCustomBehaviour(*STI, S, *MCII)); 655 if (!CB) 656 // If the target doesn't have its own CB implemented (or the -disable-cb 657 // flag is set) then we use the base class (which does nothing). 658 CB = std::make_unique<mca::CustomBehaviour>(*STI, S, *MCII); 659 660 // Create a basic pipeline simulating an out-of-order backend. 661 auto P = MCA.createDefaultPipeline(PO, S, *CB); 662 663 mca::PipelinePrinter Printer(*P, *Region, RegionIdx, *STI, PO); 664 665 // Targets can define their own custom Views that exist within their 666 // /lib/Target/ directory so that the View can utilize their CustomBehaviour 667 // or other backend symbols / functionality that are not already exposed 668 // through one of the MC-layer classes. These Views will be initialized 669 // using the CustomBehaviour::getViews() variants. 670 // If a target makes a custom View that does not depend on their target 671 // CB or their backend, they should put the View within 672 // /tools/llvm-mca/Views/ instead. 673 if (!DisableCustomBehaviour) { 674 std::vector<std::unique_ptr<mca::View>> CBViews = 675 CB->getStartViews(*IP, Insts); 676 for (auto &CBView : CBViews) 677 Printer.addView(std::move(CBView)); 678 } 679 680 // When we output JSON, we add a view that contains the instructions 681 // and CPU resource information. 682 if (PrintJson) { 683 auto IV = std::make_unique<mca::InstructionView>(*STI, *IP, Insts); 684 Printer.addView(std::move(IV)); 685 } 686 687 if (PrintSummaryView) 688 Printer.addView( 689 std::make_unique<mca::SummaryView>(SM, Insts, DispatchWidth)); 690 691 if (EnableBottleneckAnalysis) { 692 if (!IsOutOfOrder) { 693 WithColor::warning() 694 << "bottleneck analysis is not supported for in-order CPU '" << MCPU 695 << "'.\n"; 696 } 697 Printer.addView(std::make_unique<mca::BottleneckAnalysis>( 698 *STI, *IP, Insts, S.getNumIterations())); 699 } 700 701 if (PrintInstructionInfoView) 702 Printer.addView(std::make_unique<mca::InstructionInfoView>( 703 *STI, *MCII, CE, ShowEncoding, Insts, *IP, LoweredSequence, 704 ShowBarriers, *IM, InstToInstruments)); 705 706 // Fetch custom Views that are to be placed after the InstructionInfoView. 707 // Refer to the comment paired with the CB->getStartViews(*IP, Insts); line 708 // for more info. 709 if (!DisableCustomBehaviour) { 710 std::vector<std::unique_ptr<mca::View>> CBViews = 711 CB->getPostInstrInfoViews(*IP, Insts); 712 for (auto &CBView : CBViews) 713 Printer.addView(std::move(CBView)); 714 } 715 716 if (PrintDispatchStats) 717 Printer.addView(std::make_unique<mca::DispatchStatistics>()); 718 719 if (PrintSchedulerStats) 720 Printer.addView(std::make_unique<mca::SchedulerStatistics>(*STI)); 721 722 if (PrintRetireStats) 723 Printer.addView(std::make_unique<mca::RetireControlUnitStatistics>(SM)); 724 725 if (PrintRegisterFileStats) 726 Printer.addView(std::make_unique<mca::RegisterFileStatistics>(*STI)); 727 728 if (PrintResourcePressureView) 729 Printer.addView( 730 std::make_unique<mca::ResourcePressureView>(*STI, *IP, Insts)); 731 732 if (PrintTimelineView) { 733 unsigned TimelineIterations = 734 TimelineMaxIterations ? TimelineMaxIterations : 10; 735 Printer.addView(std::make_unique<mca::TimelineView>( 736 *STI, *IP, Insts, std::min(TimelineIterations, S.getNumIterations()), 737 TimelineMaxCycles)); 738 } 739 740 // Fetch custom Views that are to be placed after all other Views. 741 // Refer to the comment paired with the CB->getStartViews(*IP, Insts); line 742 // for more info. 743 if (!DisableCustomBehaviour) { 744 std::vector<std::unique_ptr<mca::View>> CBViews = 745 CB->getEndViews(*IP, Insts); 746 for (auto &CBView : CBViews) 747 Printer.addView(std::move(CBView)); 748 } 749 750 if (!runPipeline(*P)) 751 return 1; 752 753 if (PrintJson) { 754 Printer.printReport(JSONOutput); 755 } else { 756 Printer.printReport(TOF->os()); 757 } 758 759 ++RegionIdx; 760 } 761 762 if (PrintJson) 763 TOF->os() << formatv("{0:2}", json::Value(std::move(JSONOutput))) << "\n"; 764 765 TOF->keep(); 766 return 0; 767 } 768