llvm/lib/IR/LLVMRemarkStreamer.cpp

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