maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

[OptRemarks] Make OptRemarks more generic: rename OptRemarks to Remarks 

Getting rid of the name "optimization remarks" for anything that
involves handling remarks on the client side.

It's safer to do this now, before we get stuck with that name in all the
APIs and public interfaces we decide to export to users in the future.

This renames llvm/tools/opt-remarks to llvm/tools/remarks-shlib, and now
generates `libRemarks.dylib` instead of `libOptRemarks.dylib`.

Differential Revision: https://reviews.llvm.org/D58535

llvm-svn: 355439
This commit is contained in:
Francis Visoiu Mistrih 2019-03-05 20:45:17 +00:00
parent 47db2262eb
commit 1c4bab3ba4
20 changed files with 579 additions and 578 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
llvm/cmake/modules/AddLLVM.cmake
View File

@ -645,7 +645,7 @@ macro(add_llvm_library name)
set_property(GLOBAL APPEND PROPERTY LLVM_EXPORTS_BUILDTREE_ONLY ${name})
else()
if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY OR ${name} STREQUAL "LTO" OR
${name} STREQUAL "OptRemarks" OR
${name} STREQUAL "Remarks" OR
(LLVM_LINK_LLVM_DYLIB AND ${name} STREQUAL "LLVM"))
set(install_dir lib${LLVM_LIBDIR_SUFFIX})
if(ARG_MODULE OR ARG_SHARED OR BUILD_SHARED_LIBS)

102
llvm/include/llvm-c/OptRemarks.h → llvm/include/llvm-c/Remarks.h
View File

@ -1,4 +1,4 @@
/*===-- llvm-c/OptRemarks.h - OptRemarks Public C Interface -------*- C -*-===*\
/*===-- llvm-c/Remarks.h - Remarks Public C Interface -------------*- C -*-===*\
|* *|
|* Part of the LLVM Project, under the Apache License v2.0 with LLVM *|
|* Exceptions. *|
@ -7,13 +7,13 @@
|* *|
|*===----------------------------------------------------------------------===*|
|* *|
|* This header provides a public interface to an opt-remark library. *|
|* This header provides a public interface to a remark diagnostics library. *|
|* LLVM provides an implementation of this interface. *|
|* *|
\*===----------------------------------------------------------------------===*/
#ifndef LLVM_C_OPT_REMARKS_H
#define LLVM_C_OPT_REMARKS_H
#ifndef LLVM_C_REMARKS_H
#define LLVM_C_REMARKS_H
#include "llvm-c/Core.h"
#include "llvm-c/Types.h"
@ -25,81 +25,81 @@ extern "C" {
#endif /* !defined(__cplusplus) */
/**
* @defgroup LLVMCOPTREMARKS OptRemarks
* @defgroup LLVMCREMARKS Remarks
* @ingroup LLVMC
*
* @{
*/
#define OPT_REMARKS_API_VERSION 0
#define REMARKS_API_VERSION 0
/**
* String containing a buffer and a length. The buffer is not guaranteed to be
* zero-terminated.
*
* \since OPT_REMARKS_API_VERSION=0
* \since REMARKS_API_VERSION=0
*/
typedef struct {
const char *Str;
uint32_t Len;
} LLVMOptRemarkStringRef;
} LLVMRemarkStringRef;
/**
* DebugLoc containing File, Line and Column.
*
* \since OPT_REMARKS_API_VERSION=0
* \since REMARKS_API_VERSION=0
*/
typedef struct {
// File:
LLVMOptRemarkStringRef SourceFile;
LLVMRemarkStringRef SourceFile;
// Line:
uint32_t SourceLineNumber;
// Column:
uint32_t SourceColumnNumber;
} LLVMOptRemarkDebugLoc;
} LLVMRemarkDebugLoc;
/**
* Element of the "Args" list. The key might give more information about what
* are the semantics of the value, e.g. "Callee" will tell you that the value
* is a symbol that names a function.
*
* \since OPT_REMARKS_API_VERSION=0
* \since REMARKS_API_VERSION=0
*/
typedef struct {
// e.g. "Callee"
LLVMOptRemarkStringRef Key;
LLVMRemarkStringRef Key;
// e.g. "malloc"
LLVMOptRemarkStringRef Value;
LLVMRemarkStringRef Value;
// "DebugLoc": Optional
LLVMOptRemarkDebugLoc DebugLoc;
} LLVMOptRemarkArg;
LLVMRemarkDebugLoc DebugLoc;
} LLVMRemarkArg;
/**
* One remark entry.
*
* \since OPT_REMARKS_API_VERSION=0
* \since REMARKS_API_VERSION=0
*/
typedef struct {
// e.g. !Missed, !Passed
LLVMOptRemarkStringRef RemarkType;
LLVMRemarkStringRef RemarkType;
// "Pass": Required
LLVMOptRemarkStringRef PassName;
LLVMRemarkStringRef PassName;
// "Name": Required
LLVMOptRemarkStringRef RemarkName;
LLVMRemarkStringRef RemarkName;
// "Function": Required
LLVMOptRemarkStringRef FunctionName;
LLVMRemarkStringRef FunctionName;
// "DebugLoc": Optional
LLVMOptRemarkDebugLoc DebugLoc;
LLVMRemarkDebugLoc DebugLoc;
// "Hotness": Optional
uint32_t Hotness;
// "Args": Optional. It is an array of `num_args` elements.
uint32_t NumArgs;
LLVMOptRemarkArg *Args;
} LLVMOptRemarkEntry;
LLVMRemarkArg *Args;
} LLVMRemarkEntry;
typedef struct LLVMOptRemarkOpaqueParser *LLVMOptRemarkParserRef;
typedef struct LLVMRemarkOpaqueParser *LLVMRemarkParserRef;
/**
* Creates a remark parser that can be used to read and parse the buffer located
@ -107,27 +107,27 @@ typedef struct LLVMOptRemarkOpaqueParser *LLVMOptRemarkParserRef;
*
* \p Buf cannot be NULL.
*
* This function should be paired with LLVMOptRemarkParserDispose() to avoid
* This function should be paired with LLVMRemarkParserDispose() to avoid
* leaking resources.
*
* \since OPT_REMARKS_API_VERSION=0
* \since REMARKS_API_VERSION=0
*/
extern LLVMOptRemarkParserRef LLVMOptRemarkParserCreate(const void *Buf,
extern LLVMRemarkParserRef LLVMRemarkParserCreate(const void *Buf,
uint64_t Size);
/**
* Returns the next remark in the file.
*
* The value pointed to by the return value is invalidated by the next call to
* LLVMOptRemarkParserGetNext().
* LLVMRemarkParserGetNext().
*
* 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:
*
* 1) LLVMOptRemarkParserHasError() will return `1`.
* 1) LLVMRemarkParserHasError() will return `1`.
*
* 2) LLVMOptRemarkParserGetErrorMessage() will return a descriptive error
* 2) LLVMRemarkParserGetErrorMessage() will return a descriptive error
* message.
*
* An error may occur if:
@ -144,26 +144,25 @@ extern LLVMOptRemarkParserRef LLVMOptRemarkParserCreate(const void *Buf,
* Here is a quick example of the usage:
*
* ```
* LLVMOptRemarkParserRef Parser = LLVMOptRemarkParserCreate(Buf, Size);
* LLVMOptRemarkEntry *Remark = NULL;
* while ((Remark == LLVMOptRemarkParserGetNext(Parser))) {
* LLVMRemarkParserRef Parser = LLVMRemarkParserCreate(Buf, Size);
* LLVMRemarkEntry *Remark = NULL;
* while ((Remark == LLVMRemarkParserGetNext(Parser))) {
* // use Remark
* }
* bool HasError = LLVMOptRemarkParserHasError(Parser);
* LLVMOptRemarkParserDispose(Parser);
* bool HasError = LLVMRemarkParserHasError(Parser);
* LLVMRemarkParserDispose(Parser);
* ```
*
* \since OPT_REMARKS_API_VERSION=0
* \since REMARKS_API_VERSION=0
*/
extern LLVMOptRemarkEntry *
LLVMOptRemarkParserGetNext(LLVMOptRemarkParserRef Parser);
extern LLVMRemarkEntry *LLVMRemarkParserGetNext(LLVMRemarkParserRef Parser);
/**
* Returns `1` if the parser encountered an error while parsing the buffer.
*
* \since OPT_REMARKS_API_VERSION=0
* \since REMARKS_API_VERSION=0
*/
extern LLVMBool LLVMOptRemarkParserHasError(LLVMOptRemarkParserRef Parser);
extern LLVMBool LLVMRemarkParserHasError(LLVMRemarkParserRef Parser);
/**
* Returns a null-terminated string containing an error message.
@ -171,34 +170,33 @@ extern LLVMBool LLVMOptRemarkParserHasError(LLVMOptRemarkParserRef Parser);
* In case of no error, the result is `NULL`.
*
* The memory of the string is bound to the lifetime of \p Parser. If
* LLVMOptRemarkParserDispose() is called, the memory of the string will be
* LLVMRemarkParserDispose() is called, the memory of the string will be
* released.
*
* \since OPT_REMARKS_API_VERSION=0
* \since REMARKS_API_VERSION=0
*/
extern const char *
LLVMOptRemarkParserGetErrorMessage(LLVMOptRemarkParserRef Parser);
extern const char *LLVMRemarkParserGetErrorMessage(LLVMRemarkParserRef Parser);
/**
* Releases all the resources used by \p Parser.
*
* \since OPT_REMARKS_API_VERSION=0
* \since REMARKS_API_VERSION=0
*/
extern void LLVMOptRemarkParserDispose(LLVMOptRemarkParserRef Parser);
extern void LLVMRemarkParserDispose(LLVMRemarkParserRef Parser);
/**
* Returns the version of the opt-remarks dylib.
* Returns the version of the remarks dylib.
*
* \since OPT_REMARKS_API_VERSION=0
* \since REMARKS_API_VERSION=0
*/
extern uint32_t LLVMOptRemarkVersion(void);
extern uint32_t LLVMRemarkVersion(void);
/**
* @} // endgoup LLVMCOPTREMARKS
* @} // endgoup LLVMCREMARKS
*/
#ifdef __cplusplus
}
#endif /* !defined(__cplusplus) */
#endif /* LLVM_C_OPT_REMARKS_H */
#endif /* LLVM_C_REMARKS_H */

2
llvm/lib/CMakeLists.txt
View File

@ -16,7 +16,7 @@ add_subdirectory(MCA)
add_subdirectory(Object)
add_subdirectory(ObjectYAML)
add_subdirectory(Option)
add_subdirectory(OptRemarks)
add_subdirectory(Remarks)
add_subdirectory(DebugInfo)
add_subdirectory(ExecutionEngine)
add_subdirectory(Target)

2
llvm/lib/LLVMBuild.txt
View File

@ -35,7 +35,7 @@ subdirectories =
BinaryFormat
ObjectYAML
Option
OptRemarks
Remarks
Passes
ProfileData
Support

3
llvm/lib/OptRemarks/CMakeLists.txt
View File

@ -1,3 +0,0 @@
add_llvm_library(LLVMOptRemarks
OptRemarksParser.cpp
)

3
llvm/lib/Remarks/CMakeLists.txt Normal file
View File

@ -0,0 +1,3 @@
add_llvm_library(LLVMRemarks
RemarkParser.cpp
)

4
llvm/lib/OptRemarks/LLVMBuild.txt → llvm/lib/Remarks/LLVMBuild.txt
View File

@ -1,4 +1,4 @@
;===- ./lib/OptRemarks/LLVMBuild.txt ---------------------------*- Conf -*--===;
;===- ./lib/Remarks/LLVMBuild.txt ------------------------------*- Conf -*--===;
;
; Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
; See https://llvm.org/LICENSE.txt for license information.
@ -16,6 +16,6 @@
[component_0]
type = Library
name = OptRemarks
name = Remarks
parent = Libraries
required_libraries = Support

57
llvm/lib/OptRemarks/OptRemarksParser.cpp → llvm/lib/Remarks/RemarkParser.cpp
View File

@ -1,4 +1,4 @@
//===- OptRemarksParser.cpp -----------------------------------------------===//
//===- RemarkParser.cpp --------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
@ -7,11 +7,11 @@
//===----------------------------------------------------------------------===//
//
// This file provides utility methods used by clients that want to use the
// parser for optimization remarks in LLVM.
// parser for remark diagnostics in LLVM.
//
//===----------------------------------------------------------------------===//
#include "llvm-c/OptRemarks.h"
#include "llvm-c/Remarks.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/Support/SourceMgr.h"
#include "llvm/Support/YAMLTraits.h"
@ -31,14 +31,14 @@ struct RemarkParser {
/// Iterator in the YAML stream.
yaml::document_iterator DI;
/// The parsed remark (if any).
Optional<LLVMOptRemarkEntry> LastRemark;
Optional<LLVMRemarkEntry> LastRemark;
/// Temporary parsing buffer for the arguments.
SmallVector<LLVMOptRemarkArg, 8> TmpArgs;
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<LLVMOptRemarkArg> *Args;
SmallVectorImpl<LLVMRemarkArg> *Args;
StringRef Type;
StringRef Pass;
StringRef Name;
@ -49,7 +49,7 @@ struct RemarkParser {
Optional<unsigned> Column;
Optional<unsigned> Hotness;
ParseState(SmallVectorImpl<LLVMOptRemarkArg> &Args) : Args(&Args) {}
ParseState(SmallVectorImpl<LLVMRemarkArg> &Args) : Args(&Args) {}
/// Use Args only as a **temporary** buffer.
~ParseState() { Args->clear(); }
};
@ -80,7 +80,7 @@ private:
Error parseDebugLoc(Optional<StringRef> &File, Optional<unsigned> &Line,
Optional<unsigned> &Column, yaml::KeyValueNode &Node);
/// Parse an argument.
Error parseArg(SmallVectorImpl<LLVMOptRemarkArg> &TmpArgs, yaml::Node &Node);
Error parseArg(SmallVectorImpl<LLVMRemarkArg> &TmpArgs, yaml::Node &Node);
/// Handle a diagnostic from the YAML stream. Records the error in the
/// RemarkParser class.
@ -114,7 +114,7 @@ private:
char ParseError::ID = 0;
static LLVMOptRemarkStringRef toOptRemarkStr(StringRef Str) {
static LLVMRemarkStringRef toRemarkStr(StringRef Str) {
return {Str.data(), static_cast<uint32_t>(Str.size())};
}
@ -190,7 +190,7 @@ Error RemarkParser::parseDebugLoc(Optional<StringRef> &File,
return Error::success();
}
Error RemarkParser::parseArg(SmallVectorImpl<LLVMOptRemarkArg> &Args,
Error RemarkParser::parseArg(SmallVectorImpl<LLVMRemarkArg> &Args,
yaml::Node &Node) {
auto *ArgMap = dyn_cast<yaml::MappingNode>(&Node);
if (!ArgMap)
@ -237,9 +237,9 @@ Error RemarkParser::parseArg(SmallVectorImpl<LLVMOptRemarkArg> &Args,
if (ValueStr.empty())
return make_error<ParseError>("argument value is missing.", *ArgMap);
Args.push_back(LLVMOptRemarkArg{
toOptRemarkStr(KeyStr), toOptRemarkStr(ValueStr),
LLVMOptRemarkDebugLoc{toOptRemarkStr(File.getValueOr(StringRef())),
Args.push_back(LLVMRemarkArg{
toRemarkStr(KeyStr), toRemarkStr(ValueStr),
LLVMRemarkDebugLoc{toRemarkStr(File.getValueOr(StringRef())),
Line.getValueOr(0), Column.getValueOr(0)}});
return Error::success();
@ -302,14 +302,13 @@ Error RemarkParser::parseYAMLElement(yaml::Document &Remark) {
return make_error<ParseError>("Type, Pass, Name or Function missing.",
*Remark.getRoot());
LastRemark = LLVMOptRemarkEntry{
toOptRemarkStr(State.Type),
toOptRemarkStr(State.Pass),
toOptRemarkStr(State.Name),
toOptRemarkStr(State.Function),
LLVMOptRemarkDebugLoc{toOptRemarkStr(State.File.getValueOr(StringRef())),
State.Line.getValueOr(0),
State.Column.getValueOr(0)},
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()};
@ -319,16 +318,16 @@ Error RemarkParser::parseYAMLElement(yaml::Document &Remark) {
} // namespace
// Create wrappers for C Binding types (see CBindingWrapping.h).
DEFINE_SIMPLE_CONVERSION_FUNCTIONS(RemarkParser, LLVMOptRemarkParserRef)
DEFINE_SIMPLE_CONVERSION_FUNCTIONS(RemarkParser, LLVMRemarkParserRef)
extern "C" LLVMOptRemarkParserRef LLVMOptRemarkParserCreate(const void *Buf,
extern "C" LLVMRemarkParserRef LLVMRemarkParserCreate(const void *Buf,
uint64_t Size) {
return wrap(
new RemarkParser(StringRef(static_cast<const char *>(Buf), Size)));
}
extern "C" LLVMOptRemarkEntry *
LLVMOptRemarkParserGetNext(LLVMOptRemarkParserRef Parser) {
extern "C" LLVMRemarkEntry *
LLVMRemarkParserGetNext(LLVMRemarkParserRef Parser) {
RemarkParser &TheParser = *unwrap(Parser);
// Check for EOF.
if (TheParser.HadAnyErrors || TheParser.DI == TheParser.Stream.end())
@ -348,20 +347,20 @@ LLVMOptRemarkParserGetNext(LLVMOptRemarkParserRef Parser) {
++TheParser.DI;
// Return the just-parsed remark.
if (Optional<LLVMOptRemarkEntry> &Entry = TheParser.LastRemark)
if (Optional<LLVMRemarkEntry> &Entry = TheParser.LastRemark)
return &*Entry;
return nullptr;
}
extern "C" LLVMBool LLVMOptRemarkParserHasError(LLVMOptRemarkParserRef Parser) {
extern "C" LLVMBool LLVMRemarkParserHasError(LLVMRemarkParserRef Parser) {
return unwrap(Parser)->HadAnyErrors;
}
extern "C" const char *
LLVMOptRemarkParserGetErrorMessage(LLVMOptRemarkParserRef Parser) {
LLVMRemarkParserGetErrorMessage(LLVMRemarkParserRef Parser) {
return unwrap(Parser)->ErrorStream.str().c_str();
}
extern "C" void LLVMOptRemarkParserDispose(LLVMOptRemarkParserRef Parser) {
extern "C" void LLVMRemarkParserDispose(LLVMRemarkParserRef Parser) {
delete unwrap(Parser);
}

2
llvm/tools/llvm-opt-report/CMakeLists.txt
View File

@ -1,4 +1,4 @@
set(LLVM_LINK_COMPONENTS Core Demangle Object OptRemarks Support)
set(LLVM_LINK_COMPONENTS Core Demangle Object Remarks Support)
add_llvm_tool(llvm-opt-report
OptReport.cpp

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

@ -13,7 +13,7 @@
///
//===----------------------------------------------------------------------===//
#include "llvm-c/OptRemarks.h"
#include "llvm-c/Remarks.h"
#include "llvm/Demangle/Demangle.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Error.h"
@ -152,11 +152,11 @@ static bool readLocationInfo(LocationInfoTy &LocationInfo) {
}
StringRef Buffer = (*Buf)->getBuffer();
LLVMOptRemarkParserRef Parser =
LLVMOptRemarkParserCreate(Buffer.data(), Buffer.size());
LLVMRemarkParserRef Parser =
LLVMRemarkParserCreate(Buffer.data(), Buffer.size());
LLVMOptRemarkEntry *Remark = nullptr;
while ((Remark = LLVMOptRemarkParserGetNext(Parser))) {
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);
@ -165,13 +165,13 @@ static bool readLocationInfo(LocationInfoTy &LocationInfo) {
StringRef Function(Remark->FunctionName.Str, Remark->FunctionName.Len);
uint32_t Line = Remark->DebugLoc.SourceLineNumber;
uint32_t Column = Remark->DebugLoc.SourceColumnNumber;
ArrayRef<LLVMOptRemarkArg> Args(Remark->Args, Remark->NumArgs);
ArrayRef<LLVMRemarkArg> Args(Remark->Args, Remark->NumArgs);
int VectorizationFactor = 1;
int InterleaveCount = 1;
int UnrollCount = 1;
for (const LLVMOptRemarkArg &Arg : Args) {
for (const LLVMRemarkArg &Arg : Args) {
StringRef ArgKeyName(Arg.Key.Str, Arg.Key.Len);
StringRef ArgValue(Arg.Value.Str, Arg.Value.Len);
if (ArgKeyName == "VectorizationFactor")
@ -209,11 +209,11 @@ static bool readLocationInfo(LocationInfoTy &LocationInfo) {
}
}
bool HasError = LLVMOptRemarkParserHasError(Parser);
bool HasError = LLVMRemarkParserHasError(Parser);
if (HasError)
WithColor::error() << LLVMOptRemarkParserGetErrorMessage(Parser) << "\n";
WithColor::error() << LLVMRemarkParserGetErrorMessage(Parser) << "\n";
LLVMOptRemarkParserDispose(Parser);
LLVMRemarkParserDispose(Parser);
return !HasError;
}

22
llvm/tools/opt-remarks/CMakeLists.txt
View File

@ -1,22 +0,0 @@
set(LLVM_LINK_COMPONENTS
OptRemarks
)
set(SOURCES
liboptremarks.cpp
)
set(LLVM_EXPORTED_SYMBOL_FILE ${CMAKE_CURRENT_SOURCE_DIR}/OptRemarks.exports)
add_llvm_library(OptRemarks SHARED ${SOURCES})
install(FILES ${LLVM_MAIN_INCLUDE_DIR}/llvm-c/OptRemarks.h
DESTINATION include/llvm-c
COMPONENT OptRemarks)
if (APPLE)
set(OPTREMARKS_VERSION ${LLVM_VERSION_MAJOR})
set_property(TARGET OptRemarks APPEND_STRING PROPERTY
LINK_FLAGS
" -compatibility_version 1 -current_version ${OPTREMARKS_VERSION}.${LLVM_VERSION_MINOR}.${LLVM_VERSION_PATCH}")
endif()

6
llvm/tools/opt-remarks/OptRemarks.exports
View File

@ -1,6 +0,0 @@
LLVMOptRemarkParserCreate
LLVMOptRemarkParserGetNext
LLVMOptRemarkParserHasError
LLVMOptRemarkParserGetErrorMessage
LLVMOptRemarkParserDispose
LLVMOptRemarkVersion

22
llvm/tools/remarks-shlib/CMakeLists.txt Normal file
View File

@ -0,0 +1,22 @@
set(LLVM_LINK_COMPONENTS
Remarks
)
set(SOURCES
libremarks.cpp
)
set(LLVM_EXPORTED_SYMBOL_FILE ${CMAKE_CURRENT_SOURCE_DIR}/Remarks.exports)
add_llvm_library(Remarks SHARED ${SOURCES})
install(FILES ${LLVM_MAIN_INCLUDE_DIR}/llvm-c/Remarks.h
DESTINATION include/llvm-c
COMPONENT Remarks)
if (APPLE)
set(REMARKS_VERSION ${LLVM_VERSION_MAJOR})
set_property(TARGET Remarks APPEND_STRING PROPERTY
LINK_FLAGS
" -compatibility_version 1 -current_version ${REMARKS_VERSION}.${LLVM_VERSION_MINOR}.${LLVM_VERSION_PATCH}")
endif()

6
llvm/tools/remarks-shlib/Remarks.exports Normal file
View File

@ -0,0 +1,6 @@
LLVMRemarkParserCreate
LLVMRemarkParserGetNext
LLVMRemarkParserHasError
LLVMRemarkParserGetErrorMessage
LLVMRemarkParserDispose
LLVMRemarkVersion

10
llvm/tools/opt-remarks/liboptremarks.cpp → llvm/tools/remarks-shlib/libremarks.cpp
View File

@ -1,4 +1,4 @@
//===-liboptremarks.cpp - LLVM Opt-Remarks Shared Library -----------------===//
//===-libremarks.cpp - LLVM Remarks Shared Library ------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
@ -6,12 +6,12 @@
//
//===----------------------------------------------------------------------===//
//
// Provide a library to work with optimization remarks.
// Provide a library to work with remark diagnostics.
//
//===----------------------------------------------------------------------===//
#include "llvm-c/OptRemarks.h"
#include "llvm-c/Remarks.h"
extern uint32_t LLVMOptRemarkVersion(void) {
return OPT_REMARKS_API_VERSION;
extern uint32_t LLVMRemarkVersion(void) {
return REMARKS_API_VERSION;
}

2
llvm/unittests/CMakeLists.txt
View File

@ -26,7 +26,7 @@ add_subdirectory(MI)
add_subdirectory(Object)
add_subdirectory(ObjectYAML)
add_subdirectory(Option)
add_subdirectory(OptRemarks)
add_subdirectory(Remarks)
add_subdirectory(Passes)
add_subdirectory(ProfileData)
add_subdirectory(Support)

8
llvm/unittests/OptRemarks/CMakeLists.txt
View File

@ -1,8 +0,0 @@
set(LLVM_LINK_COMPONENTS
OptRemarks
Support
)
add_llvm_unittest(OptRemarksTests
OptRemarksParsingTest.cpp
)

432
llvm/unittests/OptRemarks/OptRemarksParsingTest.cpp
View File

@ -1,432 +0,0 @@
//===- unittest/Support/OptRemarksParsingTest.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/OptRemarks.h"
#include "gtest/gtest.h"
using namespace llvm;
template <size_t N> bool tryParse(const char (&Buf)[N]) {
LLVMOptRemarkParserRef Parser = LLVMOptRemarkParserCreate(Buf, N - 1);
LLVMOptRemarkEntry *Remark = nullptr;
while (LLVMOptRemarkEntry *NewRemark = LLVMOptRemarkParserGetNext(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 = LLVMOptRemarkParserHasError(Parser);
LLVMOptRemarkParserDispose(Parser);
return !HasError;
}
template <size_t N>
bool parseExpectError(const char (&Buf)[N], const char *Error) {
LLVMOptRemarkParserRef Parser = LLVMOptRemarkParserCreate(Buf, N - 1);
LLVMOptRemarkEntry *Remark = nullptr;
while (LLVMOptRemarkEntry *NewRemark = LLVMOptRemarkParserGetNext(Parser)) {
EXPECT_FALSE(NewRemark);
}
EXPECT_TRUE(Remark == nullptr); // We are parsing only one malformed remark.
EXPECT_TRUE(LLVMOptRemarkParserHasError(Parser));
bool MatchesError =
StringRef(LLVMOptRemarkParserGetErrorMessage(Parser)).contains(Error);
LLVMOptRemarkParserDispose(Parser);
return MatchesError;
}
TEST(OptRemarks, OptRemarksParsingEmpty) {
StringRef Buf = "\n"
"\n";
LLVMOptRemarkParserRef Parser =
LLVMOptRemarkParserCreate(Buf.data(), Buf.size());
LLVMOptRemarkEntry *NewRemark = LLVMOptRemarkParserGetNext(Parser);
EXPECT_TRUE(NewRemark == nullptr); // No remark expected.
EXPECT_TRUE(LLVMOptRemarkParserHasError(Parser));
EXPECT_TRUE(StringRef(LLVMOptRemarkParserGetErrorMessage(Parser))
.contains("document root is not of mapping type."));
LLVMOptRemarkParserDispose(Parser);
}
TEST(OptRemarks, OptRemarksParsingGood) {
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(OptRemarks, OptRemarksParsingTypes) {
// 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(OptRemarks, OptRemarksParsingMissingFields) {
// 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(OptRemarks, OptRemarksParsingWrongTypes) {
// 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(OptRemarks, OptRemarksParsingWrongArgs) {
// 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(OptRemarks, OptRemarksGoodStruct) {
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";
LLVMOptRemarkParserRef Parser =
LLVMOptRemarkParserCreate(Buf.data(), Buf.size());
LLVMOptRemarkEntry *Remark = LLVMOptRemarkParserGetNext(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
{
LLVMOptRemarkArg &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
{
LLVMOptRemarkArg &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
{
LLVMOptRemarkArg &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
{
LLVMOptRemarkArg &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(LLVMOptRemarkParserGetNext(Parser), nullptr);
EXPECT_FALSE(LLVMOptRemarkParserHasError(Parser));
LLVMOptRemarkParserDispose(Parser);
}

8
llvm/unittests/Remarks/CMakeLists.txt Normal file
View File

@ -0,0 +1,8 @@
set(LLVM_LINK_COMPONENTS
Remarks
Support
)
add_llvm_unittest(RemarksTests
RemarksParsingTest.cpp
)

436
llvm/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);
}