Debian Codegraph @

llvm-project/llvm/unittests/Remarks/YAMLRemarksParsingTest.cpp

raw
1 //===- unittest/Support/YAMLRemarksParsingTest.cpp - OptTable tests -------===//
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 #include "llvm-c/Remarks.h"
10 #include "llvm/Remarks/Remark.h"
11 #include "llvm/Remarks/RemarkParser.h"
12 #include "gtest/gtest.h"
13 #include <optional>
14
15 using namespace llvm;
16
17 template <size_t N> void parseGood(const char (&Buf)[N]) {
18 Expected<std::unique_ptr<remarks::RemarkParser>> MaybeParser =
19 remarks::createRemarkParser(remarks::Format::YAML, {Buf, N - 1});
20 EXPECT_FALSE(errorToBool(MaybeParser.takeError()));
21 EXPECT_TRUE(*MaybeParser != nullptr);
22
23 remarks::RemarkParser &Parser = **MaybeParser;
24 Expected<std::unique_ptr<remarks::Remark>> Remark = Parser.next();
25 EXPECT_FALSE(errorToBool(Remark.takeError())); // Check for parsing errors.
26 EXPECT_TRUE(*Remark != nullptr); // At least one remark.
27 Remark = Parser.next();
28 Error E = Remark.takeError();
29 EXPECT_TRUE(E.isA<remarks::EndOfFileError>());
30 EXPECT_TRUE(errorToBool(std::move(E))); // Check for parsing errors.
31 }
32
33 void parseGoodMeta(StringRef Buf) {
34 Expected<std::unique_ptr<remarks::RemarkParser>> MaybeParser =
35 remarks::createRemarkParserFromMeta(remarks::Format::YAML, Buf);
36 EXPECT_FALSE(errorToBool(MaybeParser.takeError()));
37 EXPECT_TRUE(*MaybeParser != nullptr);
38
39 remarks::RemarkParser &Parser = **MaybeParser;
40 Expected<std::unique_ptr<remarks::Remark>> Remark = Parser.next();
41 EXPECT_FALSE(errorToBool(Remark.takeError())); // Check for parsing errors.
42 EXPECT_TRUE(*Remark != nullptr); // At least one remark.
43 Remark = Parser.next();
44 Error E = Remark.takeError();
45 EXPECT_TRUE(E.isA<remarks::EndOfFileError>());
46 EXPECT_TRUE(errorToBool(std::move(E))); // Check for parsing errors.
47 }
48
49 template <size_t N>
50 bool parseExpectError(const char (&Buf)[N], const char *Error) {
51 Expected<std::unique_ptr<remarks::RemarkParser>> MaybeParser =
52 remarks::createRemarkParser(remarks::Format::YAML, {Buf, N - 1});
53 EXPECT_FALSE(errorToBool(MaybeParser.takeError()));
54 EXPECT_TRUE(*MaybeParser != nullptr);
55
56 remarks::RemarkParser &Parser = **MaybeParser;
57 Expected<std::unique_ptr<remarks::Remark>> Remark = Parser.next();
58 EXPECT_FALSE(Remark); // Check for parsing errors.
59
60 std::string ErrorStr;
61 raw_string_ostream Stream(ErrorStr);
62 handleAllErrors(Remark.takeError(),
63 [&](const ErrorInfoBase &EIB) { EIB.log(Stream); });
64 return StringRef(Stream.str()).contains(Error);
65 }
66
67 enum class CmpType {
68 Equal,
69 Contains
70 };
71
72 void parseExpectErrorMeta(
73 StringRef Buf, const char *Error, CmpType Cmp,
74 std::optional<StringRef> ExternalFilePrependPath = std::nullopt) {
75 std::string ErrorStr;
76 raw_string_ostream Stream(ErrorStr);
77
78 Expected<std::unique_ptr<remarks::RemarkParser>> MaybeParser =
79 remarks::createRemarkParserFromMeta(remarks::Format::YAML, Buf,
80 /*StrTab=*/std::nullopt,
81 std::move(ExternalFilePrependPath));
82 handleAllErrors(MaybeParser.takeError(),
83 [&](const ErrorInfoBase &EIB) { EIB.log(Stream); });
84
85 // Use a case insensitive comparision due to case differences in error strings
86 // for different OSs.
87 if (Cmp == CmpType::Equal) {
88 EXPECT_EQ(StringRef(Stream.str()).lower(), StringRef(Error).lower());
89 }
90
91 if (Cmp == CmpType::Contains) {
92 EXPECT_TRUE(StringRef(Stream.str()).contains(StringRef(Error)));
93 }
94 }
95
96 TEST(YAMLRemarks, ParsingEmpty) {
97 EXPECT_TRUE(parseExpectError("\n\n", "document root is not of mapping type."));
98 }
99
100 TEST(YAMLRemarks, ParsingNotYAML) {
101 EXPECT_TRUE(
102 parseExpectError("\x01\x02\x03\x04\x05\x06", "Got empty plain scalar"));
103 }
104
105 TEST(YAMLRemarks, ParsingGood) {
106 parseGood("\n"
107 "--- !Missed\n"
108 "Pass: inline\n"
109 "Name: NoDefinition\n"
110 "DebugLoc: { File: file.c, Line: 3, Column: 12 }\n"
111 "Function: foo\n"
112 "Args:\n"
113 " - Callee: bar\n"
114 " - String: ' will not be inlined into '\n"
115 " - Caller: foo\n"
116 " DebugLoc: { File: file.c, Line: 2, Column: 0 }\n"
117 " - String: ' because its definition is unavailable'\n"
118 "");
119
120 // No debug loc should also pass.
121 parseGood("\n"
122 "--- !Missed\n"
123 "Pass: inline\n"
124 "Name: NoDefinition\n"
125 "Function: foo\n"
126 "Args:\n"
127 " - Callee: bar\n"
128 " - String: ' will not be inlined into '\n"
129 " - Caller: foo\n"
130 " DebugLoc: { File: file.c, Line: 2, Column: 0 }\n"
131 " - String: ' because its definition is unavailable'\n"
132 "");
133
134 // No args is also ok.
135 parseGood("\n"
136 "--- !Missed\n"
137 "Pass: inline\n"
138 "Name: NoDefinition\n"
139 "DebugLoc: { File: file.c, Line: 3, Column: 12 }\n"
140 "Function: foo\n"
141 "");
142
143 // Different order.
144 parseGood("\n"
145 "--- !Missed\n"
146 "DebugLoc: { Line: 3, Column: 12, File: file.c }\n"
147 "Function: foo\n"
148 "Name: NoDefinition\n"
149 "Args:\n"
150 " - Callee: bar\n"
151 " - String: ' will not be inlined into '\n"
152 " - Caller: foo\n"
153 " DebugLoc: { File: file.c, Line: 2, Column: 0 }\n"
154 " - String: ' because its definition is unavailable'\n"
155 "Pass: inline\n"
156 "");
157 }
158
159 // Mandatory common part of a remark.
160 #define COMMON_REMARK "\nPass: inline\nName: NoDefinition\nFunction: foo\n\n"
161 // Test all the types.
162 TEST(YAMLRemarks, ParsingTypes) {
163 // Type: Passed
164 parseGood("--- !Passed" COMMON_REMARK);
165 // Type: Missed
166 parseGood("--- !Missed" COMMON_REMARK);
167 // Type: Analysis
168 parseGood("--- !Analysis" COMMON_REMARK);
169 // Type: AnalysisFPCommute
170 parseGood("--- !AnalysisFPCommute" COMMON_REMARK);
171 // Type: AnalysisAliasing
172 parseGood("--- !AnalysisAliasing" COMMON_REMARK);
173 // Type: Failure
174 parseGood("--- !Failure" COMMON_REMARK);
175 }
176 #undef COMMON_REMARK
177
178 TEST(YAMLRemarks, ParsingMissingFields) {
179 // No type.
180 EXPECT_TRUE(parseExpectError("\n"
181 "---\n"
182 "Pass: inline\n"
183 "Name: NoDefinition\n"
184 "Function: foo\n"
185 "",
186 "expected a remark tag."));
187 // No pass.
188 EXPECT_TRUE(parseExpectError("\n"
189 "--- !Missed\n"
190 "Name: NoDefinition\n"
191 "Function: foo\n"
192 "",
193 "Type, Pass, Name or Function missing."));
194 // No name.
195 EXPECT_TRUE(parseExpectError("\n"
196 "--- !Missed\n"
197 "Pass: inline\n"
198 "Function: foo\n"
199 "",
200 "Type, Pass, Name or Function missing."));
201 // No function.
202 EXPECT_TRUE(parseExpectError("\n"
203 "--- !Missed\n"
204 "Pass: inline\n"
205 "Name: NoDefinition\n"
206 "",
207 "Type, Pass, Name or Function missing."));
208 // Debug loc but no file.
209 EXPECT_TRUE(parseExpectError("\n"
210 "--- !Missed\n"
211 "Pass: inline\n"
212 "Name: NoDefinition\n"
213 "Function: foo\n"
214 "DebugLoc: { Line: 3, Column: 12 }\n"
215 "",
216 "DebugLoc node incomplete."));
217 // Debug loc but no line.
218 EXPECT_TRUE(parseExpectError("\n"
219 "--- !Missed\n"
220 "Pass: inline\n"
221 "Name: NoDefinition\n"
222 "Function: foo\n"
223 "DebugLoc: { File: file.c, Column: 12 }\n"
224 "",
225 "DebugLoc node incomplete."));
226 // Debug loc but no column.
227 EXPECT_TRUE(parseExpectError("\n"
228 "--- !Missed\n"
229 "Pass: inline\n"
230 "Name: NoDefinition\n"
231 "Function: foo\n"
232 "DebugLoc: { File: file.c, Line: 3 }\n"
233 "",
234 "DebugLoc node incomplete."));
235 }
236
237 TEST(YAMLRemarks, ParsingWrongTypes) {
238 // Wrong debug loc type.
239 EXPECT_TRUE(parseExpectError("\n"
240 "--- !Missed\n"
241 "Pass: inline\n"
242 "Name: NoDefinition\n"
243 "Function: foo\n"
244 "DebugLoc: foo\n"
245 "",
246 "expected a value of mapping type."));
247 // Wrong line type.
248 EXPECT_TRUE(parseExpectError("\n"
249 "--- !Missed\n"
250 "Pass: inline\n"
251 "Name: NoDefinition\n"
252 "Function: foo\n"
253 "DebugLoc: { File: file.c, Line: b, Column: 12 }\n"
254 "",
255 "expected a value of integer type."));
256 // Wrong column type.
257 EXPECT_TRUE(parseExpectError("\n"
258 "--- !Missed\n"
259 "Pass: inline\n"
260 "Name: NoDefinition\n"
261 "Function: foo\n"
262 "DebugLoc: { File: file.c, Line: 3, Column: c }\n"
263 "",
264 "expected a value of integer type."));
265 // Wrong args type.
266 EXPECT_TRUE(parseExpectError("\n"
267 "--- !Missed\n"
268 "Pass: inline\n"
269 "Name: NoDefinition\n"
270 "Function: foo\n"
271 "Args: foo\n"
272 "",
273 "wrong value type for key."));
274 // Wrong key type.
275 EXPECT_TRUE(parseExpectError("\n"
276 "--- !Missed\n"
277 "{ A: a }: inline\n"
278 "Name: NoDefinition\n"
279 "Function: foo\n"
280 "",
281 "key is not a string."));
282 // Debug loc with unknown entry.
283 EXPECT_TRUE(parseExpectError("\n"
284 "--- !Missed\n"
285 "Pass: inline\n"
286 "Name: NoDefinition\n"
287 "Function: foo\n"
288 "DebugLoc: { File: file.c, Column: 12, Unknown: 12 }\n"
289 "",
290 "unknown entry in DebugLoc map."));
291 // Unknown entry.
292 EXPECT_TRUE(parseExpectError("\n"
293 "--- !Missed\n"
294 "Unknown: inline\n"
295 "",
296 "unknown key."));
297 // Not a scalar.
298 EXPECT_TRUE(parseExpectError("\n"
299 "--- !Missed\n"
300 "Pass: { File: a, Line: 1, Column: 2 }\n"
301 "Name: NoDefinition\n"
302 "Function: foo\n"
303 "",
304 "expected a value of scalar type."));
305 // Not a string file in debug loc.
306 EXPECT_TRUE(parseExpectError("\n"
307 "--- !Missed\n"
308 "Pass: inline\n"
309 "Name: NoDefinition\n"
310 "Function: foo\n"
311 "DebugLoc: { File: { a: b }, Column: 12, Line: 12 }\n"
312 "",
313 "expected a value of scalar type."));
314 // Not a integer column in debug loc.
315 EXPECT_TRUE(parseExpectError("\n"
316 "--- !Missed\n"
317 "Pass: inline\n"
318 "Name: NoDefinition\n"
319 "Function: foo\n"
320 "DebugLoc: { File: file.c, Column: { a: b }, Line: 12 }\n"
321 "",
322 "expected a value of scalar type."));
323 // Not a integer line in debug loc.
324 EXPECT_TRUE(parseExpectError("\n"
325 "--- !Missed\n"
326 "Pass: inline\n"
327 "Name: NoDefinition\n"
328 "Function: foo\n"
329 "DebugLoc: { File: file.c, Column: 12, Line: { a: b } }\n"
330 "",
331 "expected a value of scalar type."));
332 // Not a mapping type value for args.
333 EXPECT_TRUE(parseExpectError("\n"
334 "--- !Missed\n"
335 "Pass: inline\n"
336 "Name: NoDefinition\n"
337 "Function: foo\n"
338 "DebugLoc: { File: file.c, Column: 12, Line: { a: b } }\n"
339 "",
340 "expected a value of scalar type."));
341 }
342
343 TEST(YAMLRemarks, ParsingWrongArgs) {
344 // Multiple debug locs per arg.
345 EXPECT_TRUE(parseExpectError("\n"
346 "--- !Missed\n"
347 "Pass: inline\n"
348 "Name: NoDefinition\n"
349 "Function: foo\n"
350 "Args:\n"
351 " - Str: string\n"
352 " DebugLoc: { File: a, Line: 1, Column: 2 }\n"
353 " DebugLoc: { File: a, Line: 1, Column: 2 }\n"
354 "",
355 "only one DebugLoc entry is allowed per argument."));
356 // Multiple strings per arg.
357 EXPECT_TRUE(parseExpectError("\n"
358 "--- !Missed\n"
359 "Pass: inline\n"
360 "Name: NoDefinition\n"
361 "Function: foo\n"
362 "Args:\n"
363 " - Str: string\n"
364 " Str2: string\n"
365 " DebugLoc: { File: a, Line: 1, Column: 2 }\n"
366 "",
367 "only one string entry is allowed per argument."));
368 // No arg value.
369 EXPECT_TRUE(parseExpectError("\n"
370 "--- !Missed\n"
371 "Pass: inline\n"
372 "Name: NoDefinition\n"
373 "Function: foo\n"
374 "Args:\n"
375 " - DebugLoc: { File: a, Line: 1, Column: 2 }\n"
376 "",
377 "argument key is missing."));
378 }
379
380 static inline StringRef checkStr(StringRef Str, unsigned ExpectedLen) {
381 const char *StrData = Str.data();
382 unsigned StrLen = Str.size();
383 EXPECT_EQ(StrLen, ExpectedLen);
384 return StringRef(StrData, StrLen);
385 }
386
387 TEST(YAMLRemarks, Contents) {
388 StringRef Buf = "\n"
389 "--- !Missed\n"
390 "Pass: inline\n"
391 "Name: NoDefinition\n"
392 "DebugLoc: { File: file.c, Line: 3, Column: 12 }\n"
393 "Function: foo\n"
394 "Hotness: 4\n"
395 "Args:\n"
396 " - Callee: bar\n"
397 " - String: ' will not be inlined into '\n"
398 " - Caller: foo\n"
399 " DebugLoc: { File: file.c, Line: 2, Column: 0 }\n"
400 " - String: ' because its definition is unavailable'\n"
401 "\n";
402
403 Expected<std::unique_ptr<remarks::RemarkParser>> MaybeParser =
404 remarks::createRemarkParser(remarks::Format::YAML, Buf);
405 EXPECT_FALSE(errorToBool(MaybeParser.takeError()));
406 EXPECT_TRUE(*MaybeParser != nullptr);
407
408 remarks::RemarkParser &Parser = **MaybeParser;
409 Expected<std::unique_ptr<remarks::Remark>> MaybeRemark = Parser.next();
410 EXPECT_FALSE(
411 errorToBool(MaybeRemark.takeError())); // Check for parsing errors.
412 EXPECT_TRUE(*MaybeRemark != nullptr); // At least one remark.
413
414 const remarks::Remark &Remark = **MaybeRemark;
415 EXPECT_EQ(Remark.RemarkType, remarks::Type::Missed);
416 EXPECT_EQ(checkStr(Remark.PassName, 6), "inline");
417 EXPECT_EQ(checkStr(Remark.RemarkName, 12), "NoDefinition");
418 EXPECT_EQ(checkStr(Remark.FunctionName, 3), "foo");
419 EXPECT_TRUE(Remark.Loc);
420 const remarks::RemarkLocation &RL = *Remark.Loc;
421 EXPECT_EQ(checkStr(RL.SourceFilePath, 6), "file.c");
422 EXPECT_EQ(RL.SourceLine, 3U);
423 EXPECT_EQ(RL.SourceColumn, 12U);
424 EXPECT_TRUE(Remark.Hotness);
425 EXPECT_EQ(*Remark.Hotness, 4U);
426 EXPECT_EQ(Remark.Args.size(), 4U);
427
428 unsigned ArgID = 0;
429 for (const remarks::Argument &Arg : Remark.Args) {
430 switch (ArgID) {
431 case 0:
432 EXPECT_EQ(checkStr(Arg.Key, 6), "Callee");
433 EXPECT_EQ(checkStr(Arg.Val, 3), "bar");
434 EXPECT_FALSE(Arg.Loc);
435 break;
436 case 1:
437 EXPECT_EQ(checkStr(Arg.Key, 6), "String");
438 EXPECT_EQ(checkStr(Arg.Val, 26), " will not be inlined into ");
439 EXPECT_FALSE(Arg.Loc);
440 break;
441 case 2: {
442 EXPECT_EQ(checkStr(Arg.Key, 6), "Caller");
443 EXPECT_EQ(checkStr(Arg.Val, 3), "foo");
444 EXPECT_TRUE(Arg.Loc);
445 const remarks::RemarkLocation &RL = *Arg.Loc;
446 EXPECT_EQ(checkStr(RL.SourceFilePath, 6), "file.c");
447 EXPECT_EQ(RL.SourceLine, 2U);
448 EXPECT_EQ(RL.SourceColumn, 0U);
449 break;
450 }
451 case 3:
452 EXPECT_EQ(checkStr(Arg.Key, 6), "String");
453 EXPECT_EQ(checkStr(Arg.Val, 38),
454 " because its definition is unavailable");
455 EXPECT_FALSE(Arg.Loc);
456 break;
457 default:
458 break;
459 }
460 ++ArgID;
461 }
462
463 MaybeRemark = Parser.next();
464 Error E = MaybeRemark.takeError();
465 EXPECT_TRUE(E.isA<remarks::EndOfFileError>());
466 EXPECT_TRUE(errorToBool(std::move(E))); // Check for parsing errors.
467 }
468
469 static inline StringRef checkStr(LLVMRemarkStringRef Str,
470 unsigned ExpectedLen) {
471 const char *StrData = LLVMRemarkStringGetData(Str);
472 unsigned StrLen = LLVMRemarkStringGetLen(Str);
473 EXPECT_EQ(StrLen, ExpectedLen);
474 return StringRef(StrData, StrLen);
475 }
476
477 TEST(YAMLRemarks, ContentsCAPI) {
478 StringRef Buf = "\n"
479 "--- !Missed\n"
480 "Pass: inline\n"
481 "Name: NoDefinition\n"
482 "DebugLoc: { File: file.c, Line: 3, Column: 12 }\n"
483 "Function: foo\n"
484 "Args:\n"
485 " - Callee: bar\n"
486 " - String: ' will not be inlined into '\n"
487 " - Caller: foo\n"
488 " DebugLoc: { File: file.c, Line: 2, Column: 0 }\n"
489 " - String: ' because its definition is unavailable'\n"
490 "\n";
491
492 LLVMRemarkParserRef Parser =
493 LLVMRemarkParserCreateYAML(Buf.data(), Buf.size());
494 LLVMRemarkEntryRef Remark = LLVMRemarkParserGetNext(Parser);
495 EXPECT_FALSE(Remark == nullptr);
496 EXPECT_EQ(LLVMRemarkEntryGetType(Remark), LLVMRemarkTypeMissed);
497 EXPECT_EQ(checkStr(LLVMRemarkEntryGetPassName(Remark), 6), "inline");
498 EXPECT_EQ(checkStr(LLVMRemarkEntryGetRemarkName(Remark), 12), "NoDefinition");
499 EXPECT_EQ(checkStr(LLVMRemarkEntryGetFunctionName(Remark), 3), "foo");
500 LLVMRemarkDebugLocRef DL = LLVMRemarkEntryGetDebugLoc(Remark);
501 EXPECT_EQ(checkStr(LLVMRemarkDebugLocGetSourceFilePath(DL), 6), "file.c");
502 EXPECT_EQ(LLVMRemarkDebugLocGetSourceLine(DL), 3U);
503 EXPECT_EQ(LLVMRemarkDebugLocGetSourceColumn(DL), 12U);
504 EXPECT_EQ(LLVMRemarkEntryGetHotness(Remark), 0U);
505 EXPECT_EQ(LLVMRemarkEntryGetNumArgs(Remark), 4U);
506
507 unsigned ArgID = 0;
508 LLVMRemarkArgRef Arg = LLVMRemarkEntryGetFirstArg(Remark);
509 do {
510 switch (ArgID) {
511 case 0:
512 EXPECT_EQ(checkStr(LLVMRemarkArgGetKey(Arg), 6), "Callee");
513 EXPECT_EQ(checkStr(LLVMRemarkArgGetValue(Arg), 3), "bar");
514 EXPECT_EQ(LLVMRemarkArgGetDebugLoc(Arg), nullptr);
515 break;
516 case 1:
517 EXPECT_EQ(checkStr(LLVMRemarkArgGetKey(Arg), 6), "String");
518 EXPECT_EQ(checkStr(LLVMRemarkArgGetValue(Arg), 26),
519 " will not be inlined into ");
520 EXPECT_EQ(LLVMRemarkArgGetDebugLoc(Arg), nullptr);
521 break;
522 case 2: {
523 EXPECT_EQ(checkStr(LLVMRemarkArgGetKey(Arg), 6), "Caller");
524 EXPECT_EQ(checkStr(LLVMRemarkArgGetValue(Arg), 3), "foo");
525 LLVMRemarkDebugLocRef DL = LLVMRemarkArgGetDebugLoc(Arg);
526 EXPECT_EQ(checkStr(LLVMRemarkDebugLocGetSourceFilePath(DL), 6), "file.c");
527 EXPECT_EQ(LLVMRemarkDebugLocGetSourceLine(DL), 2U);
528 EXPECT_EQ(LLVMRemarkDebugLocGetSourceColumn(DL), 0U);
529 break;
530 }
531 case 3:
532 EXPECT_EQ(checkStr(LLVMRemarkArgGetKey(Arg), 6), "String");
533 EXPECT_EQ(checkStr(LLVMRemarkArgGetValue(Arg), 38),
534 " because its definition is unavailable");
535 EXPECT_EQ(LLVMRemarkArgGetDebugLoc(Arg), nullptr);
536 break;
537 default:
538 break;
539 }
540 ++ArgID;
541 } while ((Arg = LLVMRemarkEntryGetNextArg(Arg, Remark)));
542
543 LLVMRemarkEntryDispose(Remark);
544
545 EXPECT_EQ(LLVMRemarkParserGetNext(Parser), nullptr);
546
547 EXPECT_FALSE(LLVMRemarkParserHasError(Parser));
548 LLVMRemarkParserDispose(Parser);
549 }
550
551 TEST(YAMLRemarks, ContentsStrTab) {
552 StringRef Buf = "\n"
553 "--- !Missed\n"
554 "Pass: 0\n"
555 "Name: 1\n"
556 "DebugLoc: { File: 2, Line: 3, Column: 12 }\n"
557 "Function: 3\n"
558 "Hotness: 4\n"
559 "Args:\n"
560 " - Callee: 5\n"
561 " - String: 7\n"
562 " - Caller: 3\n"
563 " DebugLoc: { File: 2, Line: 2, Column: 0 }\n"
564 " - String: 8\n"
565 "\n";
566
567 StringRef StrTabBuf =
568 StringRef("inline\0NoDefinition\0file.c\0foo\0Callee\0bar\0String\0 "
569 "will not be inlined into \0 because its definition is "
570 "unavailable",
571 115);
572
573 remarks::ParsedStringTable StrTab(StrTabBuf);
574 Expected<std::unique_ptr<remarks::RemarkParser>> MaybeParser =
575 remarks::createRemarkParser(remarks::Format::YAMLStrTab, Buf,
576 std::move(StrTab));
577 EXPECT_FALSE(errorToBool(MaybeParser.takeError()));
578 EXPECT_TRUE(*MaybeParser != nullptr);
579
580 remarks::RemarkParser &Parser = **MaybeParser;
581 Expected<std::unique_ptr<remarks::Remark>> MaybeRemark = Parser.next();
582 EXPECT_FALSE(
583 errorToBool(MaybeRemark.takeError())); // Check for parsing errors.
584 EXPECT_TRUE(*MaybeRemark != nullptr); // At least one remark.
585
586 const remarks::Remark &Remark = **MaybeRemark;
587 EXPECT_EQ(Remark.RemarkType, remarks::Type::Missed);
588 EXPECT_EQ(checkStr(Remark.PassName, 6), "inline");
589 EXPECT_EQ(checkStr(Remark.RemarkName, 12), "NoDefinition");
590 EXPECT_EQ(checkStr(Remark.FunctionName, 3), "foo");
591 EXPECT_TRUE(Remark.Loc);
592 const remarks::RemarkLocation &RL = *Remark.Loc;
593 EXPECT_EQ(checkStr(RL.SourceFilePath, 6), "file.c");
594 EXPECT_EQ(RL.SourceLine, 3U);
595 EXPECT_EQ(RL.SourceColumn, 12U);
596 EXPECT_TRUE(Remark.Hotness);
597 EXPECT_EQ(*Remark.Hotness, 4U);
598 EXPECT_EQ(Remark.Args.size(), 4U);
599
600 unsigned ArgID = 0;
601 for (const remarks::Argument &Arg : Remark.Args) {
602 switch (ArgID) {
603 case 0:
604 EXPECT_EQ(checkStr(Arg.Key, 6), "Callee");
605 EXPECT_EQ(checkStr(Arg.Val, 3), "bar");
606 EXPECT_FALSE(Arg.Loc);
607 break;
608 case 1:
609 EXPECT_EQ(checkStr(Arg.Key, 6), "String");
610 EXPECT_EQ(checkStr(Arg.Val, 26), " will not be inlined into ");
611 EXPECT_FALSE(Arg.Loc);
612 break;
613 case 2: {
614 EXPECT_EQ(checkStr(Arg.Key, 6), "Caller");
615 EXPECT_EQ(checkStr(Arg.Val, 3), "foo");
616 EXPECT_TRUE(Arg.Loc);
617 const remarks::RemarkLocation &RL = *Arg.Loc;
618 EXPECT_EQ(checkStr(RL.SourceFilePath, 6), "file.c");
619 EXPECT_EQ(RL.SourceLine, 2U);
620 EXPECT_EQ(RL.SourceColumn, 0U);
621 break;
622 }
623 case 3:
624 EXPECT_EQ(checkStr(Arg.Key, 6), "String");
625 EXPECT_EQ(checkStr(Arg.Val, 38),
626 " because its definition is unavailable");
627 EXPECT_FALSE(Arg.Loc);
628 break;
629 default:
630 break;
631 }
632 ++ArgID;
633 }
634
635 MaybeRemark = Parser.next();
636 Error E = MaybeRemark.takeError();
637 EXPECT_TRUE(E.isA<remarks::EndOfFileError>());
638 EXPECT_TRUE(errorToBool(std::move(E))); // Check for parsing errors.
639 }
640
641 TEST(YAMLRemarks, ParsingBadStringTableIndex) {
642 StringRef Buf = "\n"
643 "--- !Missed\n"
644 "Pass: 50\n"
645 "\n";
646
647 StringRef StrTabBuf = StringRef("inline");
648
649 remarks::ParsedStringTable StrTab(StrTabBuf);
650 Expected<std::unique_ptr<remarks::RemarkParser>> MaybeParser =
651 remarks::createRemarkParser(remarks::Format::YAMLStrTab, Buf,
652 std::move(StrTab));
653 EXPECT_FALSE(errorToBool(MaybeParser.takeError()));
654 EXPECT_TRUE(*MaybeParser != nullptr);
655
656 remarks::RemarkParser &Parser = **MaybeParser;
657 Expected<std::unique_ptr<remarks::Remark>> MaybeRemark = Parser.next();
658 EXPECT_FALSE(MaybeRemark); // Expect an error here.
659
660 std::string ErrorStr;
661 raw_string_ostream Stream(ErrorStr);
662 handleAllErrors(MaybeRemark.takeError(),
663 [&](const ErrorInfoBase &EIB) { EIB.log(Stream); });
664 EXPECT_TRUE(
665 StringRef(Stream.str())
666 .contains("String with index 50 is out of bounds (size = 1)."));
667 }
668
669 TEST(YAMLRemarks, ParsingGoodMeta) {
670 // No metadata should also work.
671 parseGoodMeta("--- !Missed\n"
672 "Pass: inline\n"
673 "Name: NoDefinition\n"
674 "Function: foo\n");
675
676 // No string table.
677 parseGoodMeta(StringRef("REMARKS\0"
678 "\0\0\0\0\0\0\0\0"
679 "\0\0\0\0\0\0\0\0"
680 "--- !Missed\n"
681 "Pass: inline\n"
682 "Name: NoDefinition\n"
683 "Function: foo\n",
684 82));
685
686 // Use the string table from the metadata.
687 parseGoodMeta(StringRef("REMARKS\0"
688 "\0\0\0\0\0\0\0\0"
689 "\x02\0\0\0\0\0\0\0"
690 "a\0"
691 "--- !Missed\n"
692 "Pass: 0\n"
693 "Name: 0\n"
694 "Function: 0\n",
695 66));
696 }
697
698 TEST(YAMLRemarks, ParsingBadMeta) {
699 parseExpectErrorMeta(StringRef("REMARKSS", 9),
700 "Expecting \\0 after magic number.", CmpType::Equal);
701
702 parseExpectErrorMeta(StringRef("REMARKS\0", 8), "Expecting version number.",
703 CmpType::Equal);
704
705 parseExpectErrorMeta(StringRef("REMARKS\0"
706 "\x09\0\0\0\0\0\0\0",
707 16),
708 "Mismatching remark version. Got 9, expected 0.",
709 CmpType::Equal);
710
711 parseExpectErrorMeta(StringRef("REMARKS\0"
712 "\0\0\0\0\0\0\0\0",
713 16),
714 "Expecting string table size.", CmpType::Equal);
715
716 parseExpectErrorMeta(StringRef("REMARKS\0"
717 "\0\0\0\0\0\0\0\0"
718 "\x01\0\0\0\0\0\0\0",
719 24),
720 "Expecting string table.", CmpType::Equal);
721
722 parseExpectErrorMeta(StringRef("REMARKS\0"
723 "\0\0\0\0\0\0\0\0"
724 "\0\0\0\0\0\0\0\0"
725 "/path/",
726 30),
727 "'/path/'", CmpType::Contains);
728
729 parseExpectErrorMeta(StringRef("REMARKS\0"
730 "\0\0\0\0\0\0\0\0"
731 "\0\0\0\0\0\0\0\0"
732 "/path/",
733 30),
734 "'/baddir/path/'", CmpType::Contains,
735 StringRef("/baddir/"));
736 }