lib/Remarks/RemarkParser.cpp

   1 //===- RemarkParser.cpp --------------------------------------------------===//
   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 provides utility methods used by clients that want to use the
  10 // parser for remark diagnostics in LLVM.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "llvm/Remarks/RemarkParser.h"
  15 #include "YAMLRemarkParser.h"
  16 #include "llvm-c/Remarks.h"
  17 #include "llvm/ADT/STLExtras.h"
  18 #include "llvm/Support/CBindingWrapping.h"
  19
  20 using namespace llvm;
  21 using namespace llvm::remarks;
  22
  23 Parser::Parser(StringRef Buf) : Impl(llvm::make_unique<YAMLParserImpl>(Buf)) {}
  24
  25 Parser::Parser(StringRef Buf, StringRef StrTabBuf)
  26     : Impl(llvm::make_unique<YAMLParserImpl>(Buf, StrTabBuf)) {}
  27
  28 Parser::~Parser() = default;
  29
  30 static Expected<const Remark *> getNextYAML(YAMLParserImpl &Impl) {
  31   YAMLRemarkParser &YAMLParser = Impl.YAMLParser;
  32   // Check for EOF.
  33   if (Impl.YAMLIt == Impl.YAMLParser.Stream.end())
  34     return nullptr;
  35
  36   auto CurrentIt = Impl.YAMLIt;
  37
  38   // Try to parse an entry.
  39   if (Error E = YAMLParser.parseYAMLElement(*CurrentIt)) {
  40     // Set the iterator to the end, in case the user calls getNext again.
  41     Impl.YAMLIt = Impl.YAMLParser.Stream.end();
  42     return std::move(E);
  43   }
  44
  45   // Move on.
  46   ++Impl.YAMLIt;
  47
  48   // Return the just-parsed remark.
  49   if (const Optional<YAMLRemarkParser::ParseState> &State = YAMLParser.State)
  50     return &State->TheRemark;
  51   else
  52     return createStringError(std::make_error_code(std::errc::invalid_argument),
  53                              "unexpected error while parsing.");
  54 }
  55
  56 Expected<const Remark *> Parser::getNext() const {
  57   if (auto *Impl = dyn_cast<YAMLParserImpl>(this->Impl.get()))
  58     return getNextYAML(*Impl);
  59   llvm_unreachable("Get next called with an unknown parsing implementation.");
  60 }
  61
  62 ParsedStringTable::ParsedStringTable(StringRef InBuffer) : Buffer(InBuffer) {
  63   while (!InBuffer.empty()) {
  64     // Strings are separated by '\0' bytes.
  65     std::pair<StringRef, StringRef> Split = InBuffer.split('\0');
  66     // We only store the offset from the beginning of the buffer.
  67     Offsets.push_back(Split.first.data() - Buffer.data());
  68     InBuffer = Split.second;
  69   }
  70 }
  71
  72 Expected<StringRef> ParsedStringTable::operator[](size_t Index) {
  73   if (Index >= Offsets.size())
  74     return createStringError(
  75         std::make_error_code(std::errc::invalid_argument),
  76         "String with index %u is out of bounds (size = %u).", Index,
  77         Offsets.size());
  78
  79   size_t Offset = Offsets[Index];
  80   // If it's the last offset, we can't use the next offset to know the size of
  81   // the string.
  82   size_t NextOffset =
  83       (Index == Offsets.size() - 1) ? Buffer.size() : Offsets[Index + 1];
  84   return StringRef(Buffer.data() + Offset, NextOffset - Offset - 1);
  85 }
  86
  87 // Create wrappers for C Binding types (see CBindingWrapping.h).
  88 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(remarks::Parser, LLVMRemarkParserRef)
  89
  90 extern "C" LLVMRemarkParserRef LLVMRemarkParserCreateYAML(const void *Buf,
  91                                                           uint64_t Size) {
  92   return wrap(
  93       new remarks::Parser(StringRef(static_cast<const char *>(Buf), Size)));
  94 }
  95
  96 static void handleYAMLError(remarks::YAMLParserImpl &Impl, Error E) {
  97   handleAllErrors(
  98       std::move(E),
  99       [&](const YAMLParseError &PE) {
 100         Impl.YAMLParser.Stream.printError(&PE.getNode(),
 101                                           Twine(PE.getMessage()) + Twine('\n'));
 102       },
 103       [&](const ErrorInfoBase &EIB) { EIB.log(Impl.YAMLParser.ErrorStream); });
 104   Impl.HasErrors = true;
 105 }
 106
 107 extern "C" LLVMRemarkEntryRef
 108 LLVMRemarkParserGetNext(LLVMRemarkParserRef Parser) {
 109   remarks::Parser &TheParser = *unwrap(Parser);
 110
 111   Expected<const remarks::Remark *> RemarkOrErr = TheParser.getNext();
 112   if (!RemarkOrErr) {
 113     // Error during parsing.
 114     if (auto *Impl = dyn_cast<remarks::YAMLParserImpl>(TheParser.Impl.get()))
 115       handleYAMLError(*Impl, RemarkOrErr.takeError());
 116     else
 117       llvm_unreachable("unkown parser implementation.");
 118     return nullptr;
 119   }
 120
 121   if (*RemarkOrErr == nullptr)
 122     return nullptr;
 123   // Valid remark.
 124   return wrap(*RemarkOrErr);
 125 }
 126
 127 extern "C" LLVMBool LLVMRemarkParserHasError(LLVMRemarkParserRef Parser) {
 128   if (auto *Impl =
 129           dyn_cast<remarks::YAMLParserImpl>(unwrap(Parser)->Impl.get()))
 130     return Impl->HasErrors;
 131   llvm_unreachable("unkown parser implementation.");
 132 }
 133
 134 extern "C" const char *
 135 LLVMRemarkParserGetErrorMessage(LLVMRemarkParserRef Parser) {
 136   if (auto *Impl =
 137           dyn_cast<remarks::YAMLParserImpl>(unwrap(Parser)->Impl.get()))
 138     return Impl->YAMLParser.ErrorStream.str().c_str();
 139   llvm_unreachable("unkown parser implementation.");
 140 }
 141
 142 extern "C" void LLVMRemarkParserDispose(LLVMRemarkParserRef Parser) {
 143   delete unwrap(Parser);
 144 }