1 //===- llvm/IR/LLVMRemarkStreamer.cpp - Remark Streamer -*- 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 file contains the implementation of the conversion between IR
10 // Diagnostics and serializable remarks::Remark objects.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "llvm/IR/LLVMRemarkStreamer.h"
15 #include "llvm/IR/DiagnosticInfo.h"
16 #include "llvm/IR/Function.h"
17 #include "llvm/IR/GlobalValue.h"
18 #include "llvm/Remarks/RemarkStreamer.h"
19 #include "llvm/Support/FileSystem.h"
20 #include "llvm/Support/ToolOutputFile.h"
21 
22 using namespace llvm;
23 
24 /// DiagnosticKind -> remarks::Type
toRemarkType(enum DiagnosticKind Kind)25 static remarks::Type toRemarkType(enum DiagnosticKind Kind) {
26   switch (Kind) {
27   default:
28     return remarks::Type::Unknown;
29   case DK_OptimizationRemark:
30   case DK_MachineOptimizationRemark:
31     return remarks::Type::Passed;
32   case DK_OptimizationRemarkMissed:
33   case DK_MachineOptimizationRemarkMissed:
34     return remarks::Type::Missed;
35   case DK_OptimizationRemarkAnalysis:
36   case DK_MachineOptimizationRemarkAnalysis:
37     return remarks::Type::Analysis;
38   case DK_OptimizationRemarkAnalysisFPCommute:
39     return remarks::Type::AnalysisFPCommute;
40   case DK_OptimizationRemarkAnalysisAliasing:
41     return remarks::Type::AnalysisAliasing;
42   case DK_OptimizationFailure:
43     return remarks::Type::Failure;
44   }
45 }
46 
47 /// DiagnosticLocation -> remarks::RemarkLocation.
48 static Optional<remarks::RemarkLocation>
toRemarkLocation(const DiagnosticLocation & DL)49 toRemarkLocation(const DiagnosticLocation &DL) {
50   if (!DL.isValid())
51     return None;
52   StringRef File = DL.getRelativePath();
53   unsigned Line = DL.getLine();
54   unsigned Col = DL.getColumn();
55   return remarks::RemarkLocation{File, Line, Col};
56 }
57 
58 /// LLVM Diagnostic -> Remark
59 remarks::Remark
toRemark(const DiagnosticInfoOptimizationBase & Diag) const60 LLVMRemarkStreamer::toRemark(const DiagnosticInfoOptimizationBase &Diag) const {
61   remarks::Remark R; // The result.
62   R.RemarkType = toRemarkType(static_cast<DiagnosticKind>(Diag.getKind()));
63   R.PassName = Diag.getPassName();
64   R.RemarkName = Diag.getRemarkName();
65   R.FunctionName =
66       GlobalValue::dropLLVMManglingEscape(Diag.getFunction().getName());
67   R.Loc = toRemarkLocation(Diag.getLocation());
68   R.Hotness = Diag.getHotness();
69 
70   for (const DiagnosticInfoOptimizationBase::Argument &Arg : Diag.getArgs()) {
71     R.Args.emplace_back();
72     R.Args.back().Key = Arg.Key;
73     R.Args.back().Val = Arg.Val;
74     R.Args.back().Loc = toRemarkLocation(Arg.Loc);
75   }
76 
77   return R;
78 }
79 
emit(const DiagnosticInfoOptimizationBase & Diag)80 void LLVMRemarkStreamer::emit(const DiagnosticInfoOptimizationBase &Diag) {
81   if (!RS.matchesFilter(Diag.getPassName()))
82       return;
83 
84   // First, convert the diagnostic to a remark.
85   remarks::Remark R = toRemark(Diag);
86   // Then, emit the remark through the serializer.
87   RS.getSerializer().emit(R);
88 }
89 
90 char LLVMRemarkSetupFileError::ID = 0;
91 char LLVMRemarkSetupPatternError::ID = 0;
92 char LLVMRemarkSetupFormatError::ID = 0;
93 
setupLLVMOptimizationRemarks(LLVMContext & Context,StringRef RemarksFilename,StringRef RemarksPasses,StringRef RemarksFormat,bool RemarksWithHotness,Optional<uint64_t> RemarksHotnessThreshold)94 Expected<std::unique_ptr<ToolOutputFile>> llvm::setupLLVMOptimizationRemarks(
95     LLVMContext &Context, StringRef RemarksFilename, StringRef RemarksPasses,
96     StringRef RemarksFormat, bool RemarksWithHotness,
97     Optional<uint64_t> RemarksHotnessThreshold) {
98   if (RemarksWithHotness)
99     Context.setDiagnosticsHotnessRequested(true);
100 
101   Context.setDiagnosticsHotnessThreshold(RemarksHotnessThreshold);
102 
103   if (RemarksFilename.empty())
104     return nullptr;
105 
106   Expected<remarks::Format> Format = remarks::parseFormat(RemarksFormat);
107   if (Error E = Format.takeError())
108     return make_error<LLVMRemarkSetupFormatError>(std::move(E));
109 
110   std::error_code EC;
111   auto Flags = *Format == remarks::Format::YAML ? sys::fs::OF_TextWithCRLF
112                                                 : sys::fs::OF_None;
113   auto RemarksFile =
114       std::make_unique<ToolOutputFile>(RemarksFilename, EC, Flags);
115   // We don't use llvm::FileError here because some diagnostics want the file
116   // name separately.
117   if (EC)
118     return make_error<LLVMRemarkSetupFileError>(errorCodeToError(EC));
119 
120   Expected<std::unique_ptr<remarks::RemarkSerializer>> RemarkSerializer =
121       remarks::createRemarkSerializer(
122           *Format, remarks::SerializerMode::Separate, RemarksFile->os());
123   if (Error E = RemarkSerializer.takeError())
124     return make_error<LLVMRemarkSetupFormatError>(std::move(E));
125 
126   // Create the main remark streamer.
127   Context.setMainRemarkStreamer(std::make_unique<remarks::RemarkStreamer>(
128       std::move(*RemarkSerializer), RemarksFilename));
129 
130   // Create LLVM's optimization remarks streamer.
131   Context.setLLVMRemarkStreamer(
132       std::make_unique<LLVMRemarkStreamer>(*Context.getMainRemarkStreamer()));
133 
134   if (!RemarksPasses.empty())
135     if (Error E = Context.getMainRemarkStreamer()->setFilter(RemarksPasses))
136       return make_error<LLVMRemarkSetupPatternError>(std::move(E));
137 
138   return std::move(RemarksFile);
139 }
140 
setupLLVMOptimizationRemarks(LLVMContext & Context,raw_ostream & OS,StringRef RemarksPasses,StringRef RemarksFormat,bool RemarksWithHotness,Optional<uint64_t> RemarksHotnessThreshold)141 Error llvm::setupLLVMOptimizationRemarks(
142     LLVMContext &Context, raw_ostream &OS, StringRef RemarksPasses,
143     StringRef RemarksFormat, bool RemarksWithHotness,
144     Optional<uint64_t> RemarksHotnessThreshold) {
145   if (RemarksWithHotness)
146     Context.setDiagnosticsHotnessRequested(true);
147 
148   Context.setDiagnosticsHotnessThreshold(RemarksHotnessThreshold);
149 
150   Expected<remarks::Format> Format = remarks::parseFormat(RemarksFormat);
151   if (Error E = Format.takeError())
152     return make_error<LLVMRemarkSetupFormatError>(std::move(E));
153 
154   Expected<std::unique_ptr<remarks::RemarkSerializer>> RemarkSerializer =
155       remarks::createRemarkSerializer(*Format,
156                                       remarks::SerializerMode::Separate, OS);
157   if (Error E = RemarkSerializer.takeError())
158     return make_error<LLVMRemarkSetupFormatError>(std::move(E));
159 
160   // Create the main remark streamer.
161   Context.setMainRemarkStreamer(
162       std::make_unique<remarks::RemarkStreamer>(std::move(*RemarkSerializer)));
163 
164   // Create LLVM's optimization remarks streamer.
165   Context.setLLVMRemarkStreamer(
166       std::make_unique<LLVMRemarkStreamer>(*Context.getMainRemarkStreamer()));
167 
168   if (!RemarksPasses.empty())
169     if (Error E = Context.getMainRemarkStreamer()->setFilter(RemarksPasses))
170       return make_error<LLVMRemarkSetupPatternError>(std::move(E));
171 
172   return Error::success();
173 }
174