LLVM: llvm::remarks Namespace Reference (original) (raw)

Classes
struct	Argument
	A key-value pair with a debug location that is used to display the remarks at the right place in the source. More...
class	BitstreamBlockParserHelper
class	BitstreamBlockParserHelperBase
class	BitstreamMetaParserHelper
	Helper to parse a META_BLOCK for a bitstream remark container. More...
struct	BitstreamMetaSerializer
	Serializer of metadata for bitstream remarks. More...
struct	BitstreamParserHelper
	Helper to parse any bitstream remark container. More...
struct	BitstreamRemarkParser
	Parses and holds the state of the latest parsed remark. More...
class	BitstreamRemarkParserHelper
	Helper to parse a REMARK_BLOCK for a bitstream remark container. More...
struct	BitstreamRemarkSerializer
	Implementation of the remark serializer using LLVM bitstream. More...
struct	BitstreamRemarkSerializerHelper
	Serialize the remarks to LLVM bitstream. More...
class	EndOfFileError
class	HotnessThresholdParser
struct	MetaSerializer
	This is the base class for a remark metadata serializer. More...
struct	ParsedStringTable
	In-memory representation of the string table parsed from a buffer (e.g. More...
struct	Remark
	A remark type used for both emission and parsing. More...
struct	RemarkLinker
struct	RemarkLocation
	The debug location used to track a remark back to the source file. More...
struct	RemarkParser
	Parser used to parse a raw buffer to remarks::Remark objects. More...
struct	RemarkSerializer
	This is the base class for a remark serializer. More...
class	RemarkStreamer
struct	StringTable
	The string table used for serializing remarks. More...
struct	YAMLMetaSerializer
class	YAMLParseError
struct	YAMLRemarkParser
	Regular YAML to Remark parser. More...
struct	YAMLRemarkSerializer
	Serialize the remarks to YAML. More...

Enumerations
enum class	BitstreamRemarkContainerType { RemarksFileExternal, RemarksFile, First = RemarksFileExternal , Last = RemarksFile }
	Type of the remark container. More...
enum	BlockIDs { META_BLOCK_ID = bitc::FIRST_APPLICATION_BLOCKID , REMARK_BLOCK_ID }
	The possible blocks that will be encountered in a bitstream remark container. More...
enum	RecordIDs { RECORD_META_CONTAINER_INFO = 1 , RECORD_META_REMARK_VERSION, RECORD_META_STRTAB, RECORD_META_EXTERNAL_FILE, RECORD_REMARK_HEADER, RECORD_REMARK_DEBUG_LOC, RECORD_REMARK_HOTNESS, RECORD_REMARK_ARG_WITH_DEBUGLOC, RECORD_REMARK_ARG_WITHOUT_DEBUGLOC, RECORD_FIRST = RECORD_META_CONTAINER_INFO , RECORD_LAST = RECORD_REMARK_ARG_WITHOUT_DEBUGLOC }
	The possible records that can be encountered in the previously described blocks. More...
enum class	Type { Unknown, Passed, Missed, Analysis, AnalysisFPCommute, AnalysisAliasing, Failure, First = Unknown , Last = Failure }
	The type of the remark. More...
enum class	Format { Unknown, Auto, YAML, Bitstream }
	The format used for serializing/deserializing remarks. More...

Functions
constexpr StringLiteral	ContainerMagic ("RMRK")
	The magic number used for identifying remark blocks.
constexpr StringLiteral	MetaBlockName ("Meta")
constexpr StringLiteral	RemarkBlockName ("Remark")
constexpr StringLiteral	MetaContainerInfoName ("Container info")
constexpr StringLiteral	MetaRemarkVersionName ("Remark version")
constexpr StringLiteral	MetaStrTabName ("String table")
constexpr StringLiteral	MetaExternalFileName ("External File")
constexpr StringLiteral	RemarkHeaderName ("Remark header")
constexpr StringLiteral	RemarkDebugLocName ("Remark debug location")
constexpr StringLiteral	RemarkHotnessName ("Remark hotness")
constexpr StringLiteral	RemarkArgWithDebugLocName ("Argument with debug location")
constexpr StringLiteral	RemarkArgWithoutDebugLocName ("Argument")
Expected< std::optional< uint64_t > >	parseHotnessThresholdOption (StringRef Arg)
StringRef	typeToStr (Type Ty)
template<typename T>
bool	operator< (const std::optional< T > &LHS, const std::optional< T > &RHS)
	Comparison operators for Remark objects and dependent objects.
bool	operator== (const RemarkLocation &LHS, const RemarkLocation &RHS)
bool	operator!= (const RemarkLocation &LHS, const RemarkLocation &RHS)
bool	operator< (const RemarkLocation &LHS, const RemarkLocation &RHS)
bool	operator== (const Argument &LHS, const Argument &RHS)
bool	operator!= (const Argument &LHS, const Argument &RHS)
bool	operator< (const Argument &LHS, const Argument &RHS)
bool	operator== (const Remark &LHS, const Remark &RHS)
bool	operator!= (const Remark &LHS, const Remark &RHS)
bool	operator< (const Remark &LHS, const Remark &RHS)
raw_ostream &	operator<< (raw_ostream &OS, const RemarkLocation &RLoc)
raw_ostream &	operator<< (raw_ostream &OS, const Argument &Arg)
raw_ostream &	operator<< (raw_ostream &OS, const Remark &Remark)
constexpr StringLiteral	Magic ("REMARKS")
LLVM_ABI Expected< Format >	parseFormat (StringRef FormatStr)
	Parse and validate a string for the remark format.
LLVM_ABI Expected< Format >	magicToFormat (StringRef Magic)
	Parse and validate a magic number to a remark format.
LLVM_ABI Expected< Format >	detectFormat (Format Selected, StringRef Magic)
	Detect format based on selected format and magic number.
LLVM_ABI Expected< std::optional< StringRef > >	getRemarksSectionContents (const object::ObjectFile &Obj)
	Returns a buffer with the contents of the remarks section depending on the format of the file.
LLVM_ABI Expected< std::unique_ptr< RemarkParser > >	createRemarkParser (Format ParserFormat, StringRef Buf)
LLVM_ABI Expected< std::unique_ptr< RemarkParser > >	createRemarkParserFromMeta (Format ParserFormat, StringRef Buf, std::optional< StringRef > ExternalFilePrependPath=std::nullopt)
LLVM_ABI Expected< std::unique_ptr< RemarkSerializer > >	createRemarkSerializer (Format RemarksFormat, raw_ostream &OS)
	Create a remark serializer.
LLVM_ABI Expected< std::unique_ptr< RemarkSerializer > >	createRemarkSerializer (Format RemarksFormat, raw_ostream &OS, remarks::StringTable StrTab)
	Create a remark serializer that uses a pre-filled string table.
Expected< std::unique_ptr< BitstreamRemarkParser > >	createBitstreamParserFromMeta (StringRef Buf, std::optional< StringRef > ExternalFilePrependPath=std::nullopt)
Expected< std::unique_ptr< YAMLRemarkParser > >	createYAMLParserFromMeta (StringRef Buf, std::optional< StringRef > ExternalFilePrependPath=std::nullopt)

Variables
constexpr uint64_t	CurrentContainerVersion = 1
	The current version of the remark container.
constexpr uint64_t	CurrentRemarkVersion = 0
	The current version of the remark entry.

◆ BitstreamRemarkContainerType

Type of the remark container.

| Enumerator | | | | | | | | | | | | | | | | | | | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | -------------- | | ------------------------------------------------------------------------------------------------------------------ | -------- | | ------- | | ------- | | ------- | | --- | ---------- | | ------------- | | RemarksFileExternal | Emit a link to an external remarks file (usually as a section of the object file, to enable discovery of all remarks files from the final linked object file) RemarksFileExternal: | Meta: | | Container info | | External file. | | | | | | | | | | | | | | RemarksFile | Emit metadata and remarks into a file RemarksFile: | Meta: | | Container info | | Remark version | Remarks: | | Remark0 | | Remark1 | | Remark2 | | ... | Late Meta: | | String table. | | First | | | | | | | | | | | | | | | | | | | Last | | | | | | | | | | | | | | | | | |

Definition at line 31 of file BitstreamRemarkContainer.h.

◆ BlockIDs

The possible blocks that will be encountered in a bitstream remark container.

Enumerator
META_BLOCK_ID	The metadata block is mandatory. It should always come after the BLOCKINFO_BLOCK, and contains metadata that should be used when parsing REMARK_BLOCKs. There should always be only one META_BLOCK.
REMARK_BLOCK_ID	One remark entry is represented using a REMARK_BLOCK. There can be multiple REMARK_BLOCKs in the same file.

Definition at line 59 of file BitstreamRemarkContainer.h.

◆ Format

enum class llvm::remarks::Format	strong

The format used for serializing/deserializing remarks.

Enumerator
Unknown
Auto
YAML
Bitstream

Definition at line 26 of file RemarkFormat.h.

◆ RecordIDs

The possible records that can be encountered in the previously described blocks.

Enumerator
RECORD_META_CONTAINER_INFO
RECORD_META_REMARK_VERSION
RECORD_META_STRTAB
RECORD_META_EXTERNAL_FILE
RECORD_REMARK_HEADER
RECORD_REMARK_DEBUG_LOC
RECORD_REMARK_HOTNESS
RECORD_REMARK_ARG_WITH_DEBUGLOC
RECORD_REMARK_ARG_WITHOUT_DEBUGLOC
RECORD_FIRST
RECORD_LAST

Definition at line 75 of file BitstreamRemarkContainer.h.

◆ Type

enum class llvm::remarks::Type	strong

The type of the remark.

MessagePack types as defined in the standard, with the exception of Integer being divided into a signed Int and unsigned UInt variant in order to map directly to C++ types.

The types map onto corresponding union members of the Object struct.

Enumerator
Unknown
Passed
Missed
Analysis
AnalysisFPCommute
AnalysisAliasing
Failure
First
Last

Definition at line 75 of file Remark.h.

◆ ContainerMagic()

◆ createBitstreamParserFromMeta()

◆ createRemarkParser()

◆ createRemarkParserFromMeta()

◆ createRemarkSerializer() [1/2]

◆ createRemarkSerializer() [2/2]

◆ createYAMLParserFromMeta()

Definition at line 98 of file YAMLRemarkParser.cpp.

References llvm::sys::path::append(), llvm::createFileError(), llvm::createStringError(), llvm::ErrorOr< T >::getError(), llvm::MemoryBuffer::getFile(), parseMagic(), parseStrTabSize(), parseVersion(), llvm::StringRef::starts_with(), llvm::Expected< T >::takeError(), and llvm::Version.

Referenced by createRemarkParserFromMeta().

◆ detectFormat()

◆ getRemarksSectionContents()

◆ Magic()

◆ magicToFormat()

Parse and validate a magic number to a remark format.

Definition at line 34 of file RemarkFormat.cpp.

References Bitstream, ContainerMagic(), llvm::createStringError(), llvm::StringRef::data(), llvm::StringSwitch< T, R >::Default(), Magic(), llvm::StringSwitch< T, R >::StartsWith(), Unknown, and YAML.

Referenced by detectFormat().

◆ MetaBlockName()

◆ MetaContainerInfoName()

StringLiteral llvm::remarks::MetaContainerInfoName ( "Container info" )	constexpr

◆ MetaExternalFileName()

StringLiteral llvm::remarks::MetaExternalFileName ( "External File" )	constexpr

◆ MetaRemarkVersionName()

StringLiteral llvm::remarks::MetaRemarkVersionName ( "Remark version" )	constexpr

◆ MetaStrTabName()

StringLiteral llvm::remarks::MetaStrTabName ( "String table" )	constexpr

◆ operator!=() [1/3]

◆ operator!=() [2/3]

◆ operator!=() [3/3]

◆ operator<() [1/4]

◆ operator<() [2/4]

◆ operator<() [3/4]

◆ operator<() [4/4]

template<typename T>

bool llvm::remarks::operator<	(	const std::optional< T > &	LHS,
const std::optional< T > &	RHS )

Comparison operators for Remark objects and dependent objects.

Definition at line 162 of file Remark.h.

References LHS, and RHS.

◆ operator<<() [1/3]

◆ operator<<() [2/3]

◆ operator<<() [3/3]

◆ operator==() [1/3]

◆ operator==() [2/3]

◆ operator==() [3/3]

◆ parseFormat()

◆ parseHotnessThresholdOption()

◆ RemarkArgWithDebugLocName()

StringLiteral llvm::remarks::RemarkArgWithDebugLocName ( "Argument with debug location" )	constexpr

◆ RemarkArgWithoutDebugLocName()

StringLiteral llvm::remarks::RemarkArgWithoutDebugLocName ( "Argument" )	constexpr

◆ RemarkBlockName()

StringLiteral llvm::remarks::RemarkBlockName ( "Remark" )	constexpr

◆ RemarkDebugLocName()

◆ RemarkHeaderName()

StringLiteral llvm::remarks::RemarkHeaderName ( "Remark header" )	constexpr

◆ RemarkHotnessName()

StringLiteral llvm::remarks::RemarkHotnessName ( "Remark hotness" )	constexpr

◆ typeToStr()

StringRef llvm::remarks::typeToStr ( Type Ty)	inline

◆ CurrentContainerVersion

uint64_t llvm::remarks::CurrentContainerVersion = 1	constexpr

◆ CurrentRemarkVersion

uint64_t llvm::remarks::CurrentRemarkVersion = 0	constexpr