1 //===- Remark.cpp ---------------------------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // Implementation of the Remark type and the C API. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "llvm/Remarks/Remark.h" 14 #include "llvm/ADT/ArrayRef.h" 15 #include "llvm/Support/raw_ostream.h" 16 17 using namespace llvm; 18 using namespace llvm::remarks; 19 getArgsAsMsg() const20std::string Remark::getArgsAsMsg() const { 21 std::string Str; 22 raw_string_ostream OS(Str); 23 for (const Argument &Arg : Args) 24 OS << Arg.Val; 25 return OS.str(); 26 } 27 28 // Create wrappers for C Binding types (see CBindingWrapping.h). DEFINE_SIMPLE_CONVERSION_FUNCTIONS(StringRef,LLVMRemarkStringRef) const29DEFINE_SIMPLE_CONVERSION_FUNCTIONS(StringRef, LLVMRemarkStringRef) 30 31 extern "C" const char *LLVMRemarkStringGetData(LLVMRemarkStringRef String) { 32 return unwrap(String)->data(); 33 } 34 LLVMRemarkStringGetLen(LLVMRemarkStringRef String)35extern "C" uint32_t LLVMRemarkStringGetLen(LLVMRemarkStringRef String) { 36 return unwrap(String)->size(); 37 } 38 39 extern "C" LLVMRemarkStringRef LLVMRemarkDebugLocGetSourceFilePath(LLVMRemarkDebugLocRef DL)40LLVMRemarkDebugLocGetSourceFilePath(LLVMRemarkDebugLocRef DL) { 41 return wrap(&unwrap(DL)->SourceFilePath); 42 } 43 LLVMRemarkDebugLocGetSourceLine(LLVMRemarkDebugLocRef DL)44extern "C" uint32_t LLVMRemarkDebugLocGetSourceLine(LLVMRemarkDebugLocRef DL) { 45 return unwrap(DL)->SourceLine; 46 } 47 48 extern "C" uint32_t LLVMRemarkDebugLocGetSourceColumn(LLVMRemarkDebugLocRef DL)49LLVMRemarkDebugLocGetSourceColumn(LLVMRemarkDebugLocRef DL) { 50 return unwrap(DL)->SourceColumn; 51 } 52 LLVMRemarkArgGetKey(LLVMRemarkArgRef Arg)53extern "C" LLVMRemarkStringRef LLVMRemarkArgGetKey(LLVMRemarkArgRef Arg) { 54 return wrap(&unwrap(Arg)->Key); 55 } 56 LLVMRemarkArgGetValue(LLVMRemarkArgRef Arg)57extern "C" LLVMRemarkStringRef LLVMRemarkArgGetValue(LLVMRemarkArgRef Arg) { 58 return wrap(&unwrap(Arg)->Val); 59 } 60 61 extern "C" LLVMRemarkDebugLocRef LLVMRemarkArgGetDebugLoc(LLVMRemarkArgRef Arg)62LLVMRemarkArgGetDebugLoc(LLVMRemarkArgRef Arg) { 63 if (const Optional<RemarkLocation> &Loc = unwrap(Arg)->Loc) 64 return wrap(&*Loc); 65 return nullptr; 66 } 67 LLVMRemarkEntryDispose(LLVMRemarkEntryRef Remark)68extern "C" void LLVMRemarkEntryDispose(LLVMRemarkEntryRef Remark) { 69 delete unwrap(Remark); 70 } 71 LLVMRemarkEntryGetType(LLVMRemarkEntryRef Remark)72extern "C" LLVMRemarkType LLVMRemarkEntryGetType(LLVMRemarkEntryRef Remark) { 73 // Assume here that the enums can be converted both ways. 74 return static_cast<LLVMRemarkType>(unwrap(Remark)->RemarkType); 75 } 76 77 extern "C" LLVMRemarkStringRef LLVMRemarkEntryGetPassName(LLVMRemarkEntryRef Remark)78LLVMRemarkEntryGetPassName(LLVMRemarkEntryRef Remark) { 79 return wrap(&unwrap(Remark)->PassName); 80 } 81 82 extern "C" LLVMRemarkStringRef LLVMRemarkEntryGetRemarkName(LLVMRemarkEntryRef Remark)83LLVMRemarkEntryGetRemarkName(LLVMRemarkEntryRef Remark) { 84 return wrap(&unwrap(Remark)->RemarkName); 85 } 86 87 extern "C" LLVMRemarkStringRef LLVMRemarkEntryGetFunctionName(LLVMRemarkEntryRef Remark)88LLVMRemarkEntryGetFunctionName(LLVMRemarkEntryRef Remark) { 89 return wrap(&unwrap(Remark)->FunctionName); 90 } 91 92 extern "C" LLVMRemarkDebugLocRef LLVMRemarkEntryGetDebugLoc(LLVMRemarkEntryRef Remark)93LLVMRemarkEntryGetDebugLoc(LLVMRemarkEntryRef Remark) { 94 if (const Optional<RemarkLocation> &Loc = unwrap(Remark)->Loc) 95 return wrap(&*Loc); 96 return nullptr; 97 } 98 LLVMRemarkEntryGetHotness(LLVMRemarkEntryRef Remark)99extern "C" uint64_t LLVMRemarkEntryGetHotness(LLVMRemarkEntryRef Remark) { 100 if (const Optional<uint64_t> &Hotness = unwrap(Remark)->Hotness) 101 return *Hotness; 102 return 0; 103 } 104 LLVMRemarkEntryGetNumArgs(LLVMRemarkEntryRef Remark)105extern "C" uint32_t LLVMRemarkEntryGetNumArgs(LLVMRemarkEntryRef Remark) { 106 return unwrap(Remark)->Args.size(); 107 } 108 109 extern "C" LLVMRemarkArgRef LLVMRemarkEntryGetFirstArg(LLVMRemarkEntryRef Remark)110LLVMRemarkEntryGetFirstArg(LLVMRemarkEntryRef Remark) { 111 ArrayRef<Argument> Args = unwrap(Remark)->Args; 112 // No arguments to iterate on. 113 if (Args.empty()) 114 return NULL; 115 return reinterpret_cast<LLVMRemarkArgRef>( 116 const_cast<Argument *>(Args.begin())); 117 } 118 119 extern "C" LLVMRemarkArgRef LLVMRemarkEntryGetNextArg(LLVMRemarkArgRef ArgIt,LLVMRemarkEntryRef Remark)120LLVMRemarkEntryGetNextArg(LLVMRemarkArgRef ArgIt, LLVMRemarkEntryRef Remark) { 121 // No more arguments to iterate on. 122 if (ArgIt == NULL) 123 return NULL; 124 125 auto It = (ArrayRef<Argument>::const_iterator)ArgIt; 126 auto Next = std::next(It); 127 if (Next == unwrap(Remark)->Args.end()) 128 return NULL; 129 130 return reinterpret_cast<LLVMRemarkArgRef>(const_cast<Argument *>(Next)); 131 } 132