blob: 97de338d960d3041eb569e34cb5bb9911abc1763 [file] [log] [blame]
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +00001//===-- llvm-mca.cpp - Machine Code Analyzer -------------------*- C++ -* -===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This utility is a simple driver that allows static performance analysis on
11// machine code similarly to how IACA (Intel Architecture Code Analyzer) works.
12//
13// llvm-mca [options] <file-name>
14// -march <type>
15// -mcpu <cpu>
16// -o <file>
17//
18// The target defaults to the host target.
Andrea Di Biagio93c49d52018-04-25 10:18:25 +000019// The cpu defaults to the 'native' host cpu.
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +000020// The output defaults to standard output.
21//
22//===----------------------------------------------------------------------===//
23
Andrea Di Biagioc6590122018-04-09 16:39:52 +000024#include "CodeRegion.h"
Matt Davis362ea5f2018-07-06 18:03:14 +000025#include "Context.h"
Andrea Di Biagio821f6502018-04-10 14:55:14 +000026#include "DispatchStatistics.h"
Andrea Di Biagiodf5d9482018-03-23 19:40:04 +000027#include "InstructionInfoView.h"
Andrea Di Biagiod1569292018-03-26 12:04:53 +000028#include "InstructionTables.h"
Matt Davisdea343d2018-06-25 16:53:00 +000029#include "Pipeline.h"
30#include "PipelinePrinter.h"
Andrea Di Biagio8dabf4f2018-04-03 16:46:23 +000031#include "RegisterFileStatistics.h"
Andrea Di Biagio53e6ade2018-03-09 12:50:42 +000032#include "ResourcePressureView.h"
Andrea Di Biagiof41ad5c2018-04-11 12:12:53 +000033#include "RetireControlUnitStatistics.h"
Andrea Di Biagio1cc29c02018-04-11 11:37:46 +000034#include "SchedulerStatistics.h"
Andrea Di Biagio0cc66c72018-03-09 13:52:03 +000035#include "SummaryView.h"
Andrea Di Biagio53e6ade2018-03-09 12:50:42 +000036#include "TimelineView.h"
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +000037#include "llvm/MC/MCAsmInfo.h"
38#include "llvm/MC/MCContext.h"
39#include "llvm/MC/MCObjectFileInfo.h"
40#include "llvm/MC/MCParser/MCTargetAsmParser.h"
41#include "llvm/MC/MCRegisterInfo.h"
42#include "llvm/MC/MCStreamer.h"
43#include "llvm/Support/CommandLine.h"
Andrea Di Biagio8af3fe82018-03-08 16:08:43 +000044#include "llvm/Support/ErrorOr.h"
45#include "llvm/Support/FileSystem.h"
Andrea Di Biagio641cca32018-04-25 10:27:30 +000046#include "llvm/Support/Host.h"
Rui Ueyama197194b2018-04-13 18:26:06 +000047#include "llvm/Support/InitLLVM.h"
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +000048#include "llvm/Support/MemoryBuffer.h"
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +000049#include "llvm/Support/SourceMgr.h"
50#include "llvm/Support/TargetRegistry.h"
51#include "llvm/Support/TargetSelect.h"
Andrea Di Biagio8af3fe82018-03-08 16:08:43 +000052#include "llvm/Support/ToolOutputFile.h"
Jonas Devlieghere6adef092018-04-18 15:26:51 +000053#include "llvm/Support/WithColor.h"
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +000054
55using namespace llvm;
56
Andrea Di Biagio55e9e0f2018-05-17 15:35:14 +000057static cl::OptionCategory ToolOptions("Tool Options");
58static cl::OptionCategory ViewOptions("View Options");
Andrea Di Biagio534e1da2018-04-25 11:33:14 +000059
Andrea Di Biagio55e9e0f2018-05-17 15:35:14 +000060static cl::opt<std::string> InputFilename(cl::Positional,
61 cl::desc("<input file>"),
62 cl::cat(ToolOptions), cl::init("-"));
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +000063
64static cl::opt<std::string> OutputFilename("o", cl::desc("Output filename"),
Andrea Di Biagio55e9e0f2018-05-17 15:35:14 +000065 cl::init("-"), cl::cat(ToolOptions),
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +000066 cl::value_desc("filename"));
67
68static cl::opt<std::string>
Matt Davis43de6db2018-06-22 16:17:26 +000069 ArchName("march", cl::desc("Target arch to assemble for, "
70 "see -version for available targets"),
Andrea Di Biagio55e9e0f2018-05-17 15:35:14 +000071 cl::cat(ToolOptions));
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +000072
73static cl::opt<std::string>
Matt Davis43de6db2018-06-22 16:17:26 +000074 TripleName("mtriple", cl::desc("Target triple to assemble for, "
75 "see -version for available targets"),
Andrea Di Biagio55e9e0f2018-05-17 15:35:14 +000076 cl::cat(ToolOptions));
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +000077
78static cl::opt<std::string>
79 MCPU("mcpu",
80 cl::desc("Target a specific cpu type (-mcpu=help for details)"),
Andrea Di Biagio55e9e0f2018-05-17 15:35:14 +000081 cl::value_desc("cpu-name"), cl::cat(ToolOptions), cl::init("native"));
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +000082
Andrea Di Biagio06268642018-04-24 16:19:08 +000083static cl::opt<int>
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +000084 OutputAsmVariant("output-asm-variant",
Andrea Di Biagio06268642018-04-24 16:19:08 +000085 cl::desc("Syntax variant to use for output printing"),
Andrea Di Biagio55e9e0f2018-05-17 15:35:14 +000086 cl::cat(ToolOptions), cl::init(-1));
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +000087
88static cl::opt<unsigned> Iterations("iterations",
89 cl::desc("Number of iterations to run"),
Andrea Di Biagio55e9e0f2018-05-17 15:35:14 +000090 cl::cat(ToolOptions), cl::init(0));
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +000091
Andrea Di Biagio55e9e0f2018-05-17 15:35:14 +000092static cl::opt<unsigned>
93 DispatchWidth("dispatch", cl::desc("Override the processor dispatch width"),
94 cl::cat(ToolOptions), cl::init(0));
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +000095
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +000096static cl::opt<unsigned>
97 RegisterFileSize("register-file-size",
98 cl::desc("Maximum number of temporary registers which can "
99 "be used for register mappings"),
Andrea Di Biagio55e9e0f2018-05-17 15:35:14 +0000100 cl::cat(ToolOptions), cl::init(0));
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +0000101
Andrea Di Biagio29538c62018-03-23 11:33:09 +0000102static cl::opt<bool>
Andrea Di Biagio8dabf4f2018-04-03 16:46:23 +0000103 PrintRegisterFileStats("register-file-stats",
104 cl::desc("Print register file statistics"),
Andrea Di Biagio450ea7a2018-05-05 15:36:47 +0000105 cl::cat(ViewOptions), cl::init(false));
Andrea Di Biagio8dabf4f2018-04-03 16:46:23 +0000106
Andrea Di Biagio641cca32018-04-25 10:27:30 +0000107static cl::opt<bool> PrintDispatchStats("dispatch-stats",
108 cl::desc("Print dispatch statistics"),
Andrea Di Biagio450ea7a2018-05-05 15:36:47 +0000109 cl::cat(ViewOptions), cl::init(false));
Andrea Di Biagio821f6502018-04-10 14:55:14 +0000110
Roman Lebedev9ddf1282018-06-15 14:01:43 +0000111static cl::opt<bool>
112 PrintSummaryView("summary-view", cl::Hidden,
113 cl::desc("Print summary view (enabled by default)"),
114 cl::cat(ViewOptions), cl::init(true));
115
Andrea Di Biagio641cca32018-04-25 10:27:30 +0000116static cl::opt<bool> PrintSchedulerStats("scheduler-stats",
117 cl::desc("Print scheduler statistics"),
Andrea Di Biagio450ea7a2018-05-05 15:36:47 +0000118 cl::cat(ViewOptions), cl::init(false));
Andrea Di Biagio1cc29c02018-04-11 11:37:46 +0000119
120static cl::opt<bool>
Andrea Di Biagiof41ad5c2018-04-11 12:12:53 +0000121 PrintRetireStats("retire-stats",
Andrea Di Biagio641cca32018-04-25 10:27:30 +0000122 cl::desc("Print retire control unit statistics"),
Andrea Di Biagio450ea7a2018-05-05 15:36:47 +0000123 cl::cat(ViewOptions), cl::init(false));
Andrea Di Biagiof41ad5c2018-04-11 12:12:53 +0000124
Andrea Di Biagio450ea7a2018-05-05 15:36:47 +0000125static cl::opt<bool> PrintResourcePressureView(
126 "resource-pressure",
127 cl::desc("Print the resource pressure view (enabled by default)"),
128 cl::cat(ViewOptions), cl::init(true));
Andrea Di Biagio29538c62018-03-23 11:33:09 +0000129
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +0000130static cl::opt<bool> PrintTimelineView("timeline",
131 cl::desc("Print the timeline view"),
Andrea Di Biagio450ea7a2018-05-05 15:36:47 +0000132 cl::cat(ViewOptions), cl::init(false));
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +0000133
134static cl::opt<unsigned> TimelineMaxIterations(
135 "timeline-max-iterations",
136 cl::desc("Maximum number of iterations to print in timeline view"),
Andrea Di Biagio450ea7a2018-05-05 15:36:47 +0000137 cl::cat(ViewOptions), cl::init(0));
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +0000138
139static cl::opt<unsigned> TimelineMaxCycles(
140 "timeline-max-cycles",
141 cl::desc(
142 "Maximum number of cycles in the timeline view. Defaults to 80 cycles"),
Andrea Di Biagio450ea7a2018-05-05 15:36:47 +0000143 cl::cat(ViewOptions), cl::init(80));
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +0000144
Andrea Di Biagio55e9e0f2018-05-17 15:35:14 +0000145static cl::opt<bool>
146 AssumeNoAlias("noalias",
147 cl::desc("If set, assume that loads and stores do not alias"),
148 cl::cat(ToolOptions), cl::init(true));
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +0000149
150static cl::opt<unsigned>
Andrea Di Biagio55e9e0f2018-05-17 15:35:14 +0000151 LoadQueueSize("lqueue",
152 cl::desc("Size of the load queue (unbound by default)"),
153 cl::cat(ToolOptions), cl::init(0));
Andrea Di Biagiod1569292018-03-26 12:04:53 +0000154
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +0000155static cl::opt<unsigned>
Andrea Di Biagio55e9e0f2018-05-17 15:35:14 +0000156 StoreQueueSize("squeue",
157 cl::desc("Size of the store queue (unbound by default)"),
158 cl::cat(ToolOptions), cl::init(0));
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +0000159
Andrea Di Biagiod1569292018-03-26 12:04:53 +0000160static cl::opt<bool>
161 PrintInstructionTables("instruction-tables",
162 cl::desc("Print instruction tables"),
Andrea Di Biagio55e9e0f2018-05-17 15:35:14 +0000163 cl::cat(ToolOptions), cl::init(false));
Andrea Di Biagiod1569292018-03-26 12:04:53 +0000164
Andrea Di Biagio450ea7a2018-05-05 15:36:47 +0000165static cl::opt<bool> PrintInstructionInfoView(
166 "instruction-info",
167 cl::desc("Print the instruction info view (enabled by default)"),
168 cl::cat(ViewOptions), cl::init(true));
Andrea Di Biagioff9c1092018-03-26 13:44:54 +0000169
Andrea Di Biagio650b5fc2018-05-17 12:27:03 +0000170static cl::opt<bool> EnableAllStats("all-stats",
171 cl::desc("Print all hardware statistics"),
172 cl::cat(ViewOptions), cl::init(false));
173
174static cl::opt<bool>
175 EnableAllViews("all-views",
176 cl::desc("Print all views including hardware statistics"),
177 cl::cat(ViewOptions), cl::init(false));
178
Andrea Di Biagio5c469442018-04-08 15:10:19 +0000179namespace {
180
181const Target *getTarget(const char *ProgName) {
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +0000182 TripleName = Triple::normalize(TripleName);
183 if (TripleName.empty())
184 TripleName = Triple::normalize(sys::getDefaultTargetTriple());
185 Triple TheTriple(TripleName);
186
187 // Get the target specific parser.
188 std::string Error;
189 const Target *TheTarget =
190 TargetRegistry::lookupTarget(ArchName, TheTriple, Error);
191 if (!TheTarget) {
192 errs() << ProgName << ": " << Error;
193 return nullptr;
194 }
195
196 // Return the found target.
197 return TheTarget;
198}
199
Andrea Di Biagioc6590122018-04-09 16:39:52 +0000200// A comment consumer that parses strings.
201// The only valid tokens are strings.
202class MCACommentConsumer : public AsmCommentConsumer {
203public:
204 mca::CodeRegions &Regions;
205
206 MCACommentConsumer(mca::CodeRegions &R) : Regions(R) {}
207 void HandleComment(SMLoc Loc, StringRef CommentText) override {
208 // Skip empty comments.
209 StringRef Comment(CommentText);
210 if (Comment.empty())
211 return;
212
213 // Skip spaces and tabs
214 unsigned Position = Comment.find_first_not_of(" \t");
215 if (Position >= Comment.size())
216 // we reached the end of the comment. Bail out.
217 return;
218
219 Comment = Comment.drop_front(Position);
220 if (Comment.consume_front("LLVM-MCA-END")) {
221 Regions.endRegion(Loc);
222 return;
223 }
224
225 // Now try to parse string LLVM-MCA-BEGIN
226 if (!Comment.consume_front("LLVM-MCA-BEGIN"))
227 return;
228
229 // Skip spaces and tabs
230 Position = Comment.find_first_not_of(" \t");
231 if (Position < Comment.size())
Fangrui Songbb082572018-04-09 17:06:57 +0000232 Comment = Comment.drop_front(Position);
Andrea Di Biagioc6590122018-04-09 16:39:52 +0000233 // Use the rest of the string as a descriptor for this code snippet.
234 Regions.beginRegion(Comment, Loc);
235 }
236};
237
Andrea Di Biagio5c469442018-04-08 15:10:19 +0000238int AssembleInput(const char *ProgName, MCAsmParser &Parser,
239 const Target *TheTarget, MCSubtargetInfo &STI,
240 MCInstrInfo &MCII, MCTargetOptions &MCOptions) {
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +0000241 std::unique_ptr<MCTargetAsmParser> TAP(
Andrea Di Biagio5c469442018-04-08 15:10:19 +0000242 TheTarget->createMCAsmParser(STI, Parser, MCII, MCOptions));
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +0000243
244 if (!TAP) {
Andrea Di Biagio24fb4fc2018-05-04 13:52:12 +0000245 WithColor::error() << "this target does not support assembly parsing.\n";
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +0000246 return 1;
247 }
248
Andrea Di Biagio5c469442018-04-08 15:10:19 +0000249 Parser.setTargetParser(*TAP);
250 return Parser.Run(false);
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +0000251}
252
Andrea Di Biagio5c469442018-04-08 15:10:19 +0000253ErrorOr<std::unique_ptr<ToolOutputFile>> getOutputStream() {
Andrea Di Biagio8af3fe82018-03-08 16:08:43 +0000254 if (OutputFilename == "")
255 OutputFilename = "-";
256 std::error_code EC;
257 auto Out =
258 llvm::make_unique<ToolOutputFile>(OutputFilename, EC, sys::fs::F_None);
259 if (!EC)
260 return std::move(Out);
261 return EC;
262}
263
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +0000264class MCStreamerWrapper final : public MCStreamer {
Andrea Di Biagioc6590122018-04-09 16:39:52 +0000265 mca::CodeRegions &Regions;
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +0000266
267public:
Andrea Di Biagioc6590122018-04-09 16:39:52 +0000268 MCStreamerWrapper(MCContext &Context, mca::CodeRegions &R)
269 : MCStreamer(Context), Regions(R) {}
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +0000270
271 // We only want to intercept the emission of new instructions.
272 virtual void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI,
273 bool /* unused */) override {
Andrea Di Biagioc6590122018-04-09 16:39:52 +0000274 Regions.addInstruction(llvm::make_unique<const MCInst>(Inst));
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +0000275 }
276
277 bool EmitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override {
278 return true;
279 }
280
281 void EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
282 unsigned ByteAlignment) override {}
283 void EmitZerofill(MCSection *Section, MCSymbol *Symbol = nullptr,
Francis Visoiu Mistrih4d5b1072018-07-02 17:29:43 +0000284 uint64_t Size = 0, unsigned ByteAlignment = 0,
285 SMLoc Loc = SMLoc()) override {}
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +0000286 void EmitGPRel32Value(const MCExpr *Value) override {}
287 void BeginCOFFSymbolDef(const MCSymbol *Symbol) override {}
288 void EmitCOFFSymbolStorageClass(int StorageClass) override {}
289 void EmitCOFFSymbolType(int Type) override {}
290 void EndCOFFSymbolDef() override {}
291
Andrea Di Biagioc6590122018-04-09 16:39:52 +0000292 const std::vector<std::unique_ptr<const MCInst>> &
293 GetInstructionSequence(unsigned Index) const {
294 return Regions.getInstructionSequence(Index);
295 }
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +0000296};
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +0000297} // end of anonymous namespace
298
Andrea Di Biagio650b5fc2018-05-17 12:27:03 +0000299static void processOptionImpl(cl::opt<bool> &O, const cl::opt<bool> &Default) {
300 if (!O.getNumOccurrences() || O.getPosition() < Default.getPosition())
301 O = Default.getValue();
302}
303
304static void processViewOptions() {
305 if (!EnableAllViews.getNumOccurrences() &&
306 !EnableAllStats.getNumOccurrences())
307 return;
308
309 if (EnableAllViews.getNumOccurrences()) {
Roman Lebedev9ddf1282018-06-15 14:01:43 +0000310 processOptionImpl(PrintSummaryView, EnableAllViews);
Andrea Di Biagio650b5fc2018-05-17 12:27:03 +0000311 processOptionImpl(PrintResourcePressureView, EnableAllViews);
312 processOptionImpl(PrintTimelineView, EnableAllViews);
313 processOptionImpl(PrintInstructionInfoView, EnableAllViews);
314 }
315
316 const cl::opt<bool> &Default =
317 EnableAllViews.getPosition() < EnableAllStats.getPosition()
318 ? EnableAllStats
319 : EnableAllViews;
Roman Lebedev9ddf1282018-06-15 14:01:43 +0000320 processOptionImpl(PrintSummaryView, Default);
Andrea Di Biagio650b5fc2018-05-17 12:27:03 +0000321 processOptionImpl(PrintRegisterFileStats, Default);
322 processOptionImpl(PrintDispatchStats, Default);
323 processOptionImpl(PrintSchedulerStats, Default);
324 processOptionImpl(PrintRetireStats, Default);
325}
326
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +0000327int main(int argc, char **argv) {
Rui Ueyama197194b2018-04-13 18:26:06 +0000328 InitLLVM X(argc, argv);
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +0000329
330 // Initialize targets and assembly parsers.
331 llvm::InitializeAllTargetInfos();
332 llvm::InitializeAllTargetMCs();
333 llvm::InitializeAllAsmParsers();
334
335 // Enable printing of available targets when flag --version is specified.
336 cl::AddExtraVersionPrinter(TargetRegistry::printRegisteredTargetsForVersion);
337
Andrea Di Biagio55e9e0f2018-05-17 15:35:14 +0000338 cl::HideUnrelatedOptions({&ToolOptions, &ViewOptions});
339
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +0000340 // Parse flags and initialize target options.
341 cl::ParseCommandLineOptions(argc, argv,
342 "llvm machine code performance analyzer.\n");
Andrea Di Biagio55e9e0f2018-05-17 15:35:14 +0000343
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +0000344 MCTargetOptions MCOptions;
345 MCOptions.PreserveAsmComments = false;
346
347 // Get the target from the triple. If a triple is not specified, then select
348 // the default triple for the host. If the triple doesn't correspond to any
349 // registered target, then exit with an error message.
350 const char *ProgName = argv[0];
351 const Target *TheTarget = getTarget(ProgName);
352 if (!TheTarget)
353 return 1;
354
355 // GetTarget() may replaced TripleName with a default triple.
356 // For safety, reconstruct the Triple object.
357 Triple TheTriple(TripleName);
358
359 ErrorOr<std::unique_ptr<MemoryBuffer>> BufferPtr =
360 MemoryBuffer::getFileOrSTDIN(InputFilename);
361 if (std::error_code EC = BufferPtr.getError()) {
Jonas Devlieghere6adef092018-04-18 15:26:51 +0000362 WithColor::error() << InputFilename << ": " << EC.message() << '\n';
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +0000363 return 1;
364 }
365
Andrea Di Biagio650b5fc2018-05-17 12:27:03 +0000366 // Apply overrides to llvm-mca specific options.
367 processViewOptions();
368
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +0000369 SourceMgr SrcMgr;
370
371 // Tell SrcMgr about this buffer, which is what the parser will pick up.
372 SrcMgr.AddNewSourceBuffer(std::move(*BufferPtr), SMLoc());
373
374 std::unique_ptr<MCRegisterInfo> MRI(TheTarget->createMCRegInfo(TripleName));
375 assert(MRI && "Unable to create target register info!");
376
377 std::unique_ptr<MCAsmInfo> MAI(TheTarget->createMCAsmInfo(*MRI, TripleName));
378 assert(MAI && "Unable to create target asm info!");
379
380 MCObjectFileInfo MOFI;
381 MCContext Ctx(MAI.get(), MRI.get(), &MOFI, &SrcMgr);
382 MOFI.InitMCObjectFileInfo(TheTriple, /* PIC= */ false, Ctx);
383
384 std::unique_ptr<buffer_ostream> BOS;
Andrea Di Biagiod1569292018-03-26 12:04:53 +0000385
Andrea Di Biagioc6590122018-04-09 16:39:52 +0000386 mca::CodeRegions Regions(SrcMgr);
387 MCStreamerWrapper Str(Ctx, Regions);
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +0000388
389 std::unique_ptr<MCInstrInfo> MCII(TheTarget->createMCInstrInfo());
Andrea Di Biagio93c49d52018-04-25 10:18:25 +0000390
Andrea Di Biagio2145b132018-06-20 10:08:11 +0000391 std::unique_ptr<MCInstrAnalysis> MCIA(
392 TheTarget->createMCInstrAnalysis(MCII.get()));
393
Andrea Di Biagio93c49d52018-04-25 10:18:25 +0000394 if (!MCPU.compare("native"))
395 MCPU = llvm::sys::getHostCPUName();
396
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +0000397 std::unique_ptr<MCSubtargetInfo> STI(
398 TheTarget->createMCSubtargetInfo(TripleName, MCPU, /* FeaturesStr */ ""));
399 if (!STI->isCPUStringValid(MCPU))
400 return 1;
401
Andrea Di Biagioe9384eb2018-04-30 12:05:34 +0000402 if (!PrintInstructionTables && !STI->getSchedModel().isOutOfOrder()) {
Jonas Devlieghere6adef092018-04-18 15:26:51 +0000403 WithColor::error() << "please specify an out-of-order cpu. '" << MCPU
404 << "' is an in-order cpu.\n";
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +0000405 return 1;
406 }
407
408 if (!STI->getSchedModel().hasInstrSchedModel()) {
Jonas Devlieghere6adef092018-04-18 15:26:51 +0000409 WithColor::error()
410 << "unable to find instruction-level scheduling information for"
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +0000411 << " target triple '" << TheTriple.normalize() << "' and cpu '" << MCPU
412 << "'.\n";
413
414 if (STI->getSchedModel().InstrItineraries)
Jonas Devlieghere6adef092018-04-18 15:26:51 +0000415 WithColor::note()
416 << "cpu '" << MCPU << "' provides itineraries. However, "
417 << "instruction itineraries are currently unsupported.\n";
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +0000418 return 1;
419 }
420
Andrea Di Biagio5c469442018-04-08 15:10:19 +0000421 std::unique_ptr<MCAsmParser> P(createMCAsmParser(SrcMgr, Ctx, Str, *MAI));
Andrea Di Biagioc6590122018-04-09 16:39:52 +0000422 MCAsmLexer &Lexer = P->getLexer();
423 MCACommentConsumer CC(Regions);
424 Lexer.setCommentConsumer(&CC);
425
Andrea Di Biagio5c469442018-04-08 15:10:19 +0000426 if (AssembleInput(ProgName, *P, TheTarget, *STI, *MCII, MCOptions))
427 return 1;
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +0000428
Andrea Di Biagioc6590122018-04-09 16:39:52 +0000429 if (Regions.empty()) {
Jonas Devlieghere6adef092018-04-18 15:26:51 +0000430 WithColor::error() << "no assembly instructions found.\n";
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +0000431 return 1;
432 }
433
Andrea Di Biagio8af3fe82018-03-08 16:08:43 +0000434 // Now initialize the output file.
435 auto OF = getOutputStream();
436 if (std::error_code EC = OF.getError()) {
Jonas Devlieghere6adef092018-04-18 15:26:51 +0000437 WithColor::error() << EC.message() << '\n';
Andrea Di Biagio8af3fe82018-03-08 16:08:43 +0000438 return 1;
439 }
440
Andrea Di Biagio06268642018-04-24 16:19:08 +0000441 unsigned AssemblerDialect = P->getAssemblerDialect();
442 if (OutputAsmVariant >= 0)
443 AssemblerDialect = static_cast<unsigned>(OutputAsmVariant);
444 std::unique_ptr<MCInstPrinter> IP(TheTarget->createMCInstPrinter(
445 Triple(TripleName), AssemblerDialect, *MAI, *MCII, *MRI));
446 if (!IP) {
447 WithColor::error()
448 << "unable to create instruction printer for target triple '"
449 << TheTriple.normalize() << "' with assembly variant "
450 << AssemblerDialect << ".\n";
451 return 1;
452 }
453
Andrea Di Biagio8af3fe82018-03-08 16:08:43 +0000454 std::unique_ptr<llvm::ToolOutputFile> TOF = std::move(*OF);
455
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +0000456 const MCSchedModel &SM = STI->getSchedModel();
457
458 unsigned Width = SM.IssueWidth;
459 if (DispatchWidth)
460 Width = DispatchWidth;
461
Andrea Di Biagiob5088da2018-03-23 11:50:43 +0000462 // Create an instruction builder.
Andrea Di Biagio88347792018-07-09 12:30:55 +0000463 mca::InstrBuilder IB(*STI, *MCII, *MRI, *MCIA, *IP);
Andrea Di Biagiob5088da2018-03-23 11:50:43 +0000464
Matt Davis362ea5f2018-07-06 18:03:14 +0000465 // Create a context to control ownership of the pipeline hardware.
466 mca::Context MCA(*MRI, *STI);
467
468 mca::PipelineOptions PO(Width, RegisterFileSize, LoadQueueSize,
469 StoreQueueSize, AssumeNoAlias);
470
Andrea Di Biagioc6590122018-04-09 16:39:52 +0000471 // Number each region in the sequence.
472 unsigned RegionIdx = 0;
473 for (const std::unique_ptr<mca::CodeRegion> &Region : Regions) {
474 // Skip empty code regions.
475 if (Region->empty())
476 continue;
Andrea Di Biagioff9c1092018-03-26 13:44:54 +0000477
Andrea Di Biagioc6590122018-04-09 16:39:52 +0000478 // Don't print the header of this region if it is the default region, and
479 // it doesn't have an end location.
480 if (Region->startLoc().isValid() || Region->endLoc().isValid()) {
481 TOF->os() << "\n[" << RegionIdx++ << "] Code Region";
482 StringRef Desc = Region->getDescription();
483 if (!Desc.empty())
484 TOF->os() << " - " << Desc;
485 TOF->os() << "\n\n";
Andrea Di Biagioff9c1092018-03-26 13:44:54 +0000486 }
487
Andrea Di Biagioc6590122018-04-09 16:39:52 +0000488 mca::SourceMgr S(Region->getInstructions(),
489 PrintInstructionTables ? 1 : Iterations);
490
491 if (PrintInstructionTables) {
Matt Davis43de6db2018-06-22 16:17:26 +0000492 mca::InstructionTables IT(SM, IB, S);
Andrea Di Biagioc6590122018-04-09 16:39:52 +0000493
494 if (PrintInstructionInfoView) {
495 IT.addView(
496 llvm::make_unique<mca::InstructionInfoView>(*STI, *MCII, S, *IP));
497 }
498
499 IT.addView(llvm::make_unique<mca::ResourcePressureView>(*STI, *IP, S));
500 IT.run();
501 IT.printReport(TOF->os());
502 continue;
503 }
504
Matt Davis362ea5f2018-07-06 18:03:14 +0000505 // Create a basic pipeline simulating an out-of-order backend.
506 auto P = MCA.createDefaultPipeline(PO, IB, S);
Matt Davisdea343d2018-06-25 16:53:00 +0000507 mca::PipelinePrinter Printer(*P);
Andrea Di Biagioc6590122018-04-09 16:39:52 +0000508
Roman Lebedev9ddf1282018-06-15 14:01:43 +0000509 if (PrintSummaryView)
510 Printer.addView(llvm::make_unique<mca::SummaryView>(SM, S, Width));
511
Andrea Di Biagioc6590122018-04-09 16:39:52 +0000512 if (PrintInstructionInfoView)
513 Printer.addView(
514 llvm::make_unique<mca::InstructionInfoView>(*STI, *MCII, S, *IP));
515
Andrea Di Biagio821f6502018-04-10 14:55:14 +0000516 if (PrintDispatchStats)
Andrea Di Biagio074ff7c2018-04-11 12:31:44 +0000517 Printer.addView(llvm::make_unique<mca::DispatchStatistics>());
Andrea Di Biagio821f6502018-04-10 14:55:14 +0000518
Andrea Di Biagiof41ad5c2018-04-11 12:12:53 +0000519 if (PrintSchedulerStats)
Andrea Di Biagio1cc29c02018-04-11 11:37:46 +0000520 Printer.addView(llvm::make_unique<mca::SchedulerStatistics>(*STI));
521
Andrea Di Biagiof41ad5c2018-04-11 12:12:53 +0000522 if (PrintRetireStats)
523 Printer.addView(llvm::make_unique<mca::RetireControlUnitStatistics>());
Andrea Di Biagioc6590122018-04-09 16:39:52 +0000524
525 if (PrintRegisterFileStats)
526 Printer.addView(llvm::make_unique<mca::RegisterFileStatistics>(*STI));
527
528 if (PrintResourcePressureView)
529 Printer.addView(
530 llvm::make_unique<mca::ResourcePressureView>(*STI, *IP, S));
531
532 if (PrintTimelineView) {
533 Printer.addView(llvm::make_unique<mca::TimelineView>(
534 *STI, *IP, S, TimelineMaxIterations, TimelineMaxCycles));
535 }
536
Matt Davisdea343d2018-06-25 16:53:00 +0000537 P->run();
Andrea Di Biagioc6590122018-04-09 16:39:52 +0000538 Printer.printReport(TOF->os());
Andrea Di Biagio9b3cb082018-07-02 20:39:57 +0000539
540 // Clear the InstrBuilder internal state in preparation for another round.
541 IB.clear();
Andrea Di Biagiod1569292018-03-26 12:04:53 +0000542 }
543
Andrea Di Biagio8af3fe82018-03-08 16:08:43 +0000544 TOF->keep();
Andrea Di Biagio3a6b0922018-03-08 13:05:02 +0000545 return 0;
546}