1//===-- LVOptions.h ---------------------------------------------*- 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 the LVOptions class, which is used to record the command
10// line options.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_DEBUGINFO_LOGICALVIEW_CORE_LVOPTIONS_H
15#define LLVM_DEBUGINFO_LOGICALVIEW_CORE_LVOPTIONS_H
16
17#include "llvm/ADT/StringSet.h"
18#include "llvm/DebugInfo/LogicalView/Core/LVLine.h"
19#include "llvm/DebugInfo/LogicalView/Core/LVScope.h"
20#include "llvm/DebugInfo/LogicalView/Core/LVSymbol.h"
21#include "llvm/DebugInfo/LogicalView/Core/LVType.h"
22#include "llvm/Support/Regex.h"
23#include <set>
24#include <string>
25
26namespace llvm {
27namespace logicalview {
28
29// Generate get and set 'bool' functions.
30#define BOOL_FUNCTION(FAMILY, FIELD) \
31 bool get##FAMILY##FIELD() const { return FAMILY.FIELD; } \
32 void set##FAMILY##FIELD() { FAMILY.FIELD = true; } \
33 void reset##FAMILY##FIELD() { FAMILY.FIELD = false; }
34
35// Generate get and set 'unsigned' functions.
36#define UNSIGNED_FUNCTION(FAMILY, FIELD) \
37 unsigned get##FAMILY##FIELD() const { return FAMILY.FIELD; } \
38 void set##FAMILY##FIELD(unsigned Value) { FAMILY.FIELD = Value; } \
39 void reset##FAMILY##FIELD() { FAMILY.FIELD = -1U; }
40
41// Generate get and set 'std::string' functions.
42#define STD_STRING_FUNCTION(FAMILY, FIELD) \
43 std::string get##FAMILY##FIELD() const { return FAMILY.FIELD; } \
44 void set##FAMILY##FIELD(std::string FIELD) { FAMILY.FIELD = FIELD; } \
45 void reset##FAMILY##FIELD() { FAMILY.FIELD = ""; }
46
47// Generate get and set 'std::set' functions.
48#define STDSET_FUNCTION_4(FAMILY, FIELD, TYPE, SET) \
49 bool get##FAMILY##FIELD() const { \
50 return FAMILY.SET.find(TYPE::FIELD) != FAMILY.SET.end(); \
51 } \
52 void set##FAMILY##FIELD() { FAMILY.SET.insert(TYPE::FIELD); } \
53 void reset##FAMILY##FIELD() { \
54 std::set<TYPE>::iterator Iter = FAMILY.SET.find(TYPE::FIELD); \
55 if (Iter != FAMILY.SET.end()) \
56 FAMILY.SET.erase(Iter); \
57 }
58
59#define STDSET_FUNCTION_5(FAMILY, FIELD, ENTRY, TYPE, SET) \
60 bool get##FAMILY##FIELD##ENTRY() const { \
61 return FAMILY.SET.find(TYPE::ENTRY) != FAMILY.SET.end(); \
62 } \
63 void set##FAMILY##FIELD##ENTRY() { FAMILY.SET.insert(TYPE::ENTRY); }
64
65// Generate get and set functions for '--attribute'
66#define ATTRIBUTE_OPTION(FIELD) \
67 STDSET_FUNCTION_4(Attribute, FIELD, LVAttributeKind, Kinds)
68
69// Generate get and set functions for '--output'
70#define OUTPUT_OPTION(FIELD) \
71 STDSET_FUNCTION_4(Output, FIELD, LVOutputKind, Kinds)
72
73// Generate get and set functions for '--print'
74#define PRINT_OPTION(FIELD) STDSET_FUNCTION_4(Print, FIELD, LVPrintKind, Kinds)
75
76// Generate get and set functions for '--warning'
77#define WARNING_OPTION(FIELD) \
78 STDSET_FUNCTION_4(Warning, FIELD, LVWarningKind, Kinds)
79
80// Generate get and set functions for '--compare'
81#define COMPARE_OPTION(FIELD) \
82 STDSET_FUNCTION_4(Compare, FIELD, LVCompareKind, Elements)
83
84// Generate get and set functions for '--report'
85#define REPORT_OPTION(FIELD) \
86 STDSET_FUNCTION_4(Report, FIELD, LVReportKind, Kinds)
87
88// Generate get and set functions for '--internal'
89#define INTERNAL_OPTION(FIELD) \
90 STDSET_FUNCTION_4(Internal, FIELD, LVInternalKind, Kinds)
91
92using LVOffsetSet = std::set<uint64_t>;
93
94enum class LVAttributeKind {
95 All, // --attribute=all
96 Argument, // --attribute=argument
97 Base, // --attribute=base
98 Coverage, // --attribute=coverage
99 Directories, // --attribute=directories
100 Discarded, // --attribute=discarded
101 Discriminator, // --attribute=discriminator
102 Encoded, // --attribute=encoded
103 Extended, // --attribute=extended
104 Filename, // --attribute=filename
105 Files, // --attribute=files
106 Format, // --attribute=format
107 Gaps, // --attribute=gaps
108 Generated, // --attribute=generated
109 Global, // --attribute=global
110 Inserted, // --attribute=inserted
111 Level, // --attribute=level
112 Linkage, // --attribute=linkage
113 Local, // --attribute=local
114 Location, // --attribute=location
115 Offset, // --attribute=offset
116 Pathname, // --attribute=pathname
117 Producer, // --attribute=producer
118 Publics, // --attribute=publics
119 Qualified, // --attribute=qualified
120 Qualifier, // --attribute=qualifier
121 Range, // --attribute=range
122 Reference, // --attribute=reference
123 Register, // --attribute=register
124 Standard, // --attribute=standard
125 Subrange, // --attribute=subrange
126 System, // --attribute=system
127 Typename, // --attribute=typename
128 Underlying, // --attribute=underlying
129 Zero // --attribute=zero
130};
131using LVAttributeKindSet = std::set<LVAttributeKind>;
132
133enum class LVCompareKind {
134 All, // --compare=all
135 Lines, // --compare=lines
136 Scopes, // --compare=scopes
137 Symbols, // --compare=symbols
138 Types // --compare=types
139};
140using LVCompareKindSet = std::set<LVCompareKind>;
141
142enum class LVOutputKind {
143 All, // --output=all
144 Split, // --output=split
145 Json, // --output=json
146 Text // --output=text
147};
148using LVOutputKindSet = std::set<LVOutputKind>;
149
150enum class LVPrintKind {
151 All, // --print=all
152 Elements, // --print=elements
153 Instructions, // --print=instructions
154 Lines, // --print=lines
155 Scopes, // --print=scopes
156 Sizes, // --print=sizes
157 Symbols, // --print=symbols
158 Summary, // --print=summary
159 Types, // --print=types
160 Warnings // --print=warnings
161};
162using LVPrintKindSet = std::set<LVPrintKind>;
163
164enum class LVReportKind {
165 All, // --report=all
166 Children, // --report=children
167 List, // --report=list
168 Parents, // --report=parents
169 View // --report=view
170};
171using LVReportKindSet = std::set<LVReportKind>;
172
173enum class LVWarningKind {
174 All, // --warning=all
175 Coverages, // --warning=coverages
176 Lines, // --warning=lines
177 Locations, // --warning=locations
178 Ranges // --warning=ranges
179};
180using LVWarningKindSet = std::set<LVWarningKind>;
181
182enum class LVInternalKind {
183 All, // --internal=all
184 Cmdline, // --internal=cmdline
185 ID, // --internal=id
186 Integrity, // --internal=integrity
187 None, // --internal=none
188 Tag // --internal=tag
189};
190using LVInternalKindSet = std::set<LVInternalKind>;
191
192// The 'Kinds' members are a one-to-one mapping to the associated command
193// options that supports comma separated values. There are other 'bool'
194// members that in very few cases point to a command option (see associated
195// comment). Other cases for 'bool' refers to internal values derivated from
196// the command options.
197class LVOptions {
198 class LVAttribute {
199 public:
200 LVAttributeKindSet Kinds; // --attribute=<Kind>
201 bool Added = false; // Added elements found during comparison.
202 bool AnyLocation = false; // Any kind of location information.
203 bool AnySource = false; // Any kind of source information.
204 bool Missing = false; // Missing elements found during comparison.
205 };
206
207 class LVCompare {
208 public:
209 LVCompareKindSet Elements; // --compare=<kind>
210 bool Context = false; // --compare-context
211 bool Execute = false; // Compare requested.
212 bool Print = false; // Enable any printing.
213 };
214
215 class LVPrint {
216 public:
217 LVPrintKindSet Kinds; // --print=<Kind>
218 bool AnyElement = false; // Request to print any element.
219 bool AnyLine = false; // Print 'lines' or 'instructions'.
220 bool Execute = false; // Print requested.
221 bool Formatting = true; // Disable formatting during printing.
222 bool Offset = false; // Print offsets while formatting is disabled.
223 bool SizesSummary = false; // Print 'sizes' or 'summary'.
224 };
225
226 class LVReport {
227 public:
228 LVReportKindSet Kinds; // --report=<kind>
229 bool AnyView = false; // View, Parents or Children.
230 bool Execute = false; // Report requested.
231 };
232
233 class LVSelect {
234 public:
235 bool IgnoreCase = false; // --select-ignore-case
236 bool UseRegex = false; // --select-use-regex
237 bool Execute = false; // Select requested.
238 bool GenericKind = false; // We have collected generic kinds.
239 bool GenericPattern = false; // We have collected generic patterns.
240 bool OffsetPattern = false; // We have collected offset patterns.
241 StringSet<> Generic; // --select=<Pattern>
242 LVOffsetSet Offsets; // --select-offset=<Offset>
243 LVElementKindSet Elements; // --select-elements=<Kind>
244 LVLineKindSet Lines; // --select-lines=<Kind>
245 LVScopeKindSet Scopes; // --select-scopes=<Kind>
246 LVSymbolKindSet Symbols; // --select-symbols=<Kind>
247 LVTypeKindSelection Types; // --select-types=<Kind>
248 };
249
250 class LVOutput {
251 public:
252 LVOutputKindSet Kinds; // --output=<kind>
253 LVSortMode SortMode = LVSortMode::None; // --output-sort=<SortMode>
254 std::string Folder; // --output-folder=<Folder>
255 unsigned Level = -1U; // --output-level=<level>
256 };
257
258 class LVWarning {
259 public:
260 LVWarningKindSet Kinds; // --warning=<Kind>
261 };
262
263 class LVInternal {
264 public:
265 LVInternalKindSet Kinds; // --internal=<Kind>
266 };
267
268 class LVGeneral {
269 public:
270 bool CollectRanges = false; // Collect ranges information.
271 };
272
273 // Filters the output of the filename associated with the element being
274 // printed in order to see clearly which logical elements belongs to
275 // a particular filename. It is value is reset after the element
276 // that represents the Compile Unit is printed.
277 size_t LastFilenameIndex = 0;
278
279 // Controls the amount of additional spaces to insert when printing
280 // object attributes, in order to get a consistent printing layout.
281 size_t IndentationSize = 0;
282
283 // Calculate the indentation size, so we can use that value when printing
284 // additional attributes to objects, such as location.
285 void calculateIndentationSize();
286
287public:
288 void resetFilenameIndex() { LastFilenameIndex = 0; }
289 bool changeFilenameIndex(size_t Index) {
290 bool IndexChanged = (Index != LastFilenameIndex);
291 if (IndexChanged)
292 LastFilenameIndex = Index;
293 return IndexChanged;
294 }
295
296 // Access to command line options, pattern and printing information.
297 static LVOptions *getOptions();
298 static void setOptions(LVOptions *Options);
299
300 LVOptions() = default;
301 LVOptions(const LVOptions &) = default;
302 LVOptions &operator=(const LVOptions &) = default;
303 ~LVOptions() = default;
304
305 // Some command line options support shortcuts. For example:
306 // The command line option '--print=elements' is a shortcut for:
307 // '--print=instructions,lines,scopes,symbols,types'.
308 // In the case of logical view comparison, some options related to
309 // attributes must be set or reset for a proper comparison.
310 // Resolve any dependencies between command line options.
311 void resolveDependencies();
312 size_t indentationSize() const { return IndentationSize; }
313
314 LVAttribute Attribute;
315 LVCompare Compare;
316 LVOutput Output;
317 LVPrint Print;
318 LVReport Report;
319 LVSelect Select;
320 LVWarning Warning;
321 LVInternal Internal;
322 LVGeneral General;
323
324 // --attribute.
325 ATTRIBUTE_OPTION(All);
326 ATTRIBUTE_OPTION(Argument);
327 ATTRIBUTE_OPTION(Base);
328 ATTRIBUTE_OPTION(Coverage);
329 ATTRIBUTE_OPTION(Directories);
330 ATTRIBUTE_OPTION(Discarded);
331 ATTRIBUTE_OPTION(Discriminator);
332 ATTRIBUTE_OPTION(Encoded);
333 ATTRIBUTE_OPTION(Extended);
334 ATTRIBUTE_OPTION(Filename);
335 ATTRIBUTE_OPTION(Files);
336 ATTRIBUTE_OPTION(Format);
337 ATTRIBUTE_OPTION(Gaps);
338 ATTRIBUTE_OPTION(Generated);
339 ATTRIBUTE_OPTION(Global);
340 ATTRIBUTE_OPTION(Inserted);
341 ATTRIBUTE_OPTION(Level);
342 ATTRIBUTE_OPTION(Linkage);
343 ATTRIBUTE_OPTION(Location);
344 ATTRIBUTE_OPTION(Local);
345 ATTRIBUTE_OPTION(Offset);
346 ATTRIBUTE_OPTION(Pathname);
347 ATTRIBUTE_OPTION(Producer);
348 ATTRIBUTE_OPTION(Publics);
349 ATTRIBUTE_OPTION(Qualified);
350 ATTRIBUTE_OPTION(Qualifier);
351 ATTRIBUTE_OPTION(Range);
352 ATTRIBUTE_OPTION(Reference);
353 ATTRIBUTE_OPTION(Register);
354 ATTRIBUTE_OPTION(Standard);
355 ATTRIBUTE_OPTION(Subrange);
356 ATTRIBUTE_OPTION(System);
357 ATTRIBUTE_OPTION(Typename);
358 ATTRIBUTE_OPTION(Underlying);
359 ATTRIBUTE_OPTION(Zero);
360 BOOL_FUNCTION(Attribute, Added);
361 BOOL_FUNCTION(Attribute, AnyLocation);
362 BOOL_FUNCTION(Attribute, AnySource);
363 BOOL_FUNCTION(Attribute, Missing);
364
365 // --compare.
366 COMPARE_OPTION(All);
367 COMPARE_OPTION(Lines);
368 COMPARE_OPTION(Scopes);
369 COMPARE_OPTION(Symbols);
370 COMPARE_OPTION(Types);
371 BOOL_FUNCTION(Compare, Context);
372 BOOL_FUNCTION(Compare, Execute);
373 BOOL_FUNCTION(Compare, Print);
374
375 // --output.
376 OUTPUT_OPTION(All);
377 OUTPUT_OPTION(Split);
378 OUTPUT_OPTION(Text);
379 OUTPUT_OPTION(Json);
380 STD_STRING_FUNCTION(Output, Folder);
381 UNSIGNED_FUNCTION(Output, Level);
382 LVSortMode getSortMode() const { return Output.SortMode; }
383 void setSortMode(LVSortMode SortMode) { Output.SortMode = SortMode; }
384
385 // --print.
386 PRINT_OPTION(All);
387 PRINT_OPTION(Elements);
388 PRINT_OPTION(Instructions);
389 PRINT_OPTION(Lines);
390 PRINT_OPTION(Scopes);
391 PRINT_OPTION(Sizes);
392 PRINT_OPTION(Symbols);
393 PRINT_OPTION(Summary);
394 PRINT_OPTION(Types);
395 PRINT_OPTION(Warnings);
396 BOOL_FUNCTION(Print, AnyElement);
397 BOOL_FUNCTION(Print, AnyLine);
398 BOOL_FUNCTION(Print, Execute);
399 BOOL_FUNCTION(Print, Formatting);
400 BOOL_FUNCTION(Print, Offset);
401 BOOL_FUNCTION(Print, SizesSummary);
402
403 // --report.
404 REPORT_OPTION(All);
405 REPORT_OPTION(Children);
406 REPORT_OPTION(List);
407 REPORT_OPTION(Parents);
408 REPORT_OPTION(View);
409 BOOL_FUNCTION(Report, AnyView);
410 BOOL_FUNCTION(Report, Execute);
411
412 // --select.
413 BOOL_FUNCTION(Select, IgnoreCase);
414 BOOL_FUNCTION(Select, UseRegex);
415 BOOL_FUNCTION(Select, Execute);
416 BOOL_FUNCTION(Select, GenericKind);
417 BOOL_FUNCTION(Select, GenericPattern);
418 BOOL_FUNCTION(Select, OffsetPattern);
419
420 // --warning.
421 WARNING_OPTION(All);
422 WARNING_OPTION(Coverages);
423 WARNING_OPTION(Lines);
424 WARNING_OPTION(Locations);
425 WARNING_OPTION(Ranges);
426
427 // --internal.
428 INTERNAL_OPTION(All);
429 INTERNAL_OPTION(Cmdline);
430 INTERNAL_OPTION(ID);
431 INTERNAL_OPTION(Integrity);
432 INTERNAL_OPTION(None);
433 INTERNAL_OPTION(Tag);
434
435 // General shortcuts to some combinations.
436 BOOL_FUNCTION(General, CollectRanges);
437
438 void print(raw_ostream &OS) const;
439
440#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
441 void dump() const { print(OS&: dbgs()); }
442#endif
443};
444
445inline LVOptions &options() { return (*LVOptions::getOptions()); }
446inline void setOptions(LVOptions *Options) { LVOptions::setOptions(Options); }
447
448class LVPatterns final {
449 // Pattern Mode.
450 enum class LVMatchMode {
451 None = 0, // No given pattern.
452 Match, // Perfect match.
453 NoCase, // Ignore case.
454 Regex // Regular expression.
455 };
456
457 // Keep the search pattern information.
458 struct LVMatch {
459 std::string Pattern; // Normal pattern.
460 std::shared_ptr<Regex> RE; // Regular Expression Pattern.
461 LVMatchMode Mode = LVMatchMode::None; // Match mode.
462 };
463
464 using LVMatchInfo = std::vector<LVMatch>;
465 LVMatchInfo GenericMatchInfo;
466 using LVMatchOffsets = std::vector<uint64_t>;
467 LVMatchOffsets OffsetMatchInfo;
468
469 // Element selection.
470 LVElementDispatch ElementDispatch;
471 LVLineDispatch LineDispatch;
472 LVScopeDispatch ScopeDispatch;
473 LVSymbolDispatch SymbolDispatch;
474 LVTypeDispatch TypeDispatch;
475
476 // Element selection request.
477 LVElementRequest ElementRequest;
478 LVLineRequest LineRequest;
479 LVScopeRequest ScopeRequest;
480 LVSymbolRequest SymbolRequest;
481 LVTypeRequest TypeRequest;
482
483 // Check an element printing Request.
484 template <typename T, typename U>
485 bool checkElementRequest(const T *Element, const U &Requests) const {
486 assert(Element && "Element must not be nullptr");
487 for (const auto &Request : Requests)
488 if ((Element->*Request)())
489 return true;
490 // Check generic element requests.
491 for (const LVElementGetFunction &Request : ElementRequest)
492 if ((Element->*Request)())
493 return true;
494 return false;
495 }
496
497 // Add an element printing request based on its kind.
498 template <typename T, typename U, typename V>
499 void addRequest(const T &Selection, const U &Dispatch, V &Request) const {
500 for (const auto &Entry : Selection) {
501 // Find target function to fullfit request.
502 typename U::const_iterator Iter = Dispatch.find(Entry);
503 if (Iter != Dispatch.end())
504 Request.push_back(Iter->second);
505 }
506 }
507
508 void addElement(LVElement *Element);
509
510 template <typename T, typename U>
511 void resolveGenericPatternMatch(T *Element, const U &Requests) {
512 assert(Element && "Element must not be nullptr");
513 auto CheckPattern = [this, Element]() -> bool {
514 return (Element->isNamed() &&
515 (matchGenericPattern(Input: Element->getName()) ||
516 matchGenericPattern(Input: Element->getLinkageName()))) ||
517 (Element->isTyped() &&
518 matchGenericPattern(Input: Element->getTypeName()));
519 };
520 auto CheckOffset = [this, Element]() -> bool {
521 return matchOffsetPattern(Offset: Element->getOffset());
522 };
523 if ((options().getSelectGenericPattern() && CheckPattern()) ||
524 (options().getSelectOffsetPattern() && CheckOffset()) ||
525 ((Requests.size() || ElementRequest.size()) &&
526 checkElementRequest(Element, Requests)))
527 addElement(Element);
528 }
529
530 template <typename U>
531 void resolveGenericPatternMatch(LVLine *Line, const U &Requests) {
532 assert(Line && "Line must not be nullptr");
533 auto CheckPattern = [this, Line]() -> bool {
534 return matchGenericPattern(Input: Line->lineNumberAsStringStripped()) ||
535 matchGenericPattern(Input: Line->getName()) ||
536 matchGenericPattern(Input: Line->getPathname());
537 };
538 auto CheckOffset = [this, Line]() -> bool {
539 return matchOffsetPattern(Offset: Line->getAddress());
540 };
541 if ((options().getSelectGenericPattern() && CheckPattern()) ||
542 (options().getSelectOffsetPattern() && CheckOffset()) ||
543 (Requests.size() && checkElementRequest(Line, Requests)))
544 addElement(Element: Line);
545 }
546
547 Error createMatchEntry(LVMatchInfo &Filters, StringRef Pattern,
548 bool IgnoreCase, bool UseRegex);
549
550public:
551 static LVPatterns *getPatterns();
552
553 LVPatterns() {
554 ElementDispatch = LVElement::getDispatch();
555 LineDispatch = LVLine::getDispatch();
556 ScopeDispatch = LVScope::getDispatch();
557 SymbolDispatch = LVSymbol::getDispatch();
558 TypeDispatch = LVType::getDispatch();
559 }
560 LVPatterns(const LVPatterns &) = delete;
561 LVPatterns &operator=(const LVPatterns &) = delete;
562 ~LVPatterns() = default;
563
564 // Clear any existing patterns.
565 void clear() {
566 GenericMatchInfo.clear();
567 OffsetMatchInfo.clear();
568 ElementRequest.clear();
569 LineRequest.clear();
570 ScopeRequest.clear();
571 SymbolRequest.clear();
572 TypeRequest.clear();
573
574 options().resetSelectGenericKind();
575 options().resetSelectGenericPattern();
576 options().resetSelectOffsetPattern();
577 }
578
579 void addRequest(LVElementKindSet &Selection) {
580 addRequest(Selection, Dispatch: ElementDispatch, Request&: ElementRequest);
581 }
582 void addRequest(LVLineKindSet &Selection) {
583 addRequest(Selection, Dispatch: LineDispatch, Request&: LineRequest);
584 }
585 void addRequest(LVScopeKindSet &Selection) {
586 addRequest(Selection, Dispatch: ScopeDispatch, Request&: ScopeRequest);
587 }
588 void addRequest(LVSymbolKindSet &Selection) {
589 addRequest(Selection, Dispatch: SymbolDispatch, Request&: SymbolRequest);
590 }
591 void addRequest(LVTypeKindSelection &Selection) {
592 addRequest(Selection, Dispatch: TypeDispatch, Request&: TypeRequest);
593 }
594
595 void updateReportOptions();
596
597 bool matchPattern(StringRef Input, const LVMatchInfo &MatchInfo);
598 // Match a pattern (--select='pattern').
599 bool matchGenericPattern(StringRef Input) {
600 return matchPattern(Input, MatchInfo: GenericMatchInfo);
601 }
602 bool matchOffsetPattern(LVOffset Offset) {
603 return llvm::is_contained(Range&: OffsetMatchInfo, Element: Offset);
604 }
605
606 void resolvePatternMatch(LVLine *Line) {
607 resolveGenericPatternMatch(Line, Requests: LineRequest);
608 }
609
610 void resolvePatternMatch(LVScope *Scope) {
611 resolveGenericPatternMatch(Element: Scope, Requests: ScopeRequest);
612 }
613
614 void resolvePatternMatch(LVSymbol *Symbol) {
615 resolveGenericPatternMatch(Element: Symbol, Requests: SymbolRequest);
616 }
617
618 void resolvePatternMatch(LVType *Type) {
619 resolveGenericPatternMatch(Element: Type, Requests: TypeRequest);
620 }
621
622 void addPatterns(StringSet<> &Patterns, LVMatchInfo &Filters);
623
624 // Add generic and offset patterns info.
625 void addGenericPatterns(StringSet<> &Patterns);
626 void addOffsetPatterns(const LVOffsetSet &Patterns);
627
628 // Conditions to print an object.
629 bool printElement(const LVLine *Line) const;
630 bool printObject(const LVLocation *Location) const;
631 bool printElement(const LVScope *Scope) const;
632 bool printElement(const LVSymbol *Symbol) const;
633 bool printElement(const LVType *Type) const;
634
635 void print(raw_ostream &OS) const;
636
637#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
638 void dump() const { print(OS&: dbgs()); }
639#endif
640};
641
642inline LVPatterns &patterns() { return *LVPatterns::getPatterns(); }
643
644} // namespace logicalview
645} // namespace llvm
646
647#endif // LLVM_DEBUGINFO_LOGICALVIEW_CORE_LVOPTIONS_H
648

source code of llvm/include/llvm/DebugInfo/LogicalView/Core/LVOptions.h