LLVM 17.0.0git
LVOptions.h
Go to the documentation of this file.
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"
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.
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; }
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.
364
365 // --compare.
374
375 // --output.
382 LVSortMode getSortMode() const { return Output.SortMode; }
383 void setSortMode(LVSortMode SortMode) { Output.SortMode = SortMode; }
384
385 // --print.
396 BOOL_FUNCTION(Print, AnyElement);
399 BOOL_FUNCTION(Print, Formatting);
401 BOOL_FUNCTION(Print, SizesSummary);
402
403 // --report.
411
412 // --select.
413 BOOL_FUNCTION(Select, IgnoreCase);
416 BOOL_FUNCTION(Select, GenericKind);
417 BOOL_FUNCTION(Select, GenericPattern);
418 BOOL_FUNCTION(Select, OffsetPattern);
419
420 // --warning.
426
427 // --internal.
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(dbgs()); }
442#endif
443};
444
445inline LVOptions &options() { return (*LVOptions::getOptions()); }
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 = [=]() -> bool {
514 return (Element->isNamed() && matchGenericPattern(Element->getName())) ||
515 (Element->isTyped() &&
516 matchGenericPattern(Element->getTypeName()));
517 };
518 auto CheckOffset = [=]() -> bool {
519 return matchOffsetPattern(Element->getOffset());
520 };
521 if ((options().getSelectGenericPattern() && CheckPattern()) ||
522 (options().getSelectOffsetPattern() && CheckOffset()) ||
523 ((Requests.size() || ElementRequest.size()) &&
524 checkElementRequest(Element, Requests)))
525 addElement(Element);
526 }
527
528 template <typename U>
529 void resolveGenericPatternMatch(LVLine *Line, const U &Requests) {
530 assert(Line && "Line must not be nullptr");
531 auto CheckPattern = [=]() -> bool {
532 return matchGenericPattern(Line->lineNumberAsStringStripped()) ||
533 matchGenericPattern(Line->getName()) ||
534 matchGenericPattern(Line->getPathname());
535 };
536 auto CheckOffset = [=]() -> bool {
537 return matchOffsetPattern(Line->getAddress());
538 };
539 if ((options().getSelectGenericPattern() && CheckPattern()) ||
540 (options().getSelectOffsetPattern() && CheckOffset()) ||
541 (Requests.size() && checkElementRequest(Line, Requests)))
542 addElement(Line);
543 }
544
545 Error createMatchEntry(LVMatchInfo &Filters, StringRef Pattern,
546 bool IgnoreCase, bool UseRegex);
547
548public:
549 static LVPatterns *getPatterns();
550
552 ElementDispatch = LVElement::getDispatch();
553 LineDispatch = LVLine::getDispatch();
554 ScopeDispatch = LVScope::getDispatch();
555 SymbolDispatch = LVSymbol::getDispatch();
556 TypeDispatch = LVType::getDispatch();
557 }
558 LVPatterns(const LVPatterns &) = delete;
559 LVPatterns &operator=(const LVPatterns &) = delete;
560 ~LVPatterns() = default;
561
562 // Clear any existing patterns.
563 void clear() {
564 GenericMatchInfo.clear();
565 OffsetMatchInfo.clear();
566 ElementRequest.clear();
567 LineRequest.clear();
568 ScopeRequest.clear();
569 SymbolRequest.clear();
570 TypeRequest.clear();
571
572 options().resetSelectGenericKind();
573 options().resetSelectGenericPattern();
574 options().resetSelectOffsetPattern();
575 }
576
578 addRequest(Selection, ElementDispatch, ElementRequest);
579 }
581 addRequest(Selection, LineDispatch, LineRequest);
582 }
584 addRequest(Selection, ScopeDispatch, ScopeRequest);
585 }
587 addRequest(Selection, SymbolDispatch, SymbolRequest);
588 }
590 addRequest(Selection, TypeDispatch, TypeRequest);
591 }
592
593 void updateReportOptions();
594
595 bool matchPattern(StringRef Input, const LVMatchInfo &MatchInfo);
596 // Match a pattern (--select='pattern').
598 return matchPattern(Input, GenericMatchInfo);
599 }
601 return llvm::is_contained(OffsetMatchInfo, Offset);
602 }
603
605 resolveGenericPatternMatch(Line, LineRequest);
606 }
607
609 resolveGenericPatternMatch(Scope, ScopeRequest);
610 }
611
613 resolveGenericPatternMatch(Symbol, SymbolRequest);
614 }
615
617 resolveGenericPatternMatch(Type, TypeRequest);
618 }
619
620 void addPatterns(StringSet<> &Patterns, LVMatchInfo &Filters);
621
622 // Add generic and offset patterns info.
623 void addGenericPatterns(StringSet<> &Patterns);
624 void addOffsetPatterns(const LVOffsetSet &Patterns);
625
626 // Conditions to print an object.
627 bool printElement(const LVLine *Line) const;
628 bool printObject(const LVLocation *Location) const;
629 bool printElement(const LVScope *Scope) const;
630 bool printElement(const LVSymbol *Symbol) const;
631 bool printElement(const LVType *Type) const;
632
633 void print(raw_ostream &OS) const;
634
635#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
636 void dump() const { print(dbgs()); }
637#endif
638};
639
641
642} // namespace logicalview
643} // namespace llvm
644
645#endif // LLVM_DEBUGINFO_LOGICALVIEW_CORE_LVOPTIONS_H
@ Generic
amdgpu AMDGPU DAG DAG Pattern Instruction Selection
static LVOptions Options
Definition: LVOptions.cpp:25
LLVMContext & Context
static bool Execute(ProcessInfo &PI, StringRef Program, ArrayRef< StringRef > Args, std::optional< ArrayRef< StringRef > > Env, ArrayRef< std::optional< StringRef > > Redirects, unsigned MemoryLimit, std::string *ErrMsg, BitVector *AffinityMask)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
StringSet - A set-like wrapper for the StringMap.
This class represents an incoming formal argument to a Function.
Definition: Argument.h:28
Lightweight error class with error context and mandatory checking.
Definition: Error.h:156
Wrapper class representing virtual and physical registers.
Definition: Register.h:19
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
StringSet - A wrapper for StringMap that provides set-like functionality.
Definition: StringSet.h:23
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
static LVElementDispatch & getDispatch()
Definition: LVElement.h:347
static LVLineDispatch & getDispatch()
Definition: LVLine.h:87
size_t indentationSize() const
Definition: LVOptions.h:312
LVOptions & operator=(const LVOptions &)=default
BOOL_FUNCTION(Attribute, Missing)
LVSortMode getSortMode() const
Definition: LVOptions.h:382
ATTRIBUTE_OPTION(Discriminator)
BOOL_FUNCTION(Select, Execute)
BOOL_FUNCTION(Select, GenericPattern)
static void setOptions(LVOptions *Options)
Definition: LVOptions.cpp:27
BOOL_FUNCTION(Select, GenericKind)
BOOL_FUNCTION(Print, Formatting)
STD_STRING_FUNCTION(Output, Folder)
BOOL_FUNCTION(Compare, Execute)
UNSIGNED_FUNCTION(Output, Level)
BOOL_FUNCTION(Select, OffsetPattern)
BOOL_FUNCTION(Select, UseRegex)
static LVOptions * getOptions()
Definition: LVOptions.cpp:26
BOOL_FUNCTION(Print, AnyLine)
BOOL_FUNCTION(Print, SizesSummary)
void print(raw_ostream &OS) const
Definition: LVOptions.cpp:283
BOOL_FUNCTION(Report, Execute)
bool changeFilenameIndex(size_t Index)
Definition: LVOptions.h:289
BOOL_FUNCTION(Compare, Context)
BOOL_FUNCTION(Attribute, AnyLocation)
BOOL_FUNCTION(Print, AnyElement)
void setSortMode(LVSortMode SortMode)
Definition: LVOptions.h:383
BOOL_FUNCTION(Report, AnyView)
LVOptions(const LVOptions &)=default
BOOL_FUNCTION(Select, IgnoreCase)
BOOL_FUNCTION(Attribute, Added)
BOOL_FUNCTION(Attribute, AnySource)
BOOL_FUNCTION(General, CollectRanges)
BOOL_FUNCTION(Compare, Print)
BOOL_FUNCTION(Print, Execute)
void addGenericPatterns(StringSet<> &Patterns)
Definition: LVOptions.cpp:439
void resolvePatternMatch(LVType *Type)
Definition: LVOptions.h:616
void resolvePatternMatch(LVLine *Line)
Definition: LVOptions.h:604
void addRequest(LVTypeKindSelection &Selection)
Definition: LVOptions.h:589
bool matchOffsetPattern(LVOffset Offset)
Definition: LVOptions.h:600
void resolvePatternMatch(LVScope *Scope)
Definition: LVOptions.h:608
bool matchPattern(StringRef Input, const LVMatchInfo &MatchInfo)
Definition: LVOptions.cpp:506
void addRequest(LVElementKindSet &Selection)
Definition: LVOptions.h:577
void addRequest(LVLineKindSet &Selection)
Definition: LVOptions.h:580
bool printObject(const LVLocation *Location) const
Definition: LVOptions.cpp:538
void print(raw_ostream &OS) const
Definition: LVOptions.cpp:576
bool printElement(const LVLine *Line) const
Definition: LVOptions.cpp:533
LVPatterns(const LVPatterns &)=delete
void addPatterns(StringSet<> &Patterns, LVMatchInfo &Filters)
Definition: LVOptions.cpp:456
bool matchGenericPattern(StringRef Input)
Definition: LVOptions.h:597
void addOffsetPatterns(const LVOffsetSet &Patterns)
Definition: LVOptions.cpp:447
void resolvePatternMatch(LVSymbol *Symbol)
Definition: LVOptions.h:612
void addRequest(LVSymbolKindSet &Selection)
Definition: LVOptions.h:586
LVPatterns & operator=(const LVPatterns &)=delete
void addRequest(LVScopeKindSet &Selection)
Definition: LVOptions.h:583
static LVPatterns * getPatterns()
Definition: LVOptions.cpp:403
static LVScopeDispatch & getDispatch()
Definition: LVScope.h:313
static LVSymbolDispatch & getDispatch()
Definition: LVSymbol.h:161
static LVTypeDispatch & getDispatch()
Definition: LVType.h:115
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
std::set< LVPrintKind > LVPrintKindSet
Definition: LVOptions.h:162
std::set< LVLineKind > LVLineKindSet
Definition: LVLine.h:35
std::vector< LVSymbolGetFunction > LVSymbolRequest
Definition: LVSymbol.h:34
bool(LVElement::*)() const LVElementGetFunction
Definition: LVObject.h:65
std::set< LVScopeKind > LVScopeKindSet
Definition: LVScope.h:62
void setOptions(LVOptions *Options)
Definition: LVOptions.h:446
std::set< LVTypeKind > LVTypeKindSelection
Definition: LVType.h:46
std::set< LVElementKind > LVElementKindSet
Definition: LVElement.h:64
std::set< uint64_t > LVOffsetSet
Definition: LVOptions.h:92
std::set< LVOutputKind > LVOutputKindSet
Definition: LVOptions.h:148
LVPatterns & patterns()
Definition: LVOptions.h:640
std::map< LVScopeKind, LVScopeGetFunction > LVScopeDispatch
Definition: LVScope.h:63
std::set< LVWarningKind > LVWarningKindSet
Definition: LVOptions.h:180
std::set< LVReportKind > LVReportKindSet
Definition: LVOptions.h:171
std::vector< LVLineGetFunction > LVLineRequest
Definition: LVLine.h:37
std::set< LVSymbolKind > LVSymbolKindSet
Definition: LVSymbol.h:32
std::vector< LVScopeGetFunction > LVScopeRequest
Definition: LVScope.h:64
std::map< LVLineKind, LVLineGetFunction > LVLineDispatch
Definition: LVLine.h:36
std::set< LVInternalKind > LVInternalKindSet
Definition: LVOptions.h:190
std::set< LVAttributeKind > LVAttributeKindSet
Definition: LVOptions.h:131
std::map< LVSymbolKind, LVSymbolGetFunction > LVSymbolDispatch
Definition: LVSymbol.h:33
std::vector< LVElementGetFunction > LVElementRequest
Definition: LVElement.h:66
std::map< LVElementKind, LVElementGetFunction > LVElementDispatch
Definition: LVElement.h:65
LVOptions & options()
Definition: LVOptions.h:445
std::set< LVCompareKind > LVCompareKindSet
Definition: LVOptions.h:140
std::map< LVTypeKind, LVTypeGetFunction > LVTypeDispatch
Definition: LVType.h:47
std::vector< LVTypeGetFunction > LVTypeRequest
Definition: LVType.h:48
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
bool is_contained(R &&Range, const E &Element)
Wrapper function around std::find to detect if an element exists in a container.
Definition: STLExtras.h:1869
constexpr std::nullopt_t None
Definition: None.h:28