1 //===-- llvm/Remarks/Remark.h - The remark type -----------------*- C++/-*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file defines an abstraction for handling remarks. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #ifndef LLVM_REMARKS_REMARK_H 14 #define LLVM_REMARKS_REMARK_H 15 16 #include "llvm-c/Remarks.h" 17 #include "llvm/ADT/ArrayRef.h" 18 #include "llvm/ADT/Optional.h" 19 #include "llvm/ADT/StringRef.h" 20 #include "llvm/Support/CBindingWrapping.h" 21 #include <string> 22 23 namespace llvm { 24 namespace remarks { 25 26 /// The current version of the remark entry. 27 constexpr uint64_t CurrentRemarkVersion = 0; 28 29 /// The debug location used to track a remark back to the source file. 30 struct RemarkLocation { 31 /// Absolute path of the source file corresponding to this remark. 32 StringRef SourceFilePath; 33 unsigned SourceLine; 34 unsigned SourceColumn; 35 }; 36 37 // Create wrappers for C Binding types (see CBindingWrapping.h). 38 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(RemarkLocation, LLVMRemarkDebugLocRef) 39 40 /// A key-value pair with a debug location that is used to display the remarks 41 /// at the right place in the source. 42 struct Argument { 43 StringRef Key; 44 // FIXME: We might want to be able to store other types than strings here. 45 StringRef Val; 46 // If set, the debug location corresponding to the value. 47 Optional<RemarkLocation> Loc; 48 }; 49 50 // Create wrappers for C Binding types (see CBindingWrapping.h). 51 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Argument, LLVMRemarkArgRef) 52 53 /// The type of the remark. 54 enum class Type { 55 Unknown, 56 Passed, 57 Missed, 58 Analysis, 59 AnalysisFPCommute, 60 AnalysisAliasing, 61 Failure, 62 First = Unknown, 63 Last = Failure 64 }; 65 66 /// A remark type used for both emission and parsing. 67 struct Remark { 68 /// The type of the remark. 69 Type RemarkType = Type::Unknown; 70 71 /// Name of the pass that triggers the emission of this remark. 72 StringRef PassName; 73 74 /// Textual identifier for the remark (single-word, camel-case). Can be used 75 /// by external tools reading the output file for remarks to identify the 76 /// remark. 77 StringRef RemarkName; 78 79 /// Mangled name of the function that triggers the emssion of this remark. 80 StringRef FunctionName; 81 82 /// The location in the source file of the remark. 83 Optional<RemarkLocation> Loc; 84 85 /// If profile information is available, this is the number of times the 86 /// corresponding code was executed in a profile instrumentation run. 87 Optional<uint64_t> Hotness; 88 89 /// Arguments collected via the streaming interface. 90 SmallVector<Argument, 5> Args; 91 92 Remark() = default; 93 Remark(Remark &&) = default; 94 Remark &operator=(Remark &&) = default; 95 96 /// Return a message composed from the arguments as a string. 97 std::string getArgsAsMsg() const; 98 99 /// Clone this remark to explicitly ask for a copy. 100 Remark clone() const { return *this; } 101 102 private: 103 /// In order to avoid unwanted copies, "delete" the copy constructor. 104 /// If a copy is needed, it should be done through `Remark::clone()`. 105 Remark(const Remark &) = default; 106 Remark& operator=(const Remark &) = default; 107 }; 108 109 // Create wrappers for C Binding types (see CBindingWrapping.h). 110 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Remark, LLVMRemarkEntryRef) 111 112 /// Comparison operators for Remark objects and dependent objects. 113 inline bool operator==(const RemarkLocation &LHS, const RemarkLocation &RHS) { 114 return LHS.SourceFilePath == RHS.SourceFilePath && 115 LHS.SourceLine == RHS.SourceLine && 116 LHS.SourceColumn == RHS.SourceColumn; 117 } 118 119 inline bool operator!=(const RemarkLocation &LHS, const RemarkLocation &RHS) { 120 return !(LHS == RHS); 121 } 122 123 inline bool operator==(const Argument &LHS, const Argument &RHS) { 124 return LHS.Key == RHS.Key && LHS.Val == RHS.Val && LHS.Loc == RHS.Loc; 125 } 126 127 inline bool operator!=(const Argument &LHS, const Argument &RHS) { 128 return !(LHS == RHS); 129 } 130 131 inline bool operator==(const Remark &LHS, const Remark &RHS) { 132 return LHS.RemarkType == RHS.RemarkType && LHS.PassName == RHS.PassName && 133 LHS.RemarkName == RHS.RemarkName && 134 LHS.FunctionName == RHS.FunctionName && LHS.Loc == RHS.Loc && 135 LHS.Hotness == RHS.Hotness && LHS.Args == RHS.Args; 136 } 137 138 inline bool operator!=(const Remark &LHS, const Remark &RHS) { 139 return !(LHS == RHS); 140 } 141 142 } // end namespace remarks 143 } // end namespace llvm 144 145 #endif /* LLVM_REMARKS_REMARK_H */ 146