1 //===- YAMLRemarkParser.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 // This file provides utility methods used by clients that want to use the
10 // parser for remark diagnostics in LLVM.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "YAMLRemarkParser.h"
15 #include "llvm/ADT/StringSwitch.h"
16 #include "llvm/Support/Endian.h"
17 #include "llvm/Support/Path.h"
18 
19 using namespace llvm;
20 using namespace llvm::remarks;
21 
22 char YAMLParseError::ID = 0;
23 
24 static void handleDiagnostic(const SMDiagnostic &Diag, void *Ctx) {
25   assert(Ctx && "Expected non-null Ctx in diagnostic handler.");
26   std::string &Message = *static_cast<std::string *>(Ctx);
27   assert(Message.empty() && "Expected an empty string.");
28   raw_string_ostream OS(Message);
29   Diag.print(/*ProgName=*/nullptr, OS, /*ShowColors*/ false,
30              /*ShowKindLabels*/ true);
31   OS << '\n';
32   OS.flush();
33 }
34 
35 YAMLParseError::YAMLParseError(StringRef Msg, SourceMgr &SM,
36                                yaml::Stream &Stream, yaml::Node &Node) {
37   // 1) Set up a diagnostic handler to avoid errors being printed out to
38   // stderr.
39   // 2) Use the stream to print the error with the associated node.
40   // 3) The stream will use the source manager to print the error, which will
41   // call the diagnostic handler.
42   // 4) The diagnostic handler will stream the error directly into this object's
43   // Message member, which is used when logging is asked for.
44   auto OldDiagHandler = SM.getDiagHandler();
45   auto OldDiagCtx = SM.getDiagContext();
46   SM.setDiagHandler(handleDiagnostic, &Message);
47   Stream.printError(&Node, Twine(Msg) + Twine('\n'));
48   // Restore the old handlers.
49   SM.setDiagHandler(OldDiagHandler, OldDiagCtx);
50 }
51 
52 static SourceMgr setupSM(std::string &LastErrorMessage) {
53   SourceMgr SM;
54   SM.setDiagHandler(handleDiagnostic, &LastErrorMessage);
55   return SM;
56 }
57 
58 // Parse the magic number. This function returns true if this represents remark
59 // metadata, false otherwise.
60 static Expected<bool> parseMagic(StringRef &Buf) {
61   if (!Buf.consume_front(remarks::Magic))
62     return false;
63 
64   if (Buf.size() < 1 || !Buf.consume_front(StringRef("\0", 1)))
65     return createStringError(std::errc::illegal_byte_sequence,
66                              "Expecting \\0 after magic number.");
67   return true;
68 }
69 
70 static Expected<uint64_t> parseVersion(StringRef &Buf) {
71   if (Buf.size() < sizeof(uint64_t))
72     return createStringError(std::errc::illegal_byte_sequence,
73                              "Expecting version number.");
74 
75   uint64_t Version =
76       support::endian::read<uint64_t, support::little, support::unaligned>(
77           Buf.data());
78   if (Version != remarks::CurrentRemarkVersion)
79     return createStringError(std::errc::illegal_byte_sequence,
80                              "Mismatching remark version. Got %" PRId64
81                              ", expected %" PRId64 ".",
82                              Version, remarks::CurrentRemarkVersion);
83   Buf = Buf.drop_front(sizeof(uint64_t));
84   return Version;
85 }
86 
87 static Expected<uint64_t> parseStrTabSize(StringRef &Buf) {
88   if (Buf.size() < sizeof(uint64_t))
89     return createStringError(std::errc::illegal_byte_sequence,
90                              "Expecting string table size.");
91   uint64_t StrTabSize =
92       support::endian::read<uint64_t, support::little, support::unaligned>(
93           Buf.data());
94   Buf = Buf.drop_front(sizeof(uint64_t));
95   return StrTabSize;
96 }
97 
98 static Expected<ParsedStringTable> parseStrTab(StringRef &Buf,
99                                                uint64_t StrTabSize) {
100   if (Buf.size() < StrTabSize)
101     return createStringError(std::errc::illegal_byte_sequence,
102                              "Expecting string table.");
103 
104   // Attach the string table to the parser.
105   ParsedStringTable Result(StringRef(Buf.data(), StrTabSize));
106   Buf = Buf.drop_front(StrTabSize);
107   return Expected<ParsedStringTable>(std::move(Result));
108 }
109 
110 Expected<std::unique_ptr<YAMLRemarkParser>>
111 remarks::createYAMLParserFromMeta(StringRef Buf,
112                                   Optional<ParsedStringTable> StrTab,
113                                   Optional<StringRef> ExternalFilePrependPath) {
114   // We now have a magic number. The metadata has to be correct.
115   Expected<bool> isMeta = parseMagic(Buf);
116   if (!isMeta)
117     return isMeta.takeError();
118   // If it's not recognized as metadata, roll back.
119   std::unique_ptr<MemoryBuffer> SeparateBuf;
120   if (*isMeta) {
121     Expected<uint64_t> Version = parseVersion(Buf);
122     if (!Version)
123       return Version.takeError();
124 
125     Expected<uint64_t> StrTabSize = parseStrTabSize(Buf);
126     if (!StrTabSize)
127       return StrTabSize.takeError();
128 
129     // If the size of string table is not 0, try to build one.
130     if (*StrTabSize != 0) {
131       if (StrTab)
132         return createStringError(std::errc::illegal_byte_sequence,
133                                  "String table already provided.");
134       Expected<ParsedStringTable> MaybeStrTab = parseStrTab(Buf, *StrTabSize);
135       if (!MaybeStrTab)
136         return MaybeStrTab.takeError();
137       StrTab = std::move(*MaybeStrTab);
138     }
139     // If it starts with "---", there is no external file.
140     if (!Buf.startswith("---")) {
141       // At this point, we expect Buf to contain the external file path.
142       StringRef ExternalFilePath = Buf;
143       SmallString<80> FullPath;
144       if (ExternalFilePrependPath)
145         FullPath = *ExternalFilePrependPath;
146       sys::path::append(FullPath, ExternalFilePath);
147 
148       // Try to open the file and start parsing from there.
149       ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr =
150           MemoryBuffer::getFile(FullPath);
151       if (std::error_code EC = BufferOrErr.getError())
152         return createFileError(FullPath, EC);
153 
154       // Keep the buffer alive.
155       SeparateBuf = std::move(*BufferOrErr);
156       Buf = SeparateBuf->getBuffer();
157     }
158   }
159 
160   std::unique_ptr<YAMLRemarkParser> Result =
161       StrTab
162           ? std::make_unique<YAMLStrTabRemarkParser>(Buf, std::move(*StrTab))
163           : std::make_unique<YAMLRemarkParser>(Buf);
164   if (SeparateBuf)
165     Result->SeparateBuf = std::move(SeparateBuf);
166   return std::move(Result);
167 }
168 
169 YAMLRemarkParser::YAMLRemarkParser(StringRef Buf)
170     : YAMLRemarkParser(Buf, None) {}
171 
172 YAMLRemarkParser::YAMLRemarkParser(StringRef Buf,
173                                    Optional<ParsedStringTable> StrTab)
174     : RemarkParser{Format::YAML}, StrTab(std::move(StrTab)),
175       SM(setupSM(LastErrorMessage)), Stream(Buf, SM), YAMLIt(Stream.begin()) {}
176 
177 Error YAMLRemarkParser::error(StringRef Message, yaml::Node &Node) {
178   return make_error<YAMLParseError>(Message, SM, Stream, Node);
179 }
180 
181 Error YAMLRemarkParser::error() {
182   if (LastErrorMessage.empty())
183     return Error::success();
184   Error E = make_error<YAMLParseError>(LastErrorMessage);
185   LastErrorMessage.clear();
186   return E;
187 }
188 
189 Expected<std::unique_ptr<Remark>>
190 YAMLRemarkParser::parseRemark(yaml::Document &RemarkEntry) {
191   if (Error E = error())
192     return std::move(E);
193 
194   yaml::Node *YAMLRoot = RemarkEntry.getRoot();
195   if (!YAMLRoot) {
196     return createStringError(std::make_error_code(std::errc::invalid_argument),
197                              "not a valid YAML file.");
198   }
199 
200   auto *Root = dyn_cast<yaml::MappingNode>(YAMLRoot);
201   if (!Root)
202     return error("document root is not of mapping type.", *YAMLRoot);
203 
204   std::unique_ptr<Remark> Result = std::make_unique<Remark>();
205   Remark &TheRemark = *Result;
206 
207   // First, the type. It needs special handling since is not part of the
208   // key-value stream.
209   Expected<Type> T = parseType(*Root);
210   if (!T)
211     return T.takeError();
212   else
213     TheRemark.RemarkType = *T;
214 
215   // Then, parse the fields, one by one.
216   for (yaml::KeyValueNode &RemarkField : *Root) {
217     Expected<StringRef> MaybeKey = parseKey(RemarkField);
218     if (!MaybeKey)
219       return MaybeKey.takeError();
220     StringRef KeyName = *MaybeKey;
221 
222     if (KeyName == "Pass") {
223       if (Expected<StringRef> MaybeStr = parseStr(RemarkField))
224         TheRemark.PassName = *MaybeStr;
225       else
226         return MaybeStr.takeError();
227     } else if (KeyName == "Name") {
228       if (Expected<StringRef> MaybeStr = parseStr(RemarkField))
229         TheRemark.RemarkName = *MaybeStr;
230       else
231         return MaybeStr.takeError();
232     } else if (KeyName == "Function") {
233       if (Expected<StringRef> MaybeStr = parseStr(RemarkField))
234         TheRemark.FunctionName = *MaybeStr;
235       else
236         return MaybeStr.takeError();
237     } else if (KeyName == "Hotness") {
238       if (Expected<unsigned> MaybeU = parseUnsigned(RemarkField))
239         TheRemark.Hotness = *MaybeU;
240       else
241         return MaybeU.takeError();
242     } else if (KeyName == "DebugLoc") {
243       if (Expected<RemarkLocation> MaybeLoc = parseDebugLoc(RemarkField))
244         TheRemark.Loc = *MaybeLoc;
245       else
246         return MaybeLoc.takeError();
247     } else if (KeyName == "Args") {
248       auto *Args = dyn_cast<yaml::SequenceNode>(RemarkField.getValue());
249       if (!Args)
250         return error("wrong value type for key.", RemarkField);
251 
252       for (yaml::Node &Arg : *Args) {
253         if (Expected<Argument> MaybeArg = parseArg(Arg))
254           TheRemark.Args.push_back(*MaybeArg);
255         else
256           return MaybeArg.takeError();
257       }
258     } else {
259       return error("unknown key.", RemarkField);
260     }
261   }
262 
263   // Check if any of the mandatory fields are missing.
264   if (TheRemark.RemarkType == Type::Unknown || TheRemark.PassName.empty() ||
265       TheRemark.RemarkName.empty() || TheRemark.FunctionName.empty())
266     return error("Type, Pass, Name or Function missing.",
267                  *RemarkEntry.getRoot());
268 
269   return std::move(Result);
270 }
271 
272 Expected<Type> YAMLRemarkParser::parseType(yaml::MappingNode &Node) {
273   auto Type = StringSwitch<remarks::Type>(Node.getRawTag())
274                   .Case("!Passed", remarks::Type::Passed)
275                   .Case("!Missed", remarks::Type::Missed)
276                   .Case("!Analysis", remarks::Type::Analysis)
277                   .Case("!AnalysisFPCommute", remarks::Type::AnalysisFPCommute)
278                   .Case("!AnalysisAliasing", remarks::Type::AnalysisAliasing)
279                   .Case("!Failure", remarks::Type::Failure)
280                   .Default(remarks::Type::Unknown);
281   if (Type == remarks::Type::Unknown)
282     return error("expected a remark tag.", Node);
283   return Type;
284 }
285 
286 Expected<StringRef> YAMLRemarkParser::parseKey(yaml::KeyValueNode &Node) {
287   if (auto *Key = dyn_cast<yaml::ScalarNode>(Node.getKey()))
288     return Key->getRawValue();
289 
290   return error("key is not a string.", Node);
291 }
292 
293 Expected<StringRef> YAMLRemarkParser::parseStr(yaml::KeyValueNode &Node) {
294   auto *Value = dyn_cast<yaml::ScalarNode>(Node.getValue());
295   if (!Value)
296     return error("expected a value of scalar type.", Node);
297   StringRef Result = Value->getRawValue();
298 
299   if (Result.front() == '\'')
300     Result = Result.drop_front();
301 
302   if (Result.back() == '\'')
303     Result = Result.drop_back();
304 
305   return Result;
306 }
307 
308 Expected<unsigned> YAMLRemarkParser::parseUnsigned(yaml::KeyValueNode &Node) {
309   SmallVector<char, 4> Tmp;
310   auto *Value = dyn_cast<yaml::ScalarNode>(Node.getValue());
311   if (!Value)
312     return error("expected a value of scalar type.", Node);
313   unsigned UnsignedValue = 0;
314   if (Value->getValue(Tmp).getAsInteger(10, UnsignedValue))
315     return error("expected a value of integer type.", *Value);
316   return UnsignedValue;
317 }
318 
319 Expected<RemarkLocation>
320 YAMLRemarkParser::parseDebugLoc(yaml::KeyValueNode &Node) {
321   auto *DebugLoc = dyn_cast<yaml::MappingNode>(Node.getValue());
322   if (!DebugLoc)
323     return error("expected a value of mapping type.", Node);
324 
325   Optional<StringRef> File;
326   Optional<unsigned> Line;
327   Optional<unsigned> Column;
328 
329   for (yaml::KeyValueNode &DLNode : *DebugLoc) {
330     Expected<StringRef> MaybeKey = parseKey(DLNode);
331     if (!MaybeKey)
332       return MaybeKey.takeError();
333     StringRef KeyName = *MaybeKey;
334 
335     if (KeyName == "File") {
336       if (Expected<StringRef> MaybeStr = parseStr(DLNode))
337         File = *MaybeStr;
338       else
339         return MaybeStr.takeError();
340     } else if (KeyName == "Column") {
341       if (Expected<unsigned> MaybeU = parseUnsigned(DLNode))
342         Column = *MaybeU;
343       else
344         return MaybeU.takeError();
345     } else if (KeyName == "Line") {
346       if (Expected<unsigned> MaybeU = parseUnsigned(DLNode))
347         Line = *MaybeU;
348       else
349         return MaybeU.takeError();
350     } else {
351       return error("unknown entry in DebugLoc map.", DLNode);
352     }
353   }
354 
355   // If any of the debug loc fields is missing, return an error.
356   if (!File || !Line || !Column)
357     return error("DebugLoc node incomplete.", Node);
358 
359   return RemarkLocation{*File, *Line, *Column};
360 }
361 
362 Expected<Argument> YAMLRemarkParser::parseArg(yaml::Node &Node) {
363   auto *ArgMap = dyn_cast<yaml::MappingNode>(&Node);
364   if (!ArgMap)
365     return error("expected a value of mapping type.", Node);
366 
367   Optional<StringRef> KeyStr;
368   Optional<StringRef> ValueStr;
369   Optional<RemarkLocation> Loc;
370 
371   for (yaml::KeyValueNode &ArgEntry : *ArgMap) {
372     Expected<StringRef> MaybeKey = parseKey(ArgEntry);
373     if (!MaybeKey)
374       return MaybeKey.takeError();
375     StringRef KeyName = *MaybeKey;
376 
377     // Try to parse debug locs.
378     if (KeyName == "DebugLoc") {
379       // Can't have multiple DebugLoc entries per argument.
380       if (Loc)
381         return error("only one DebugLoc entry is allowed per argument.",
382                      ArgEntry);
383 
384       if (Expected<RemarkLocation> MaybeLoc = parseDebugLoc(ArgEntry)) {
385         Loc = *MaybeLoc;
386         continue;
387       } else
388         return MaybeLoc.takeError();
389     }
390 
391     // If we already have a string, error out.
392     if (ValueStr)
393       return error("only one string entry is allowed per argument.", ArgEntry);
394 
395     // Try to parse the value.
396     if (Expected<StringRef> MaybeStr = parseStr(ArgEntry))
397       ValueStr = *MaybeStr;
398     else
399       return MaybeStr.takeError();
400 
401     // Keep the key from the string.
402     KeyStr = KeyName;
403   }
404 
405   if (!KeyStr)
406     return error("argument key is missing.", *ArgMap);
407   if (!ValueStr)
408     return error("argument value is missing.", *ArgMap);
409 
410   return Argument{*KeyStr, *ValueStr, Loc};
411 }
412 
413 Expected<std::unique_ptr<Remark>> YAMLRemarkParser::next() {
414   if (YAMLIt == Stream.end())
415     return make_error<EndOfFileError>();
416 
417   Expected<std::unique_ptr<Remark>> MaybeResult = parseRemark(*YAMLIt);
418   if (!MaybeResult) {
419     // Avoid garbage input, set the iterator to the end.
420     YAMLIt = Stream.end();
421     return MaybeResult.takeError();
422   }
423 
424   ++YAMLIt;
425 
426   return std::move(*MaybeResult);
427 }
428 
429 Expected<StringRef> YAMLStrTabRemarkParser::parseStr(yaml::KeyValueNode &Node) {
430   auto *Value = dyn_cast<yaml::ScalarNode>(Node.getValue());
431   if (!Value)
432     return error("expected a value of scalar type.", Node);
433   StringRef Result;
434   // If we have a string table, parse it as an unsigned.
435   unsigned StrID = 0;
436   if (Expected<unsigned> MaybeStrID = parseUnsigned(Node))
437     StrID = *MaybeStrID;
438   else
439     return MaybeStrID.takeError();
440 
441   if (Expected<StringRef> Str = (*StrTab)[StrID])
442     Result = *Str;
443   else
444     return Str.takeError();
445 
446   if (Result.front() == '\'')
447     Result = Result.drop_front();
448 
449   if (Result.back() == '\'')
450     Result = Result.drop_back();
451 
452   return Result;
453 }
454