RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-10-19 02:52:53 +02:00
Code Issues Projects Releases Wiki Activity

Revert "[Remarks] Add a new Remark / RemarkParser abstraction"

Browse Source 
This reverts commit 51dc6a8c84cd6a58562e320e1828a0158dbbf750.

Breaks
http://lab.llvm.org:8011/builders/clang-cmake-x86_64-sde-avx512-linux/builds/20034/steps/build%20stage%201/logs/stdio.

llvm-svn: 356492
This commit is contained in:
Francis Visoiu Mistrih 2019-03-19 18:21:43 +00:00
parent de75d7efaf
commit a58b553f92
14 changed files with 856 additions and 1493 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

225
include/llvm-c/Remarks.h
View File

@ -33,202 +33,87 @@ extern "C" {
#define REMARKS_API_VERSION 0
/**
* The type of the emitted remark.
*/
enum LLVMRemarkType {
LLVMRemarkTypeUnknown,
LLVMRemarkTypePassed,
LLVMRemarkTypeMissed,
LLVMRemarkTypeAnalysis,
LLVMRemarkTypeAnalysisFPCommute,
LLVMRemarkTypeAnalysisAliasing,
LLVMRemarkTypeFailure
};
/**
* String containing a buffer and a length. The buffer is not guaranteed to be
* zero-terminated.
*
* \since REMARKS_API_VERSION=0
*/
typedef struct LLVMRemarkOpaqueString *LLVMRemarkStringRef;
/**
* Returns the buffer holding the string.
*
* \since REMARKS_API_VERSION=0
*/
extern const char *LLVMRemarkStringGetData(LLVMRemarkStringRef String);
/**
* Returns the size of the string.
*
* \since REMARKS_API_VERSION=0
*/
extern uint32_t LLVMRemarkStringGetLen(LLVMRemarkStringRef String);
typedef struct {
const char *Str;
uint32_t Len;
} LLVMRemarkStringRef;
/**
* DebugLoc containing File, Line and Column.
*
* \since REMARKS_API_VERSION=0
*/
typedef struct LLVMRemarkOpaqueDebugLoc *LLVMRemarkDebugLocRef;
/**
* Return the path to the source file for a debug location.
*
* \since REMARKS_API_VERSION=0
*/
extern LLVMRemarkStringRef
LLVMRemarkDebugLocGetSourceFilePath(LLVMRemarkDebugLocRef DL);
/**
* Return the line in the source file for a debug location.
*
* \since REMARKS_API_VERSION=0
*/
extern uint32_t LLVMRemarkDebugLocGetSourceLine(LLVMRemarkDebugLocRef DL);
/**
* Return the column in the source file for a debug location.
*
* \since REMARKS_API_VERSION=0
*/
extern uint32_t LLVMRemarkDebugLocGetSourceColumn(LLVMRemarkDebugLocRef DL);
typedef struct {
// File:
LLVMRemarkStringRef SourceFile;
// Line:
uint32_t SourceLineNumber;
// Column:
uint32_t SourceColumnNumber;
} LLVMRemarkDebugLoc;
/**
* Element of the "Args" list. The key might give more information about what
* the semantics of the value are, e.g. "Callee" will tell you that the value
* are the semantics of the value, e.g. "Callee" will tell you that the value
* is a symbol that names a function.
*
* \since REMARKS_API_VERSION=0
*/
typedef struct LLVMRemarkOpaqueArg *LLVMRemarkArgRef;
typedef struct {
// e.g. "Callee"
LLVMRemarkStringRef Key;
// e.g. "malloc"
LLVMRemarkStringRef Value;
// "DebugLoc": Optional
LLVMRemarkDebugLoc DebugLoc;
} LLVMRemarkArg;
/**
* Returns the key of an argument. The key defines what the value is, and the
* same key can appear multiple times in the list of arguments.
* One remark entry.
*
* \since REMARKS_API_VERSION=0
*/
extern LLVMRemarkStringRef LLVMRemarkArgGetKey(LLVMRemarkArgRef Arg);
typedef struct {
// e.g. !Missed, !Passed
LLVMRemarkStringRef RemarkType;
// "Pass": Required
LLVMRemarkStringRef PassName;
// "Name": Required
LLVMRemarkStringRef RemarkName;
// "Function": Required
LLVMRemarkStringRef FunctionName;
/**
* Returns the value of an argument. This is a string that can contain newlines.
*
* \since REMARKS_API_VERSION=0
*/
extern LLVMRemarkStringRef LLVMRemarkArgGetValue(LLVMRemarkArgRef Arg);
/**
* Returns the debug location that is attached to the value of this argument.
*
* If there is no debug location, the return value will be `NULL`.
*
* \since REMARKS_API_VERSION=0
*/
extern LLVMRemarkDebugLocRef LLVMRemarkArgGetDebugLoc(LLVMRemarkArgRef Arg);
/**
* A remark emitted by the compiler.
*
* \since REMARKS_API_VERSION=0
*/
typedef struct LLVMRemarkOpaqueEntry *LLVMRemarkEntryRef;
/**
* The type of the remark. For example, it can allow users to only keep the
* missed optimizations from the compiler.
*
* \since REMARKS_API_VERSION=0
*/
extern enum LLVMRemarkType LLVMRemarkEntryGetType(LLVMRemarkEntryRef Remark);
/**
* Get the name of the pass that emitted this remark.
*
* \since REMARKS_API_VERSION=0
*/
extern LLVMRemarkStringRef
LLVMRemarkEntryGetPassName(LLVMRemarkEntryRef Remark);
/**
* Get an identifier of the remark.
*
* \since REMARKS_API_VERSION=0
*/
extern LLVMRemarkStringRef
LLVMRemarkEntryGetRemarkName(LLVMRemarkEntryRef Remark);
/**
* Get the name of the function being processsed when the remark was emitted.
*
* \since REMARKS_API_VERSION=0
*/
extern LLVMRemarkStringRef
LLVMRemarkEntryGetFunctionName(LLVMRemarkEntryRef Remark);
/**
* Returns the debug location that is attached to this remark.
*
* If there is no debug location, the return value will be `NULL`.
*
* \since REMARKS_API_VERSION=0
*/
extern LLVMRemarkDebugLocRef
LLVMRemarkEntryGetDebugLoc(LLVMRemarkEntryRef Remark);
/**
* Return the hotness of the remark.
*
* A hotness of `0` means this value is not set.
*
* \since REMARKS_API_VERSION=0
*/
extern uint64_t LLVMRemarkEntryGetHotness(LLVMRemarkEntryRef Remark);
/**
* The number of arguments the remark holds.
*
* \since REMARKS_API_VERSION=0
*/
extern uint32_t LLVMRemarkEntryGetNumArgs(LLVMRemarkEntryRef Remark);
/**
* Get a new iterator to iterate over a remark's argument.
*
* If there are no arguments in \p Remark, the return value will be `NULL`.
*
* \since REMARKS_API_VERSION=0
*/
extern LLVMRemarkArgRef LLVMRemarkEntryGetFirstArg(LLVMRemarkEntryRef Remark);
/**
* Get the next argument in \p Remark from the position of \p It.
*
* Returns `NULL` if there are no more arguments available.
*
* \since REMARKS_API_VERSION=0
*/
extern LLVMRemarkArgRef LLVMRemarkEntryGetNextArg(LLVMRemarkArgRef It,
LLVMRemarkEntryRef Remark);
// "DebugLoc": Optional
LLVMRemarkDebugLoc DebugLoc;
// "Hotness": Optional
uint32_t Hotness;
// "Args": Optional. It is an array of `num_args` elements.
uint32_t NumArgs;
LLVMRemarkArg *Args;
} LLVMRemarkEntry;
typedef struct LLVMRemarkOpaqueParser *LLVMRemarkParserRef;
/**
* Creates a remark parser that can be used to parse the buffer located in \p
* Buf of size \p Size bytes.
* Creates a remark parser that can be used to read and parse the buffer located
* in \p Buf of size \p Size.
*
* \p Buf cannot be `NULL`.
* \p Buf cannot be NULL.
*
* This function should be paired with LLVMRemarkParserDispose() to avoid
* leaking resources.
*
* \since REMARKS_API_VERSION=0
*/
extern LLVMRemarkParserRef LLVMRemarkParserCreateYAML(const void *Buf,
uint64_t Size);
extern LLVMRemarkParserRef LLVMRemarkParserCreate(const void *Buf,
uint64_t Size);
/**
* Returns the next remark in the file.
@ -236,9 +121,9 @@ extern LLVMRemarkParserRef LLVMRemarkParserCreateYAML(const void *Buf,
* The value pointed to by the return value is invalidated by the next call to
* LLVMRemarkParserGetNext().
*
* If the parser reaches the end of the buffer, the return value will be `NULL`.
* If the parser reaches the end of the buffer, the return value will be NULL.
*
* In the case of an error, the return value will be `NULL`, and:
* In the case of an error, the return value will be NULL, and:
*
* 1) LLVMRemarkParserHasError() will return `1`.
*
@ -249,16 +134,18 @@ extern LLVMRemarkParserRef LLVMRemarkParserCreateYAML(const void *Buf,
*
* 1) An argument is invalid.
*
* 2) There is a parsing error. This can occur on things like malformed YAML.
* 2) There is a YAML parsing error. This type of error aborts parsing
* immediately and returns `1`. It can occur on malformed YAML.
*
* 3) There is a Remark semantic error. This can occur on well-formed files with
* missing or extra fields.
* 3) Remark parsing error. If this type of error occurs, the parser won't call
* the handler and will continue to the next one. It can occur on malformed
* remarks, like missing or extra fields in the file.
*
* Here is a quick example of the usage:
*
* ```
* LLVMRemarkParserRef Parser = LLVMRemarkParserCreateYAML(Buf, Size);
* LLVMRemarkEntryRef Remark = NULL;
* LLVMRemarkParserRef Parser = LLVMRemarkParserCreate(Buf, Size);
* LLVMRemarkEntry *Remark = NULL;
* while ((Remark == LLVMRemarkParserGetNext(Parser))) {
* // use Remark
* }
@ -268,7 +155,7 @@ extern LLVMRemarkParserRef LLVMRemarkParserCreateYAML(const void *Buf,
*
* \since REMARKS_API_VERSION=0
*/
extern LLVMRemarkEntryRef LLVMRemarkParserGetNext(LLVMRemarkParserRef Parser);
extern LLVMRemarkEntry *LLVMRemarkParserGetNext(LLVMRemarkParserRef Parser);
/**
* Returns `1` if the parser encountered an error while parsing the buffer.
@ -298,7 +185,7 @@ extern const char *LLVMRemarkParserGetErrorMessage(LLVMRemarkParserRef Parser);
extern void LLVMRemarkParserDispose(LLVMRemarkParserRef Parser);
/**
* Returns the version of the remarks library.
* Returns the version of the remarks dylib.
*
* \since REMARKS_API_VERSION=0
*/

98
include/llvm/Remarks/Remark.h
View File

@ -1,98 +0,0 @@
//===-- llvm/Remarks/Remark.h - The remark type -----------------*- C++/-*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file defines an abstraction for handling remarks.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_REMARKS_REMARK_H
#define LLVM_REMARKS_REMARK_H
#include "llvm-c/Remarks.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/Optional.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/CBindingWrapping.h"
#include <string>
namespace llvm {
namespace remarks {
/// The debug location used to track a remark back to the source file.
struct RemarkLocation {
/// Absolute path of the source file corresponding to this remark.
StringRef SourceFilePath;
unsigned SourceLine;
unsigned SourceColumn;
};
// Create wrappers for C Binding types (see CBindingWrapping.h).
DEFINE_SIMPLE_CONVERSION_FUNCTIONS(RemarkLocation, LLVMRemarkDebugLocRef)
/// A key-value pair with a debug location that is used to display the remarks
/// at the right place in the source.
struct Argument {
StringRef Key;
// FIXME: We might want to be able to store other types than strings here.
StringRef Val;
// If set, the debug location corresponding to the value.
Optional<RemarkLocation> Loc;
};
// Create wrappers for C Binding types (see CBindingWrapping.h).
DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Argument, LLVMRemarkArgRef)
/// The type of the remark.
enum class Type {
Unknown,
Passed,
Missed,
Analysis,
AnalysisFPCommute,
AnalysisAliasing,
Failure,
LastTypeValue = Failure
};
/// A remark type used for both emission and parsing.
struct Remark {
/// The type of the remark.
enum Type RemarkType = Type::Unknown;
/// Name of the pass that triggers the emission of this remark.
StringRef PassName;
/// Textual identifier for the remark (single-word, camel-case). Can be used
/// by external tools reading the output file for remarks to identify the
/// remark.
StringRef RemarkName;
/// Mangled name of the function that triggers the emssion of this remark.
StringRef FunctionName;
/// The location in the source file of the remark.
Optional<RemarkLocation> Loc;
/// If profile information is available, this is the number of times the
/// corresponding code was executed in a profile instrumentation run.
Optional<uint64_t> Hotness;
/// Arguments collected via the streaming interface.
ArrayRef<Argument> Args;
/// Return a message composed from the arguments as a string.
std::string getArgsAsMsg() const;
};
// Create wrappers for C Binding types (see CBindingWrapping.h).
DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Remark, LLVMRemarkEntryRef)
} // end namespace remarks
} // end namespace llvm
#endif /* LLVM_REMARKS_REMARK_H */

46
include/llvm/Remarks/RemarkParser.h
View File

@ -1,46 +0,0 @@
//===-- llvm/Remarks/Remark.h - The remark type -----------------*- C++/-*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file provides an interface for parsing remarks in LLVM.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_REMARKS_REMARK_PARSER_H
#define LLVM_REMARKS_REMARK_PARSER_H
#include "llvm/ADT/StringRef.h"
#include "llvm/Remarks/Remark.h"
#include "llvm/Support/Error.h"
#include <memory>
namespace llvm {
namespace remarks {
struct ParserImpl;
/// Parser used to parse a raw buffer to remarks::Remark objects.
struct Parser {
/// The hidden implementation of the parser.
std::unique_ptr<ParserImpl> Impl;
/// Create a parser parsing \p Buffer to Remark objects.
/// This constructor should be only used for parsing YAML remarks.
Parser(StringRef Buffer);
// Needed because ParserImpl is an incomplete type.
~Parser();
/// Returns an empty Optional if it reached the end.
/// Returns a valid remark otherwise.
Expected<const Remark *> getNext() const;
};
} // end namespace remarks
} // end namespace llvm
#endif /* LLVM_REMARKS_REMARK_PARSER_H */

2
lib/Remarks/CMakeLists.txt
View File

@ -1,5 +1,3 @@
add_llvm_library(LLVMRemarks
Remark.cpp
RemarkParser.cpp
YAMLRemarkParser.cpp
)

128
lib/Remarks/Remark.cpp
View File

@ -1,128 +0,0 @@
//===- Remark.cpp ---------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// Implementation of the Remark type and the C API.
//
//===----------------------------------------------------------------------===//
#include "llvm/Remarks/Remark.h"
#include "llvm-c/Remarks.h"
#include "llvm/Support/CBindingWrapping.h"
#include "llvm/Support/raw_ostream.h"
using namespace llvm;
using namespace llvm::remarks;
std::string Remark::getArgsAsMsg() const {
std::string Str;
raw_string_ostream OS(Str);
for (const Argument &Arg : Args)
OS << Arg.Val;
return OS.str();
}
// Create wrappers for C Binding types (see CBindingWrapping.h).
DEFINE_SIMPLE_CONVERSION_FUNCTIONS(StringRef, LLVMRemarkStringRef)
extern "C" const char *LLVMRemarkStringGetData(LLVMRemarkStringRef String) {
return unwrap(String)->data();
}
extern "C" uint32_t LLVMRemarkStringGetLen(LLVMRemarkStringRef String) {
return unwrap(String)->size();
}
extern "C" LLVMRemarkStringRef
LLVMRemarkDebugLocGetSourceFilePath(LLVMRemarkDebugLocRef DL) {
return wrap(&unwrap(DL)->SourceFilePath);
}
extern "C" uint32_t LLVMRemarkDebugLocGetSourceLine(LLVMRemarkDebugLocRef DL) {
return unwrap(DL)->SourceLine;
}
extern "C" uint32_t
LLVMRemarkDebugLocGetSourceColumn(LLVMRemarkDebugLocRef DL) {
return unwrap(DL)->SourceColumn;
}
extern "C" LLVMRemarkStringRef LLVMRemarkArgGetKey(LLVMRemarkArgRef Arg) {
return wrap(&unwrap(Arg)->Key);
}
extern "C" LLVMRemarkStringRef LLVMRemarkArgGetValue(LLVMRemarkArgRef Arg) {
return wrap(&unwrap(Arg)->Val);
}
extern "C" LLVMRemarkDebugLocRef
LLVMRemarkArgGetDebugLoc(LLVMRemarkArgRef Arg) {
if (const Optional<RemarkLocation> &Loc = unwrap(Arg)->Loc)
return wrap(&*Loc);
return nullptr;
}
extern "C" LLVMRemarkType LLVMRemarkEntryGetType(LLVMRemarkEntryRef Remark) {
// Assume here that the enums can be converted both ways.
return static_cast<LLVMRemarkType>(unwrap(Remark)->RemarkType);
}
extern "C" LLVMRemarkStringRef
LLVMRemarkEntryGetPassName(LLVMRemarkEntryRef Remark) {
return wrap(&unwrap(Remark)->PassName);
}
extern "C" LLVMRemarkStringRef
LLVMRemarkEntryGetRemarkName(LLVMRemarkEntryRef Remark) {
return wrap(&unwrap(Remark)->RemarkName);
}
extern "C" LLVMRemarkStringRef
LLVMRemarkEntryGetFunctionName(LLVMRemarkEntryRef Remark) {
return wrap(&unwrap(Remark)->FunctionName);
}
extern "C" LLVMRemarkDebugLocRef
LLVMRemarkEntryGetDebugLoc(LLVMRemarkEntryRef Remark) {
if (const Optional<RemarkLocation> &Loc = unwrap(Remark)->Loc)
return wrap(&*Loc);
return nullptr;
}
extern "C" uint64_t LLVMRemarkEntryGetHotness(LLVMRemarkEntryRef Remark) {
if (const Optional<uint64_t> &Hotness = unwrap(Remark)->Hotness)
return *Hotness;
return 0;
}
extern "C" uint32_t LLVMRemarkEntryGetNumArgs(LLVMRemarkEntryRef Remark) {
return unwrap(Remark)->Args.size();
}
extern "C" LLVMRemarkArgRef
LLVMRemarkEntryGetFirstArg(LLVMRemarkEntryRef Remark) {
ArrayRef<Argument> Args = unwrap(Remark)->Args;
// No arguments to iterate on.
if (Args.empty())
return NULL;
return reinterpret_cast<LLVMRemarkArgRef>(
const_cast<Argument *>(Args.begin()));
}
extern "C" LLVMRemarkArgRef
LLVMRemarkEntryGetNextArg(LLVMRemarkArgRef ArgIt, LLVMRemarkEntryRef Remark) {
// No more arguments to iterate on.
if (ArgIt == NULL)
return NULL;
auto It = (ArrayRef<Argument>::const_iterator)ArgIt;
auto Next = std::next(It);
if (Next == unwrap(Remark)->Args.end())
return NULL;
return reinterpret_cast<LLVMRemarkArgRef>(const_cast<Argument *>(Next));
}

401
lib/Remarks/RemarkParser.cpp
View File

@ -11,104 +11,355 @@
//
//===----------------------------------------------------------------------===//
#include "llvm/Remarks/RemarkParser.h"
#include "YAMLRemarkParser.h"
#include "llvm-c/Remarks.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/Support/CBindingWrapping.h"
#include "llvm/Support/SourceMgr.h"
#include "llvm/Support/YAMLTraits.h"
using namespace llvm;
using namespace llvm::remarks;
Parser::Parser(StringRef Buf) : Impl(llvm::make_unique<YAMLParserImpl>(Buf)) {}
namespace {
struct YAMLRemarkParser {
/// Source manager for better error messages.
SourceMgr SM;
/// Stream for yaml parsing.
yaml::Stream Stream;
/// Storage for the error stream.
std::string ErrorString;
/// The error stream.
raw_string_ostream ErrorStream;
/// Iterator in the YAML stream.
yaml::document_iterator DI;
/// The parsed remark (if any).
Optional<LLVMRemarkEntry> LastRemark;
/// Temporary parsing buffer for the arguments.
SmallVector<LLVMRemarkArg, 8> TmpArgs;
/// The state used by the parser to parse a remark entry. Invalidated with
/// every call to `parseYAMLElement`.
struct ParseState {
/// Temporary parsing buffer for the arguments.
SmallVectorImpl<LLVMRemarkArg> *Args;
StringRef Type;
StringRef Pass;
StringRef Name;
StringRef Function;
/// Optional.
Optional<StringRef> File;
Optional<unsigned> Line;
Optional<unsigned> Column;
Optional<unsigned> Hotness;
Parser::~Parser() = default;
ParseState(SmallVectorImpl<LLVMRemarkArg> &Args) : Args(&Args) {}
/// Use Args only as a **temporary** buffer.
~ParseState() { Args->clear(); }
};
static Expected<const Remark *> getNextYAML(YAMLParserImpl &Impl) {
YAMLRemarkParser &YAMLParser = Impl.YAMLParser;
ParseState State;
/// Set to `true` if we had any errors during parsing.
bool HadAnyErrors = false;
YAMLRemarkParser(StringRef Buf)
: SM(), Stream(Buf, SM), ErrorString(), ErrorStream(ErrorString),
DI(Stream.begin()), LastRemark(), TmpArgs(), State(TmpArgs) {
SM.setDiagHandler(YAMLRemarkParser::HandleDiagnostic, this);
}
/// Parse a YAML element.
Error parseYAMLElement(yaml::Document &Remark);
private:
/// Parse one key to a string.
/// otherwise.
Error parseKey(StringRef &Result, yaml::KeyValueNode &Node);
/// Parse one value to a string.
Error parseValue(StringRef &Result, yaml::KeyValueNode &Node);
/// Parse one value to an unsigned.
Error parseValue(Optional<unsigned> &Result, yaml::KeyValueNode &Node);
/// Parse a debug location.
Error parseDebugLoc(Optional<StringRef> &File, Optional<unsigned> &Line,
Optional<unsigned> &Column, yaml::KeyValueNode &Node);
/// Parse an argument.
Error parseArg(SmallVectorImpl<LLVMRemarkArg> &TmpArgs, yaml::Node &Node);
/// Handle a diagnostic from the YAML stream. Records the error in the
/// YAMLRemarkParser class.
static void HandleDiagnostic(const SMDiagnostic &Diag, void *Ctx) {
assert(Ctx && "Expected non-null Ctx in diagnostic handler.");
auto *Parser = static_cast<YAMLRemarkParser *>(Ctx);
Diag.print(/*ProgName=*/nullptr, Parser->ErrorStream, /*ShowColors*/ false,
/*ShowKindLabels*/ true);
}
};
class ParseError : public ErrorInfo<ParseError> {
public:
static char ID;
ParseError(StringRef Message, yaml::Node &Node)
: Message(Message), Node(Node) {}
void log(raw_ostream &OS) const override { OS << Message; }
std::error_code convertToErrorCode() const override {
return inconvertibleErrorCode();
}
StringRef getMessage() const { return Message; }
yaml::Node &getNode() const { return Node; }
private:
StringRef Message; // No need to hold a full copy of the buffer.
yaml::Node &Node;
};
char ParseError::ID = 0;
static LLVMRemarkStringRef toRemarkStr(StringRef Str) {
return {Str.data(), static_cast<uint32_t>(Str.size())};
}
Error YAMLRemarkParser::parseKey(StringRef &Result, yaml::KeyValueNode &Node) {
auto *Key = dyn_cast<yaml::ScalarNode>(Node.getKey());
if (!Key)
return make_error<ParseError>("key is not a string.", Node);
Result = Key->getRawValue();
return Error::success();
}
Error YAMLRemarkParser::parseValue(StringRef &Result,
yaml::KeyValueNode &Node) {
auto *Value = dyn_cast<yaml::ScalarNode>(Node.getValue());
if (!Value)
return make_error<ParseError>("expected a value of scalar type.", Node);
Result = Value->getRawValue();
if (Result.front() == '\'')
Result = Result.drop_front();
if (Result.back() == '\'')
Result = Result.drop_back();
return Error::success();
}
Error YAMLRemarkParser::parseValue(Optional<unsigned> &Result,
yaml::KeyValueNode &Node) {
SmallVector<char, 4> Tmp;
auto *Value = dyn_cast<yaml::ScalarNode>(Node.getValue());
if (!Value)
return make_error<ParseError>("expected a value of scalar type.", Node);
unsigned UnsignedValue = 0;
if (Value->getValue(Tmp).getAsInteger(10, UnsignedValue))
return make_error<ParseError>("expected a value of integer type.", *Value);
Result = UnsignedValue;
return Error::success();
}
Error YAMLRemarkParser::parseDebugLoc(Optional<StringRef> &File,
Optional<unsigned> &Line,
Optional<unsigned> &Column,
yaml::KeyValueNode &Node) {
auto *DebugLoc = dyn_cast<yaml::MappingNode>(Node.getValue());
if (!DebugLoc)
return make_error<ParseError>("expected a value of mapping type.", Node);
for (yaml::KeyValueNode &DLNode : *DebugLoc) {
StringRef KeyName;
if (Error E = parseKey(KeyName, DLNode))
return E;
if (KeyName == "File") {
File = StringRef(); // Set the optional to contain a default constructed
// value, to be passed to the parsing function.
if (Error E = parseValue(*File, DLNode))
return E;
} else if (KeyName == "Column") {
if (Error E = parseValue(Column, DLNode))
return E;
} else if (KeyName == "Line") {
if (Error E = parseValue(Line, DLNode))
return E;
} else {
return make_error<ParseError>("unknown entry in DebugLoc map.", DLNode);
}
}
// If any of the debug loc fields is missing, return an error.
if (!File || !Line || !Column)
return make_error<ParseError>("DebugLoc node incomplete.", Node);
return Error::success();
}
Error YAMLRemarkParser::parseArg(SmallVectorImpl<LLVMRemarkArg> &Args,
yaml::Node &Node) {
auto *ArgMap = dyn_cast<yaml::MappingNode>(&Node);
if (!ArgMap)
return make_error<ParseError>("expected a value of mapping type.", Node);
StringRef ValueStr;
StringRef KeyStr;
Optional<StringRef> File;
Optional<unsigned> Line;
Optional<unsigned> Column;
for (yaml::KeyValueNode &ArgEntry : *ArgMap) {
StringRef KeyName;
if (Error E = parseKey(KeyName, ArgEntry))
return E;
// Try to parse debug locs.
if (KeyName == "DebugLoc") {
// Can't have multiple DebugLoc entries per argument.
if (File || Line || Column)
return make_error<ParseError>(
"only one DebugLoc entry is allowed per argument.", ArgEntry);
if (Error E = parseDebugLoc(File, Line, Column, ArgEntry))
return E;
continue;
}
// If we already have a string, error out.
if (!ValueStr.empty())
return make_error<ParseError>(
"only one string entry is allowed per argument.", ArgEntry);
// Try to parse a string.
if (Error E = parseValue(ValueStr, ArgEntry))
return E;
// Keep the key from the string.
KeyStr = KeyName;
}
if (KeyStr.empty())
return make_error<ParseError>("argument key is missing.", *ArgMap);
if (ValueStr.empty())
return make_error<ParseError>("argument value is missing.", *ArgMap);
Args.push_back(LLVMRemarkArg{
toRemarkStr(KeyStr), toRemarkStr(ValueStr),
LLVMRemarkDebugLoc{toRemarkStr(File.getValueOr(StringRef())),
Line.getValueOr(0), Column.getValueOr(0)}});
return Error::success();
}
Error YAMLRemarkParser::parseYAMLElement(yaml::Document &Remark) {
// Parsing a new remark, clear the previous one.
LastRemark = None;
State = ParseState(TmpArgs);
auto *Root = dyn_cast<yaml::MappingNode>(Remark.getRoot());
if (!Root)
return make_error<ParseError>("document root is not of mapping type.",
*Remark.getRoot());
State.Type = Root->getRawTag();
for (yaml::KeyValueNode &RemarkField : *Root) {
StringRef KeyName;
if (Error E = parseKey(KeyName, RemarkField))
return E;
if (KeyName == "Pass") {
if (Error E = parseValue(State.Pass, RemarkField))
return E;
} else if (KeyName == "Name") {
if (Error E = parseValue(State.Name, RemarkField))
return E;
} else if (KeyName == "Function") {
if (Error E = parseValue(State.Function, RemarkField))
return E;
} else if (KeyName == "Hotness") {
if (Error E = parseValue(State.Hotness, RemarkField))
return E;
} else if (KeyName == "DebugLoc") {
if (Error E =
parseDebugLoc(State.File, State.Line, State.Column, RemarkField))
return E;
} else if (KeyName == "Args") {
auto *Args = dyn_cast<yaml::SequenceNode>(RemarkField.getValue());
if (!Args)
return make_error<ParseError>("wrong value type for key.", RemarkField);
for (yaml::Node &Arg : *Args)
if (Error E = parseArg(*State.Args, Arg))
return E;
} else {
return make_error<ParseError>("unknown key.", RemarkField);
}
}
// If the YAML parsing failed, don't even continue parsing. We might
// encounter malformed YAML.
if (Stream.failed())
return make_error<ParseError>("YAML parsing failed.", *Remark.getRoot());
// Check if any of the mandatory fields are missing.
if (State.Type.empty() || State.Pass.empty() || State.Name.empty() ||
State.Function.empty())
return make_error<ParseError>("Type, Pass, Name or Function missing.",
*Remark.getRoot());
LastRemark = LLVMRemarkEntry{
toRemarkStr(State.Type),
toRemarkStr(State.Pass),
toRemarkStr(State.Name),
toRemarkStr(State.Function),
LLVMRemarkDebugLoc{toRemarkStr(State.File.getValueOr(StringRef())),
State.Line.getValueOr(0), State.Column.getValueOr(0)},
State.Hotness.getValueOr(0),
static_cast<uint32_t>(State.Args->size()),
State.Args->data()};
return Error::success();
}
} // namespace
// Create wrappers for C Binding types (see CBindingWrapping.h).
DEFINE_SIMPLE_CONVERSION_FUNCTIONS(YAMLRemarkParser, LLVMRemarkParserRef)
extern "C" LLVMRemarkParserRef LLVMRemarkParserCreate(const void *Buf,
uint64_t Size) {
return wrap(
new YAMLRemarkParser(StringRef(static_cast<const char *>(Buf), Size)));
}
extern "C" LLVMRemarkEntry *
LLVMRemarkParserGetNext(LLVMRemarkParserRef Parser) {
YAMLRemarkParser &TheParser = *unwrap(Parser);
// Check for EOF.
if (Impl.YAMLIt == Impl.YAMLParser.Stream.end())
if (TheParser.HadAnyErrors || TheParser.DI == TheParser.Stream.end())
return nullptr;
auto CurrentIt = Impl.YAMLIt;
// Try to parse an entry.
if (Error E = YAMLParser.parseYAMLElement(*CurrentIt)) {
// Set the iterator to the end, in case the user calls getNext again.
Impl.YAMLIt = Impl.YAMLParser.Stream.end();
return std::move(E);
if (Error E = TheParser.parseYAMLElement(*TheParser.DI)) {
handleAllErrors(std::move(E), [&](const ParseError &PE) {
TheParser.Stream.printError(&PE.getNode(),
Twine(PE.getMessage()) + Twine('\n'));
TheParser.HadAnyErrors = true;
});
return nullptr;
}
// Move on.
++Impl.YAMLIt;
++TheParser.DI;
// Return the just-parsed remark.
if (const Optional<YAMLRemarkParser::ParseState> &State = YAMLParser.State)
return &State->Remark;
else
return createStringError(std::make_error_code(std::errc::invalid_argument),
"unexpected error while parsing.");
}
Expected<const Remark *> Parser::getNext() const {
if (auto *Impl = dyn_cast<YAMLParserImpl>(this->Impl.get()))
return getNextYAML(*Impl);
llvm_unreachable("Get next called with an unknown parsing implementation.");
}
// Create wrappers for C Binding types (see CBindingWrapping.h).
DEFINE_SIMPLE_CONVERSION_FUNCTIONS(remarks::Parser, LLVMRemarkParserRef)
extern "C" LLVMRemarkParserRef LLVMRemarkParserCreateYAML(const void *Buf,
uint64_t Size) {
return wrap(
new remarks::Parser(StringRef(static_cast<const char *>(Buf), Size)));
}
static void handleYAMLError(remarks::YAMLParserImpl &Impl, Error E) {
handleAllErrors(
std::move(E),
[&](const YAMLParseError &PE) {
Impl.YAMLParser.Stream.printError(&PE.getNode(),
Twine(PE.getMessage()) + Twine('\n'));
Impl.HasErrors = true;
},
[&](const StringError &PE) { PE.log(Impl.YAMLParser.ErrorStream); });
}
extern "C" LLVMRemarkEntryRef
LLVMRemarkParserGetNext(LLVMRemarkParserRef Parser) {
remarks::Parser &TheParser = *unwrap(Parser);
Expected<const remarks::Remark *> RemarkOrErr = TheParser.getNext();
if (!RemarkOrErr) {
// Error during parsing.
if (auto *Impl = dyn_cast<remarks::YAMLParserImpl>(TheParser.Impl.get()))
handleYAMLError(*Impl, RemarkOrErr.takeError());
else
llvm_unreachable("unkown parser implementation.");
return nullptr;
}
if (*RemarkOrErr == nullptr)
return nullptr;
// Valid remark.
return wrap(*RemarkOrErr);
if (Optional<LLVMRemarkEntry> &Entry = TheParser.LastRemark)
return &*Entry;
return nullptr;
}
extern "C" LLVMBool LLVMRemarkParserHasError(LLVMRemarkParserRef Parser) {
if (auto *Impl =
dyn_cast<remarks::YAMLParserImpl>(unwrap(Parser)->Impl.get()))
return Impl->HasErrors;
llvm_unreachable("unkown parser implementation.");
return unwrap(Parser)->HadAnyErrors;
}
extern "C" const char *
LLVMRemarkParserGetErrorMessage(LLVMRemarkParserRef Parser) {
if (auto *Impl =
dyn_cast<remarks::YAMLParserImpl>(unwrap(Parser)->Impl.get()))
return Impl->YAMLParser.ErrorStream.str().c_str();
llvm_unreachable("unkown parser implementation.");
return unwrap(Parser)->ErrorStream.str().c_str();
}
extern "C" void LLVMRemarkParserDispose(LLVMRemarkParserRef Parser) {

29
lib/Remarks/RemarkParserImpl.h
View File

@ -1,29 +0,0 @@
//===-- RemarkParserImpl.h - Implementation details -------------*- C++/-*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file provides implementation details for the remark parser.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_REMARKS_REMARK_PARSER_IMPL_H
#define LLVM_REMARKS_REMARK_PARSER_IMPL_H
namespace llvm {
namespace remarks {
/// This is used as a base for any parser implementation.
struct ParserImpl {
enum class Kind { YAML };
// The parser kind. This is used as a tag to safely cast between
// implementations.
enum Kind Kind;
};
} // end namespace remarks
} // end namespace llvm
#endif /* LLVM_REMARKS_REMARK_PARSER_IMPL_H */

261
lib/Remarks/YAMLRemarkParser.cpp
View File

@ -1,261 +0,0 @@
//===- YAMLRemarkParser.cpp -----------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file provides utility methods used by clients that want to use the
// parser for remark diagnostics in LLVM.
//
//===----------------------------------------------------------------------===//
#include "YAMLRemarkParser.h"
#include "llvm/ADT/StringSwitch.h"
#include "llvm/Remarks/RemarkParser.h"
using namespace llvm;
using namespace llvm::remarks;
char YAMLParseError::ID = 0;
Error YAMLRemarkParser::parseKey(StringRef &Result, yaml::KeyValueNode &Node) {
if (auto *Key = dyn_cast<yaml::ScalarNode>(Node.getKey())) {
Result = Key->getRawValue();
return Error::success();
}
return make_error<YAMLParseError>("key is not a string.", Node);
}
template <typename T>
Error YAMLRemarkParser::parseStr(T &Result, yaml::KeyValueNode &Node) {
auto *Value = dyn_cast<yaml::ScalarNode>(Node.getValue());
if (!Value)
return make_error<YAMLParseError>("expected a value of scalar type.", Node);
StringRef Tmp = Value->getRawValue();
if (Tmp.front() == '\'')
Tmp = Tmp.drop_front();
if (Tmp.back() == '\'')
Tmp = Tmp.drop_back();
Result = Tmp;
return Error::success();
}
template <typename T>
Error YAMLRemarkParser::parseUnsigned(T &Result, yaml::KeyValueNode &Node) {
SmallVector<char, 4> Tmp;
auto *Value = dyn_cast<yaml::ScalarNode>(Node.getValue());
if (!Value)
return make_error<YAMLParseError>("expected a value of scalar type.", Node);
unsigned UnsignedValue = 0;
if (Value->getValue(Tmp).getAsInteger(10, UnsignedValue))
return make_error<YAMLParseError>("expected a value of integer type.",
*Value);
Result = UnsignedValue;
return Error::success();
}
Error YAMLRemarkParser::parseType(Type &Result, yaml::MappingNode &Node) {
auto Type = StringSwitch<remarks::Type>(Node.getRawTag())
.Case("!Passed", Type::Passed)
.Case("!Missed", Type::Missed)
.Case("!Analysis", Type::Analysis)
.Case("!AnalysisFPCommute", Type::AnalysisFPCommute)
.Case("!AnalysisAliasing", Type::AnalysisAliasing)
.Case("!Failure", Type::Failure)
.Default(Type::Unknown);
if (Type == Type::Unknown)
return make_error<YAMLParseError>("expected a remark tag.", Node);
Result = Type;
return Error::success();
}
Error YAMLRemarkParser::parseDebugLoc(Optional<RemarkLocation> &Result,
yaml::KeyValueNode &Node) {
auto *DebugLoc = dyn_cast<yaml::MappingNode>(Node.getValue());
if (!DebugLoc)
return make_error<YAMLParseError>("expected a value of mapping type.",
Node);
Optional<StringRef> File;
Optional<unsigned> Line;
Optional<unsigned> Column;
for (yaml::KeyValueNode &DLNode : *DebugLoc) {
StringRef KeyName;
if (Error E = parseKey(KeyName, DLNode))
return E;
if (KeyName == "File") {
if (Error E = parseStr(File, DLNode))
return E;
} else if (KeyName == "Column") {
if (Error E = parseUnsigned(Column, DLNode))
return E;
} else if (KeyName == "Line") {
if (Error E = parseUnsigned(Line, DLNode))
return E;
} else {
return make_error<YAMLParseError>("unknown entry in DebugLoc map.",
DLNode);
}
}
// If any of the debug loc fields is missing, return an error.
if (!File || !Line || !Column)
return make_error<YAMLParseError>("DebugLoc node incomplete.", Node);
Result = RemarkLocation{*File, *Line, *Column};
return Error::success();
}
Error YAMLRemarkParser::parseRemarkField(yaml::KeyValueNode &RemarkField) {
StringRef KeyName;
if (Error E = parseKey(KeyName, RemarkField))
return E;
if (KeyName == "Pass") {
if (Error E = parseStr(State->Remark.PassName, RemarkField))
return E;
} else if (KeyName == "Name") {
if (Error E = parseStr(State->Remark.RemarkName, RemarkField))
return E;
} else if (KeyName == "Function") {
if (Error E = parseStr(State->Remark.FunctionName, RemarkField))
return E;
} else if (KeyName == "Hotness") {
State->Remark.Hotness = 0;
if (Error E = parseUnsigned(*State->Remark.Hotness, RemarkField))
return E;
} else if (KeyName == "DebugLoc") {
if (Error E = parseDebugLoc(State->Remark.Loc, RemarkField))
return E;
} else if (KeyName == "Args") {
auto *Args = dyn_cast<yaml::SequenceNode>(RemarkField.getValue());
if (!Args)
return make_error<YAMLParseError>("wrong value type for key.",
RemarkField);
for (yaml::Node &Arg : *Args)
if (Error E = parseArg(State->Args, Arg))
return E;
State->Remark.Args = State->Args;
} else {
return make_error<YAMLParseError>("unknown key.", RemarkField);
}
return Error::success();
}
Error YAMLRemarkParser::parseArg(SmallVectorImpl<Argument> &Args,
yaml::Node &Node) {
auto *ArgMap = dyn_cast<yaml::MappingNode>(&Node);
if (!ArgMap)
return make_error<YAMLParseError>("expected a value of mapping type.",
Node);
StringRef KeyStr;
StringRef ValueStr;
Optional<RemarkLocation> Loc;
for (yaml::KeyValueNode &ArgEntry : *ArgMap)
if (Error E = parseArgEntry(ArgEntry, KeyStr, ValueStr, Loc))
return E;
if (KeyStr.empty())
return make_error<YAMLParseError>("argument key is missing.", *ArgMap);
if (ValueStr.empty())
return make_error<YAMLParseError>("argument value is missing.", *ArgMap);
Args.push_back(Argument{KeyStr, ValueStr, Loc});
return Error::success();
}
Error YAMLRemarkParser::parseArgEntry(yaml::KeyValueNode &ArgEntry,
StringRef &KeyStr, StringRef &ValueStr,
Optional<RemarkLocation> &Loc) {
StringRef KeyName;
if (Error E = parseKey(KeyName, ArgEntry))
return E;
// Try to parse debug locs.
if (KeyName == "DebugLoc") {
// Can't have multiple DebugLoc entries per argument.
if (Loc)
return make_error<YAMLParseError>(
"only one DebugLoc entry is allowed per argument.", ArgEntry);
if (Error E = parseDebugLoc(Loc, ArgEntry))
return E;
return Error::success();
}
// If we already have a string, error out.
if (!ValueStr.empty())
return make_error<YAMLParseError>(
"only one string entry is allowed per argument.", ArgEntry);
// Try to parse a string.
if (Error E = parseStr(ValueStr, ArgEntry))
return E;
// Keep the key from the string.
KeyStr = KeyName;
return Error::success();
}
Error YAMLRemarkParser::parseYAMLElement(yaml::Document &Remark) {
// Parsing a new remark, clear the previous one by re-constructing the state
// in-place in the Optional.
State.emplace(TmpArgs);
yaml::Node *YAMLRoot = Remark.getRoot();
if (!YAMLRoot)
return createStringError(std::make_error_code(std::errc::invalid_argument),
"not a valid YAML file.");
auto *Root = dyn_cast<yaml::MappingNode>(YAMLRoot);
if (!Root)
return make_error<YAMLParseError>("document root is not of mapping type.",
*YAMLRoot);
if (Error E = parseType(State->Remark.RemarkType, *Root))
return E;
for (yaml::KeyValueNode &RemarkField : *Root)
if (Error E = parseRemarkField(RemarkField))
return E;
// If the YAML parsing failed, don't even continue parsing. We might
// encounter malformed YAML.
if (Stream.failed())
return make_error<YAMLParseError>("YAML parsing failed.",
*Remark.getRoot());
// Check if any of the mandatory fields are missing.
if (State->Remark.RemarkType == Type::Unknown ||
State->Remark.PassName.empty() || State->Remark.RemarkName.empty() ||
State->Remark.FunctionName.empty())
return make_error<YAMLParseError>("Type, Pass, Name or Function missing.",
*Remark.getRoot());
return Error::success();
}
/// Handle a diagnostic from the YAML stream. Records the error in the
/// YAMLRemarkParser class.
void YAMLRemarkParser::HandleDiagnostic(const SMDiagnostic &Diag, void *Ctx) {
assert(Ctx && "Expected non-null Ctx in diagnostic handler.");
auto *Parser = static_cast<YAMLRemarkParser *>(Ctx);
Diag.print(/*ProgName=*/nullptr, Parser->ErrorStream, /*ShowColors*/ false,
/*ShowKindLabels*/ true);
}

136
lib/Remarks/YAMLRemarkParser.h
View File

@ -1,136 +0,0 @@
//===-- YAMLRemarkParser.h - Parser for YAML remarks ------------*- C++/-*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file provides the impementation of the YAML remark parser.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_REMARKS_YAML_REMARK_PARSER_H
#define LLVM_REMARKS_YAML_REMARK_PARSER_H
#include "RemarkParserImpl.h"
#include "llvm/ADT/Optional.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/Remarks/Remark.h"
#include "llvm/Support/Error.h"
#include "llvm/Support/SourceMgr.h"
#include "llvm/Support/YAMLParser.h"
#include "llvm/Support/YAMLTraits.h"
#include "llvm/Support/raw_ostream.h"
#include <string>
namespace llvm {
namespace remarks {
/// Parses and holds the state of the latest parsed remark.
struct YAMLRemarkParser {
/// Source manager for better error messages.
SourceMgr SM;
/// Stream for yaml parsing.
yaml::Stream Stream;
/// Storage for the error stream.
std::string ErrorString;
/// The error stream.
raw_string_ostream ErrorStream;
/// Temporary parsing buffer for the arguments.
SmallVector<Argument, 8> TmpArgs;
/// The state used by the parser to parse a remark entry. Invalidated with
/// every call to `parseYAMLElement`.
struct ParseState {
/// Temporary parsing buffer for the arguments.
/// The parser itself is owning this buffer in order to reduce the number of
/// allocations.
SmallVectorImpl<Argument> &Args;
Remark Remark;
ParseState(SmallVectorImpl<Argument> &Args) : Args(Args) {}
/// Use Args only as a **temporary** buffer.
~ParseState() { Args.clear(); }
};
/// The current state of the parser. If the parsing didn't start yet, it will
/// not be containing any value.
Optional<ParseState> State;
YAMLRemarkParser(StringRef Buf)
: SM(), Stream(Buf, SM), ErrorString(), ErrorStream(ErrorString),
TmpArgs() {
SM.setDiagHandler(YAMLRemarkParser::HandleDiagnostic, this);
}
/// Parse a YAML element.
Error parseYAMLElement(yaml::Document &Remark);
private:
/// Parse one key to a string.
/// otherwise.
Error parseKey(StringRef &Result, yaml::KeyValueNode &Node);
/// Parse one value to a string.
template <typename T> Error parseStr(T &Result, yaml::KeyValueNode &Node);
/// Parse one value to an unsigned.
template <typename T>
Error parseUnsigned(T &Result, yaml::KeyValueNode &Node);
/// Parse the type of a remark to an enum type.
Error parseType(Type &Result, yaml::MappingNode &Node);
/// Parse a debug location.
Error parseDebugLoc(Optional<RemarkLocation> &Result,
yaml::KeyValueNode &Node);
/// Parse a remark field and update the parsing state.
Error parseRemarkField(yaml::KeyValueNode &RemarkField);
/// Parse an argument.
Error parseArg(SmallVectorImpl<Argument> &TmpArgs, yaml::Node &Node);
/// Parse an entry from the contents of an argument.
Error parseArgEntry(yaml::KeyValueNode &ArgEntry, StringRef &KeyStr,
StringRef &ValueStr, Optional<RemarkLocation> &Loc);
/// Handle a diagnostic from the YAML stream. Records the error in the
/// YAMLRemarkParser class.
static void HandleDiagnostic(const SMDiagnostic &Diag, void *Ctx);
};
class YAMLParseError : public ErrorInfo<YAMLParseError> {
public:
static char ID;
YAMLParseError(StringRef Message, yaml::Node &Node)
: Message(Message), Node(Node) {}
void log(raw_ostream &OS) const override { OS << Message; }
std::error_code convertToErrorCode() const override {
return inconvertibleErrorCode();
}
StringRef getMessage() const { return Message; }
yaml::Node &getNode() const { return Node; }
private:
StringRef Message; // No need to hold a full copy of the buffer.
yaml::Node &Node;
};
/// Regular YAML to Remark parser.
struct YAMLParserImpl : public ParserImpl {
/// The object parsing the YAML.
YAMLRemarkParser YAMLParser;
/// Iterator in the YAML stream.
yaml::document_iterator YAMLIt;
/// Set to `true` if we had any errors during parsing.
bool HasErrors = false;
YAMLParserImpl(StringRef Buf)
: ParserImpl{ParserImpl::Kind::YAML}, YAMLParser(Buf),
YAMLIt(YAMLParser.Stream.begin()), HasErrors(false) {}
static bool classof(const ParserImpl *PI) {
return PI->Kind == ParserImpl::Kind::YAML;
}
};
} // end namespace remarks
} // end namespace llvm
#endif /* LLVM_REMARKS_YAML_REMARK_PARSER_H */

72
tools/llvm-opt-report/OptReport.cpp
View File

@ -15,7 +15,6 @@
#include "llvm-c/Remarks.h"
#include "llvm/Demangle/Demangle.h"
#include "llvm/Remarks/RemarkParser.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Error.h"
#include "llvm/Support/ErrorOr.h"
@ -152,44 +151,40 @@ static bool readLocationInfo(LocationInfoTy &LocationInfo) {
return false;
}
remarks::Parser Parser((*Buf)->getBuffer());
StringRef Buffer = (*Buf)->getBuffer();
LLVMRemarkParserRef Parser =
LLVMRemarkParserCreate(Buffer.data(), Buffer.size());
while (true) {
Expected<const remarks::Remark *> RemarkOrErr = Parser.getNext();
if (!RemarkOrErr) {
handleAllErrors(RemarkOrErr.takeError(), [&](const ErrorInfoBase &PE) {
PE.log(WithColor::error());
});
return false;
}
if (!*RemarkOrErr) // End of file.
break;
const remarks::Remark &Remark = **RemarkOrErr;
bool Transformed = Remark.RemarkType == remarks::Type::Passed;
LLVMRemarkEntry *Remark = nullptr;
while ((Remark = LLVMRemarkParserGetNext(Parser))) {
bool Transformed =
StringRef(Remark->RemarkType.Str, Remark->RemarkType.Len) == "!Passed";
StringRef Pass(Remark->PassName.Str, Remark->PassName.Len);
StringRef File(Remark->DebugLoc.SourceFile.Str,
Remark->DebugLoc.SourceFile.Len);
StringRef Function(Remark->FunctionName.Str, Remark->FunctionName.Len);
uint32_t Line = Remark->DebugLoc.SourceLineNumber;
uint32_t Column = Remark->DebugLoc.SourceColumnNumber;
ArrayRef<LLVMRemarkArg> Args(Remark->Args, Remark->NumArgs);
int VectorizationFactor = 1;
int InterleaveCount = 1;
int UnrollCount = 1;
for (const remarks::Argument &Arg : Remark.Args) {
if (Arg.Key == "VectorizationFactor")
Arg.Val.getAsInteger(10, VectorizationFactor);
else if (Arg.Key == "InterleaveCount")
Arg.Val.getAsInteger(10, InterleaveCount);
else if (Arg.Key == "UnrollCount")
Arg.Val.getAsInteger(10, UnrollCount);
for (const LLVMRemarkArg &Arg : Args) {
StringRef ArgKeyName(Arg.Key.Str, Arg.Key.Len);
StringRef ArgValue(Arg.Value.Str, Arg.Value.Len);
if (ArgKeyName == "VectorizationFactor")
ArgValue.getAsInteger(10, VectorizationFactor);
else if (ArgKeyName == "InterleaveCount")
ArgValue.getAsInteger(10, InterleaveCount);
else if (ArgKeyName == "UnrollCount")
ArgValue.getAsInteger(10, UnrollCount);
}
const Optional<remarks::RemarkLocation> &Loc = Remark.Loc;
if (!Loc)
if (Line < 1 || File.empty())
continue;
StringRef File = Loc->SourceFilePath;
unsigned Line = Loc->SourceLine;
unsigned Column = Loc->SourceColumn;
// We track information on both actual and potential transformations. This
// way, if there are multiple possible things on a line that are, or could
// have been transformed, we can indicate that explicitly in the output.
@ -199,22 +194,27 @@ static bool readLocationInfo(LocationInfoTy &LocationInfo) {
LLII.Transformed = true;
};
if (Remark.PassName == "inline") {
auto &LI = LocationInfo[File][Line][Remark.FunctionName][Column];
if (Pass == "inline") {
auto &LI = LocationInfo[File][Line][Function][Column];
UpdateLLII(LI.Inlined);
} else if (Remark.PassName == "loop-unroll") {
auto &LI = LocationInfo[File][Line][Remark.FunctionName][Column];
} else if (Pass == "loop-unroll") {
auto &LI = LocationInfo[File][Line][Function][Column];
LI.UnrollCount = UnrollCount;
UpdateLLII(LI.Unrolled);
} else if (Remark.PassName == "loop-vectorize") {
auto &LI = LocationInfo[File][Line][Remark.FunctionName][Column];
} else if (Pass == "loop-vectorize") {
auto &LI = LocationInfo[File][Line][Function][Column];
LI.VectorizationFactor = VectorizationFactor;
LI.InterleaveCount = InterleaveCount;
UpdateLLII(LI.Vectorized);
}
}
return true;
bool HasError = LLVMRemarkParserHasError(Parser);
if (HasError)
WithColor::error() << LLVMRemarkParserGetErrorMessage(Parser) << "\n";
LLVMRemarkParserDispose(Parser);
return !HasError;
}
static bool writeReport(LocationInfoTy &LocationInfo) {

19
tools/remarks-shlib/Remarks.exports
View File

@ -1,21 +1,4 @@
LLVMRemarkStringGetData
LLVMRemarkStringGetLen
LLVMRemarkDebugLocGetSourceFilePath
LLVMRemarkDebugLocGetSourceLine
LLVMRemarkDebugLocGetSourceColumn
LLVMRemarkArgGetKey
LLVMRemarkArgGetValue
LLVMRemarkArgGetDebugLoc
LLVMRemarkEntryGetType
LLVMRemarkEntryGetPassName
LLVMRemarkEntryGetRemarkName
LLVMRemarkEntryGetFunctionName
LLVMRemarkEntryGetDebugLoc
LLVMRemarkEntryGetHotness
LLVMRemarkEntryGetNumArgs
LLVMRemarkEntryGetFirstArg
LLVMRemarkEntryGetNextArg
LLVMRemarkParserCreateYAML
LLVMRemarkParserCreate
LLVMRemarkParserGetNext
LLVMRemarkParserHasError
LLVMRemarkParserGetErrorMessage

2
unittests/Remarks/CMakeLists.txt
View File

@ -4,5 +4,5 @@ set(LLVM_LINK_COMPONENTS
)
add_llvm_unittest(RemarksTests
YAMLRemarksParsingTest.cpp
RemarksParsingTest.cpp
)

436
unittests/Remarks/RemarksParsingTest.cpp Normal file
View File

@ -0,0 +1,436 @@
//===- unittest/Support/RemarksParsingTest.cpp - OptTable tests --------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "llvm-c/Remarks.h"
#include "gtest/gtest.h"
using namespace llvm;
template <size_t N> bool tryParse(const char (&Buf)[N]) {
LLVMRemarkParserRef Parser = LLVMRemarkParserCreate(Buf, N - 1);
LLVMRemarkEntry *Remark = nullptr;
while (LLVMRemarkEntry *NewRemark = LLVMRemarkParserGetNext(Parser)) {
EXPECT_TRUE(Remark == nullptr); // Only one remark per test.
Remark = NewRemark;
}
EXPECT_TRUE(Remark != nullptr); // We need *exactly* one remark per test.
bool HasError = LLVMRemarkParserHasError(Parser);
LLVMRemarkParserDispose(Parser);
return !HasError;
}
template <size_t N>
bool parseExpectError(const char (&Buf)[N], const char *Error) {
LLVMRemarkParserRef Parser = LLVMRemarkParserCreate(Buf, N - 1);
LLVMRemarkEntry *Remark = nullptr;
while (LLVMRemarkEntry *NewRemark = LLVMRemarkParserGetNext(Parser)) {
EXPECT_FALSE(NewRemark);
}
EXPECT_TRUE(Remark == nullptr); // We are parsing only one malformed remark.
EXPECT_TRUE(LLVMRemarkParserHasError(Parser));
bool MatchesError =
StringRef(LLVMRemarkParserGetErrorMessage(Parser)).contains(Error);
LLVMRemarkParserDispose(Parser);
return MatchesError;
}
TEST(Remarks, RemarksParsingEmpty) {
StringRef Buf = "\n"
"\n";
LLVMRemarkParserRef Parser = LLVMRemarkParserCreate(Buf.data(), Buf.size());
LLVMRemarkEntry *NewRemark = LLVMRemarkParserGetNext(Parser);
EXPECT_TRUE(NewRemark == nullptr); // No remark expected.
EXPECT_TRUE(LLVMRemarkParserHasError(Parser));
EXPECT_TRUE(StringRef(LLVMRemarkParserGetErrorMessage(Parser))
.contains("document root is not of mapping type."));
LLVMRemarkParserDispose(Parser);
}
TEST(Remarks, RemarksParsingGood) {
EXPECT_TRUE(tryParse("\n"
"--- !Missed\n"
"Pass: inline\n"
"Name: NoDefinition\n"
"DebugLoc: { File: file.c, Line: 3, Column: 12 }\n"
"Function: foo\n"
"Args:\n"
" - Callee: bar\n"
" - String: ' will not be inlined into '\n"
" - Caller: foo\n"
" DebugLoc: { File: file.c, Line: 2, Column: 0 }\n"
" - String: ' because its definition is unavailable'\n"
""));
// No debug loc should also pass.
EXPECT_TRUE(tryParse("\n"
"--- !Missed\n"
"Pass: inline\n"
"Name: NoDefinition\n"
"Function: foo\n"
"Args:\n"
" - Callee: bar\n"
" - String: ' will not be inlined into '\n"
" - Caller: foo\n"
" DebugLoc: { File: file.c, Line: 2, Column: 0 }\n"
" - String: ' because its definition is unavailable'\n"
""));
// No args is also ok.
EXPECT_TRUE(tryParse("\n"
"--- !Missed\n"
"Pass: inline\n"
"Name: NoDefinition\n"
"DebugLoc: { File: file.c, Line: 3, Column: 12 }\n"
"Function: foo\n"
""));
// Different order.
EXPECT_TRUE(tryParse("\n"
"--- !Missed\n"
"DebugLoc: { Line: 3, Column: 12, File: file.c }\n"
"Function: foo\n"
"Name: NoDefinition\n"
"Args:\n"
" - Callee: bar\n"
" - String: ' will not be inlined into '\n"
" - Caller: foo\n"
" DebugLoc: { File: file.c, Line: 2, Column: 0 }\n"
" - String: ' because its definition is unavailable'\n"
"Pass: inline\n"
""));
}
// Mandatory common part of a remark.
#define COMMON_REMARK "\nPass: inline\nName: NoDefinition\nFunction: foo\n\n"
// Test all the types.
TEST(Remarks, RemarksParsingTypes) {
// Type: Passed
EXPECT_TRUE(tryParse("--- !Passed" COMMON_REMARK));
// Type: Missed
EXPECT_TRUE(tryParse("--- !Missed" COMMON_REMARK));
// Type: Analysis
EXPECT_TRUE(tryParse("--- !Analysis" COMMON_REMARK));
// Type: AnalysisFPCompute
EXPECT_TRUE(tryParse("--- !AnalysisFPCompute" COMMON_REMARK));
// Type: AnalysisAliasing
EXPECT_TRUE(tryParse("--- !AnalysisAliasing" COMMON_REMARK));
// Type: Failure
EXPECT_TRUE(tryParse("--- !Failure" COMMON_REMARK));
}
#undef COMMON_REMARK
TEST(Remarks, RemarksParsingMissingFields) {
// No type.
EXPECT_TRUE(parseExpectError("\n"
"---\n"
"Pass: inline\n"
"Name: NoDefinition\n"
"Function: foo\n"
"",
"error: Type, Pass, Name or Function missing."));
// No pass.
EXPECT_TRUE(parseExpectError("\n"
"--- !Missed\n"
"Name: NoDefinition\n"
"Function: foo\n"
"",
"error: Type, Pass, Name or Function missing."));
// No name.
EXPECT_TRUE(parseExpectError("\n"
"--- !Missed\n"
"Pass: inline\n"
"Function: foo\n"
"",
"error: Type, Pass, Name or Function missing."));
// No function.
EXPECT_TRUE(parseExpectError("\n"
"--- !Missed\n"
"Pass: inline\n"
"Name: NoDefinition\n"
"",
"error: Type, Pass, Name or Function missing."));
// Debug loc but no file.
EXPECT_TRUE(parseExpectError("\n"
"--- !Missed\n"
"Pass: inline\n"
"Name: NoDefinition\n"
"Function: foo\n"
"DebugLoc: { Line: 3, Column: 12 }\n"
"",
"DebugLoc node incomplete."));
// Debug loc but no line.
EXPECT_TRUE(parseExpectError("\n"
"--- !Missed\n"
"Pass: inline\n"
"Name: NoDefinition\n"
"Function: foo\n"
"DebugLoc: { File: file.c, Column: 12 }\n"
"",
"DebugLoc node incomplete."));
// Debug loc but no column.
EXPECT_TRUE(parseExpectError("\n"
"--- !Missed\n"
"Pass: inline\n"
"Name: NoDefinition\n"
"Function: foo\n"
"DebugLoc: { File: file.c, Line: 3 }\n"
"",
"DebugLoc node incomplete."));
}
TEST(Remarks, RemarksParsingWrongTypes) {
// Wrong debug loc type.
EXPECT_TRUE(parseExpectError("\n"
"--- !Missed\n"
"Pass: inline\n"
"Name: NoDefinition\n"
"Function: foo\n"
"DebugLoc: foo\n"
"",
"expected a value of mapping type."));
// Wrong line type.
EXPECT_TRUE(
parseExpectError("\n"
"--- !Missed\n"
"Pass: inline\n"
"Name: NoDefinition\n"
"Function: foo\n"
"DebugLoc: { File: file.c, Line: b, Column: 12 }\n"
"",
"expected a value of integer type."));
// Wrong column type.
EXPECT_TRUE(
parseExpectError("\n"
"--- !Missed\n"
"Pass: inline\n"
"Name: NoDefinition\n"
"Function: foo\n"
"DebugLoc: { File: file.c, Line: 3, Column: c }\n"
"",
"expected a value of integer type."));
// Wrong args type.
EXPECT_TRUE(parseExpectError("\n"
"--- !Missed\n"
"Pass: inline\n"
"Name: NoDefinition\n"
"Function: foo\n"
"Args: foo\n"
"",
"wrong value type for key."));
// Wrong key type.
EXPECT_TRUE(parseExpectError("\n"
"--- !Missed\n"
"{ A: a }: inline\n"
"Name: NoDefinition\n"
"Function: foo\n"
"",
"key is not a string."));
// Debug loc with unknown entry.
EXPECT_TRUE(
parseExpectError("\n"
"--- !Missed\n"
"Pass: inline\n"
"Name: NoDefinition\n"
"Function: foo\n"
"DebugLoc: { File: file.c, Column: 12, Unknown: 12 }\n"
"",
"unknown entry in DebugLoc map."));
// Unknown entry.
EXPECT_TRUE(parseExpectError("\n"
"--- !Missed\n"
"Unknown: inline\n"
"",
"unknown key."));
// Not a scalar.
EXPECT_TRUE(parseExpectError("\n"
"--- !Missed\n"
"Pass: { File: a, Line: 1, Column: 2 }\n"
"Name: NoDefinition\n"
"Function: foo\n"
"",
"expected a value of scalar type."));
// Not a string file in debug loc.
EXPECT_TRUE(
parseExpectError("\n"
"--- !Missed\n"
"Pass: inline\n"
"Name: NoDefinition\n"
"Function: foo\n"
"DebugLoc: { File: { a: b }, Column: 12, Line: 12 }\n"
"",
"expected a value of scalar type."));
// Not a integer column in debug loc.
EXPECT_TRUE(parseExpectError(
"\n"
"--- !Missed\n"
"Pass: inline\n"
"Name: NoDefinition\n"
"Function: foo\n"
"DebugLoc: { File: file.c, Column: { a: b }, Line: 12 }\n"
"",
"expected a value of scalar type."));
// Not a integer line in debug loc.
EXPECT_TRUE(parseExpectError(
"\n"
"--- !Missed\n"
"Pass: inline\n"
"Name: NoDefinition\n"
"Function: foo\n"
"DebugLoc: { File: file.c, Column: 12, Line: { a: b } }\n"
"",
"expected a value of scalar type."));
// Not a mapping type value for args.
EXPECT_TRUE(parseExpectError(
"\n"
"--- !Missed\n"
"Pass: inline\n"
"Name: NoDefinition\n"
"Function: foo\n"
"DebugLoc: { File: file.c, Column: 12, Line: { a: b } }\n"
"",
"expected a value of scalar type."));
}
TEST(Remarks, RemarksParsingWrongArgs) {
// Multiple debug locs per arg.
EXPECT_TRUE(
parseExpectError("\n"
"--- !Missed\n"
"Pass: inline\n"
"Name: NoDefinition\n"
"Function: foo\n"
"Args:\n"
" - Str: string\n"
" DebugLoc: { File: a, Line: 1, Column: 2 }\n"
" DebugLoc: { File: a, Line: 1, Column: 2 }\n"
"",
"only one DebugLoc entry is allowed per argument."));
// Multiple strings per arg.
EXPECT_TRUE(
parseExpectError("\n"
"--- !Missed\n"
"Pass: inline\n"
"Name: NoDefinition\n"
"Function: foo\n"
"Args:\n"
" - Str: string\n"
" Str2: string\n"
" DebugLoc: { File: a, Line: 1, Column: 2 }\n"
"",
"only one string entry is allowed per argument."));
// No arg value.
EXPECT_TRUE(parseExpectError("\n"
"--- !Missed\n"
"Pass: inline\n"
"Name: NoDefinition\n"
"Function: foo\n"
"Args:\n"
" - Callee: ''\n"
" - DebugLoc: { File: a, Line: 1, Column: 2 }\n"
"",
"argument value is missing."));
// No arg value.
EXPECT_TRUE(parseExpectError("\n"
"--- !Missed\n"
"Pass: inline\n"
"Name: NoDefinition\n"
"Function: foo\n"
"Args:\n"
" - DebugLoc: { File: a, Line: 1, Column: 2 }\n"
"",
"argument key is missing."));
}
TEST(Remarks, RemarksGoodStruct) {
StringRef Buf = "\n"
"--- !Missed\n"
"Pass: inline\n"
"Name: NoDefinition\n"
"DebugLoc: { File: file.c, Line: 3, Column: 12 }\n"
"Function: foo\n"
"Args:\n"
" - Callee: bar\n"
" - String: ' will not be inlined into '\n"
" - Caller: foo\n"
" DebugLoc: { File: file.c, Line: 2, Column: 0 }\n"
" - String: ' because its definition is unavailable'\n"
"\n";
LLVMRemarkParserRef Parser = LLVMRemarkParserCreate(Buf.data(), Buf.size());
LLVMRemarkEntry *Remark = LLVMRemarkParserGetNext(Parser);
EXPECT_FALSE(Remark == nullptr);
EXPECT_EQ(StringRef(Remark->RemarkType.Str, 7), "!Missed");
EXPECT_EQ(Remark->RemarkType.Len, 7U);
EXPECT_EQ(StringRef(Remark->PassName.Str, 6), "inline");
EXPECT_EQ(Remark->PassName.Len, 6U);
EXPECT_EQ(StringRef(Remark->RemarkName.Str, 12), "NoDefinition");
EXPECT_EQ(Remark->RemarkName.Len, 12U);
EXPECT_EQ(StringRef(Remark->FunctionName.Str, 3), "foo");
EXPECT_EQ(Remark->FunctionName.Len, 3U);
EXPECT_EQ(StringRef(Remark->DebugLoc.SourceFile.Str, 6), "file.c");
EXPECT_EQ(Remark->DebugLoc.SourceFile.Len, 6U);
EXPECT_EQ(Remark->DebugLoc.SourceLineNumber, 3U);
EXPECT_EQ(Remark->DebugLoc.SourceColumnNumber, 12U);
EXPECT_EQ(Remark->Hotness, 0U);
EXPECT_EQ(Remark->NumArgs, 4U);
// Arg 0
{
LLVMRemarkArg &Arg = Remark->Args[0];
EXPECT_EQ(StringRef(Arg.Key.Str, 6), "Callee");
EXPECT_EQ(Arg.Key.Len, 6U);
EXPECT_EQ(StringRef(Arg.Value.Str, 3), "bar");
EXPECT_EQ(Arg.Value.Len, 3U);
EXPECT_EQ(StringRef(Arg.DebugLoc.SourceFile.Str, 0), "");
EXPECT_EQ(Arg.DebugLoc.SourceFile.Len, 0U);
EXPECT_EQ(Arg.DebugLoc.SourceLineNumber, 0U);
EXPECT_EQ(Arg.DebugLoc.SourceColumnNumber, 0U);
}
// Arg 1
{
LLVMRemarkArg &Arg = Remark->Args[1];
EXPECT_EQ(StringRef(Arg.Key.Str, 6), "String");
EXPECT_EQ(Arg.Key.Len, 6U);
EXPECT_EQ(StringRef(Arg.Value.Str, 26), " will not be inlined into ");
EXPECT_EQ(Arg.Value.Len, 26U);
EXPECT_EQ(StringRef(Arg.DebugLoc.SourceFile.Str, 0), "");
EXPECT_EQ(Arg.DebugLoc.SourceFile.Len, 0U);
EXPECT_EQ(Arg.DebugLoc.SourceLineNumber, 0U);
EXPECT_EQ(Arg.DebugLoc.SourceColumnNumber, 0U);
}
// Arg 2
{
LLVMRemarkArg &Arg = Remark->Args[2];
EXPECT_EQ(StringRef(Arg.Key.Str, 6), "Caller");
EXPECT_EQ(Arg.Key.Len, 6U);
EXPECT_EQ(StringRef(Arg.Value.Str, 3), "foo");
EXPECT_EQ(Arg.Value.Len, 3U);
EXPECT_EQ(StringRef(Arg.DebugLoc.SourceFile.Str, 6), "file.c");
EXPECT_EQ(Arg.DebugLoc.SourceFile.Len, 6U);
EXPECT_EQ(Arg.DebugLoc.SourceLineNumber, 2U);
EXPECT_EQ(Arg.DebugLoc.SourceColumnNumber, 0U);
}
// Arg 3
{
LLVMRemarkArg &Arg = Remark->Args[3];
EXPECT_EQ(StringRef(Arg.Key.Str, 6), "String");
EXPECT_EQ(Arg.Key.Len, 6U);
EXPECT_EQ(StringRef(Arg.Value.Str, 38),
" because its definition is unavailable");
EXPECT_EQ(Arg.Value.Len, 38U);
EXPECT_EQ(StringRef(Arg.DebugLoc.SourceFile.Str, 0), "");
EXPECT_EQ(Arg.DebugLoc.SourceFile.Len, 0U);
EXPECT_EQ(Arg.DebugLoc.SourceLineNumber, 0U);
EXPECT_EQ(Arg.DebugLoc.SourceColumnNumber, 0U);
}
EXPECT_EQ(LLVMRemarkParserGetNext(Parser), nullptr);
EXPECT_FALSE(LLVMRemarkParserHasError(Parser));
LLVMRemarkParserDispose(Parser);
}

494
unittests/Remarks/YAMLRemarksParsingTest.cpp
View File

@ -1,494 +0,0 @@
//===- unittest/Support/YAMLRemarksParsingTest.cpp - OptTable tests -------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "llvm-c/Remarks.h"
#include "llvm/Remarks/Remark.h"
#include "llvm/Remarks/RemarkParser.h"
#include "gtest/gtest.h"
using namespace llvm;
template <size_t N> void parseGood(const char (&Buf)[N]) {
remarks::Parser Parser({Buf, N - 1});
Expected<const remarks::Remark *> Remark = Parser.getNext();
EXPECT_FALSE(errorToBool(Remark.takeError())); // Check for parsing errors.
EXPECT_TRUE(*Remark != nullptr); // At least one remark.
Remark = Parser.getNext();
EXPECT_FALSE(errorToBool(Remark.takeError())); // Check for parsing errors.
EXPECT_TRUE(*Remark == nullptr); // Check that there are no more remarks.
}
template <size_t N>
bool parseExpectError(const char (&Buf)[N], const char *Error) {
remarks::Parser Parser({Buf, N - 1});
Expected<const remarks::Remark *> Remark = Parser.getNext();
EXPECT_FALSE(Remark); // Expect an error here.
std::string ErrorStr;
raw_string_ostream Stream(ErrorStr);
handleAllErrors(Remark.takeError(),
[&](const ErrorInfoBase &EIB) { EIB.log(Stream); });
return StringRef(Stream.str()).contains(Error);
}
TEST(YAMLRemarks, ParsingEmpty) {
EXPECT_TRUE(parseExpectError("\n\n", "document root is not of mapping type."));
}
TEST(YAMLRemarks, ParsingNotYAML) {
EXPECT_TRUE(
parseExpectError("\x01\x02\x03\x04\x05\x06", "not a valid YAML file."));
}
TEST(YAMLRemarks, ParsingGood) {
parseGood("\n"
"--- !Missed\n"
"Pass: inline\n"
"Name: NoDefinition\n"
"DebugLoc: { File: file.c, Line: 3, Column: 12 }\n"
"Function: foo\n"
"Args:\n"
" - Callee: bar\n"
" - String: ' will not be inlined into '\n"
" - Caller: foo\n"
" DebugLoc: { File: file.c, Line: 2, Column: 0 }\n"
" - String: ' because its definition is unavailable'\n"
"");
// No debug loc should also pass.
parseGood("\n"
"--- !Missed\n"
"Pass: inline\n"
"Name: NoDefinition\n"
"Function: foo\n"
"Args:\n"
" - Callee: bar\n"
" - String: ' will not be inlined into '\n"
" - Caller: foo\n"
" DebugLoc: { File: file.c, Line: 2, Column: 0 }\n"
" - String: ' because its definition is unavailable'\n"
"");
// No args is also ok.
parseGood("\n"
"--- !Missed\n"
"Pass: inline\n"
"Name: NoDefinition\n"
"DebugLoc: { File: file.c, Line: 3, Column: 12 }\n"
"Function: foo\n"
"");
// Different order.
parseGood("\n"
"--- !Missed\n"
"DebugLoc: { Line: 3, Column: 12, File: file.c }\n"
"Function: foo\n"
"Name: NoDefinition\n"
"Args:\n"
" - Callee: bar\n"
" - String: ' will not be inlined into '\n"
" - Caller: foo\n"
" DebugLoc: { File: file.c, Line: 2, Column: 0 }\n"
" - String: ' because its definition is unavailable'\n"
"Pass: inline\n"
"");
}
// Mandatory common part of a remark.
#define COMMON_REMARK "\nPass: inline\nName: NoDefinition\nFunction: foo\n\n"
// Test all the types.
TEST(YAMLRemarks, ParsingTypes) {
// Type: Passed
parseGood("--- !Passed" COMMON_REMARK);
// Type: Missed
parseGood("--- !Missed" COMMON_REMARK);
// Type: Analysis
parseGood("--- !Analysis" COMMON_REMARK);
// Type: AnalysisFPCommute
parseGood("--- !AnalysisFPCommute" COMMON_REMARK);
// Type: AnalysisAliasing
parseGood("--- !AnalysisAliasing" COMMON_REMARK);
// Type: Failure
parseGood("--- !Failure" COMMON_REMARK);
}
#undef COMMON_REMARK
TEST(YAMLRemarks, ParsingMissingFields) {
// No type.
EXPECT_TRUE(parseExpectError("\n"
"---\n"
"Pass: inline\n"
"Name: NoDefinition\n"
"Function: foo\n"
"",
"expected a remark tag."));
// No pass.
EXPECT_TRUE(parseExpectError("\n"
"--- !Missed\n"
"Name: NoDefinition\n"
"Function: foo\n"
"",
"Type, Pass, Name or Function missing."));
// No name.
EXPECT_TRUE(parseExpectError("\n"
"--- !Missed\n"
"Pass: inline\n"
"Function: foo\n"
"",
"Type, Pass, Name or Function missing."));
// No function.
EXPECT_TRUE(parseExpectError("\n"
"--- !Missed\n"
"Pass: inline\n"
"Name: NoDefinition\n"
"",
"Type, Pass, Name or Function missing."));
// Debug loc but no file.
EXPECT_TRUE(parseExpectError("\n"
"--- !Missed\n"
"Pass: inline\n"
"Name: NoDefinition\n"
"Function: foo\n"
"DebugLoc: { Line: 3, Column: 12 }\n"
"",
"DebugLoc node incomplete."));
// Debug loc but no line.
EXPECT_TRUE(parseExpectError("\n"
"--- !Missed\n"
"Pass: inline\n"
"Name: NoDefinition\n"
"Function: foo\n"
"DebugLoc: { File: file.c, Column: 12 }\n"
"",
"DebugLoc node incomplete."));
// Debug loc but no column.
EXPECT_TRUE(parseExpectError("\n"
"--- !Missed\n"
"Pass: inline\n"
"Name: NoDefinition\n"
"Function: foo\n"
"DebugLoc: { File: file.c, Line: 3 }\n"
"",
"DebugLoc node incomplete."));
}
TEST(YAMLRemarks, ParsingWrongTypes) {
// Wrong debug loc type.
EXPECT_TRUE(parseExpectError("\n"
"--- !Missed\n"
"Pass: inline\n"
"Name: NoDefinition\n"
"Function: foo\n"
"DebugLoc: foo\n"
"",
"expected a value of mapping type."));
// Wrong line type.
EXPECT_TRUE(parseExpectError("\n"
"--- !Missed\n"
"Pass: inline\n"
"Name: NoDefinition\n"
"Function: foo\n"
"DebugLoc: { File: file.c, Line: b, Column: 12 }\n"
"",
"expected a value of integer type."));
// Wrong column type.
EXPECT_TRUE(parseExpectError("\n"
"--- !Missed\n"
"Pass: inline\n"
"Name: NoDefinition\n"
"Function: foo\n"
"DebugLoc: { File: file.c, Line: 3, Column: c }\n"
"",
"expected a value of integer type."));
// Wrong args type.
EXPECT_TRUE(parseExpectError("\n"
"--- !Missed\n"
"Pass: inline\n"
"Name: NoDefinition\n"
"Function: foo\n"
"Args: foo\n"
"",
"wrong value type for key."));
// Wrong key type.
EXPECT_TRUE(parseExpectError("\n"
"--- !Missed\n"
"{ A: a }: inline\n"
"Name: NoDefinition\n"
"Function: foo\n"
"",
"key is not a string."));
// Debug loc with unknown entry.
EXPECT_TRUE(parseExpectError("\n"
"--- !Missed\n"
"Pass: inline\n"
"Name: NoDefinition\n"
"Function: foo\n"
"DebugLoc: { File: file.c, Column: 12, Unknown: 12 }\n"
"",
"unknown entry in DebugLoc map."));
// Unknown entry.
EXPECT_TRUE(parseExpectError("\n"
"--- !Missed\n"
"Unknown: inline\n"
"",
"unknown key."));
// Not a scalar.
EXPECT_TRUE(parseExpectError("\n"
"--- !Missed\n"
"Pass: { File: a, Line: 1, Column: 2 }\n"
"Name: NoDefinition\n"
"Function: foo\n"
"",
"expected a value of scalar type."));
// Not a string file in debug loc.
EXPECT_TRUE(parseExpectError("\n"
"--- !Missed\n"
"Pass: inline\n"
"Name: NoDefinition\n"
"Function: foo\n"
"DebugLoc: { File: { a: b }, Column: 12, Line: 12 }\n"
"",
"expected a value of scalar type."));
// Not a integer column in debug loc.
EXPECT_TRUE(parseExpectError("\n"
"--- !Missed\n"
"Pass: inline\n"
"Name: NoDefinition\n"
"Function: foo\n"
"DebugLoc: { File: file.c, Column: { a: b }, Line: 12 }\n"
"",
"expected a value of scalar type."));
// Not a integer line in debug loc.
EXPECT_TRUE(parseExpectError("\n"
"--- !Missed\n"
"Pass: inline\n"
"Name: NoDefinition\n"
"Function: foo\n"
"DebugLoc: { File: file.c, Column: 12, Line: { a: b } }\n"
"",
"expected a value of scalar type."));
// Not a mapping type value for args.
EXPECT_TRUE(parseExpectError("\n"
"--- !Missed\n"
"Pass: inline\n"
"Name: NoDefinition\n"
"Function: foo\n"
"DebugLoc: { File: file.c, Column: 12, Line: { a: b } }\n"
"",
"expected a value of scalar type."));
}
TEST(YAMLRemarks, ParsingWrongArgs) {
// Multiple debug locs per arg.
EXPECT_TRUE(parseExpectError("\n"
"--- !Missed\n"
"Pass: inline\n"
"Name: NoDefinition\n"
"Function: foo\n"
"Args:\n"
" - Str: string\n"
" DebugLoc: { File: a, Line: 1, Column: 2 }\n"
" DebugLoc: { File: a, Line: 1, Column: 2 }\n"
"",
"only one DebugLoc entry is allowed per argument."));
// Multiple strings per arg.
EXPECT_TRUE(parseExpectError("\n"
"--- !Missed\n"
"Pass: inline\n"
"Name: NoDefinition\n"
"Function: foo\n"
"Args:\n"
" - Str: string\n"
" Str2: string\n"
" DebugLoc: { File: a, Line: 1, Column: 2 }\n"
"",
"only one string entry is allowed per argument."));
// No arg value.
EXPECT_TRUE(parseExpectError("\n"
"--- !Missed\n"
"Pass: inline\n"
"Name: NoDefinition\n"
"Function: foo\n"
"Args:\n"
" - Callee: ''\n"
" - DebugLoc: { File: a, Line: 1, Column: 2 }\n"
"",
"argument value is missing."));
// No arg value.
EXPECT_TRUE(parseExpectError("\n"
"--- !Missed\n"
"Pass: inline\n"
"Name: NoDefinition\n"
"Function: foo\n"
"Args:\n"
" - DebugLoc: { File: a, Line: 1, Column: 2 }\n"
"",
"argument key is missing."));
}
static inline StringRef checkStr(StringRef Str, unsigned ExpectedLen) {
const char *StrData = Str.data();
unsigned StrLen = Str.size();
EXPECT_EQ(StrLen, ExpectedLen);
return StringRef(StrData, StrLen);
}
TEST(YAMLRemarks, Contents) {
StringRef Buf = "\n"
"--- !Missed\n"
"Pass: inline\n"
"Name: NoDefinition\n"
"DebugLoc: { File: file.c, Line: 3, Column: 12 }\n"
"Function: foo\n"
"Hotness: 4\n"
"Args:\n"
" - Callee: bar\n"
" - String: ' will not be inlined into '\n"
" - Caller: foo\n"
" DebugLoc: { File: file.c, Line: 2, Column: 0 }\n"
" - String: ' because its definition is unavailable'\n"
"\n";
remarks::Parser Parser(Buf);
Expected<const remarks::Remark *> RemarkOrErr = Parser.getNext();
EXPECT_FALSE(errorToBool(RemarkOrErr.takeError()));
EXPECT_TRUE(*RemarkOrErr != nullptr);
const remarks::Remark &Remark = **RemarkOrErr;
EXPECT_EQ(Remark.RemarkType, remarks::Type::Missed);
EXPECT_EQ(checkStr(Remark.PassName, 6), "inline");
EXPECT_EQ(checkStr(Remark.RemarkName, 12), "NoDefinition");
EXPECT_EQ(checkStr(Remark.FunctionName, 3), "foo");
EXPECT_TRUE(Remark.Loc);
const remarks::RemarkLocation &RL = *Remark.Loc;
EXPECT_EQ(checkStr(RL.SourceFilePath, 6), "file.c");
EXPECT_EQ(RL.SourceLine, 3U);
EXPECT_EQ(RL.SourceColumn, 12U);
EXPECT_TRUE(Remark.Hotness);
EXPECT_EQ(*Remark.Hotness, 4U);
EXPECT_EQ(Remark.Args.size(), 4U);
unsigned ArgID = 0;
for (const remarks::Argument &Arg : Remark.Args) {
switch (ArgID) {
case 0:
EXPECT_EQ(checkStr(Arg.Key, 6), "Callee");
EXPECT_EQ(checkStr(Arg.Val, 3), "bar");
EXPECT_FALSE(Arg.Loc);
break;
case 1:
EXPECT_EQ(checkStr(Arg.Key, 6), "String");
EXPECT_EQ(checkStr(Arg.Val, 26), " will not be inlined into ");
EXPECT_FALSE(Arg.Loc);
break;
case 2: {
EXPECT_EQ(checkStr(Arg.Key, 6), "Caller");
EXPECT_EQ(checkStr(Arg.Val, 3), "foo");
EXPECT_TRUE(Arg.Loc);
const remarks::RemarkLocation &RL = *Arg.Loc;
EXPECT_EQ(checkStr(RL.SourceFilePath, 6), "file.c");
EXPECT_EQ(RL.SourceLine, 2U);
EXPECT_EQ(RL.SourceColumn, 0U);
break;
}
case 3:
EXPECT_EQ(checkStr(Arg.Key, 6), "String");
EXPECT_EQ(checkStr(Arg.Val, 38),
" because its definition is unavailable");
EXPECT_FALSE(Arg.Loc);
break;
default:
break;
}
++ArgID;
}
RemarkOrErr = Parser.getNext();
EXPECT_FALSE(errorToBool(RemarkOrErr.takeError()));
EXPECT_EQ(*RemarkOrErr, nullptr);
}
static inline StringRef checkStr(LLVMRemarkStringRef Str,
unsigned ExpectedLen) {
const char *StrData = LLVMRemarkStringGetData(Str);
unsigned StrLen = LLVMRemarkStringGetLen(Str);
EXPECT_EQ(StrLen, ExpectedLen);
return StringRef(StrData, StrLen);
}
TEST(YAMLRemarks, ContentsCAPI) {
StringRef Buf = "\n"
"--- !Missed\n"
"Pass: inline\n"
"Name: NoDefinition\n"
"DebugLoc: { File: file.c, Line: 3, Column: 12 }\n"
"Function: foo\n"
"Args:\n"
" - Callee: bar\n"
" - String: ' will not be inlined into '\n"
" - Caller: foo\n"
" DebugLoc: { File: file.c, Line: 2, Column: 0 }\n"
" - String: ' because its definition is unavailable'\n"
"\n";
LLVMRemarkParserRef Parser =
LLVMRemarkParserCreateYAML(Buf.data(), Buf.size());
LLVMRemarkEntryRef Remark = LLVMRemarkParserGetNext(Parser);
EXPECT_FALSE(Remark == nullptr);
EXPECT_EQ(LLVMRemarkEntryGetType(Remark), LLVMRemarkTypeMissed);
EXPECT_EQ(checkStr(LLVMRemarkEntryGetPassName(Remark), 6), "inline");
EXPECT_EQ(checkStr(LLVMRemarkEntryGetRemarkName(Remark), 12), "NoDefinition");
EXPECT_EQ(checkStr(LLVMRemarkEntryGetFunctionName(Remark), 3), "foo");
LLVMRemarkDebugLocRef DL = LLVMRemarkEntryGetDebugLoc(Remark);
EXPECT_EQ(checkStr(LLVMRemarkDebugLocGetSourceFilePath(DL), 6), "file.c");
EXPECT_EQ(LLVMRemarkDebugLocGetSourceLine(DL), 3U);
EXPECT_EQ(LLVMRemarkDebugLocGetSourceColumn(DL), 12U);
EXPECT_EQ(LLVMRemarkEntryGetHotness(Remark), 0U);
EXPECT_EQ(LLVMRemarkEntryGetNumArgs(Remark), 4U);
unsigned ArgID = 0;
LLVMRemarkArgRef Arg = LLVMRemarkEntryGetFirstArg(Remark);
do {
switch (ArgID) {
case 0:
EXPECT_EQ(checkStr(LLVMRemarkArgGetKey(Arg), 6), "Callee");
EXPECT_EQ(checkStr(LLVMRemarkArgGetValue(Arg), 3), "bar");
EXPECT_EQ(LLVMRemarkArgGetDebugLoc(Arg), nullptr);
break;
case 1:
EXPECT_EQ(checkStr(LLVMRemarkArgGetKey(Arg), 6), "String");
EXPECT_EQ(checkStr(LLVMRemarkArgGetValue(Arg), 26),
" will not be inlined into ");
EXPECT_EQ(LLVMRemarkArgGetDebugLoc(Arg), nullptr);
break;
case 2: {
EXPECT_EQ(checkStr(LLVMRemarkArgGetKey(Arg), 6), "Caller");
EXPECT_EQ(checkStr(LLVMRemarkArgGetValue(Arg), 3), "foo");
LLVMRemarkDebugLocRef DL = LLVMRemarkArgGetDebugLoc(Arg);
EXPECT_EQ(checkStr(LLVMRemarkDebugLocGetSourceFilePath(DL), 6), "file.c");
EXPECT_EQ(LLVMRemarkDebugLocGetSourceLine(DL), 2U);
EXPECT_EQ(LLVMRemarkDebugLocGetSourceColumn(DL), 0U);
break;
}
case 3:
EXPECT_EQ(checkStr(LLVMRemarkArgGetKey(Arg), 6), "String");
EXPECT_EQ(checkStr(LLVMRemarkArgGetValue(Arg), 38),
" because its definition is unavailable");
EXPECT_EQ(LLVMRemarkArgGetDebugLoc(Arg), nullptr);
break;
default:
break;
}
++ArgID;
} while ((Arg = LLVMRemarkEntryGetNextArg(Arg, Remark)));
EXPECT_EQ(LLVMRemarkParserGetNext(Parser), nullptr);
EXPECT_FALSE(LLVMRemarkParserHasError(Parser));
LLVMRemarkParserDispose(Parser);
}