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