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 26 namespace llvm { 27 namespace 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 92 using LVOffsetSet = std::set<uint64_t>; 93 94 enum 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 }; 131 using LVAttributeKindSet = std::set<LVAttributeKind>; 132 133 enum class LVCompareKind { 134 All, // --compare=all 135 Lines, // --compare=lines 136 Scopes, // --compare=scopes 137 Symbols, // --compare=symbols 138 Types // --compare=types 139 }; 140 using LVCompareKindSet = std::set<LVCompareKind>; 141 142 enum class LVOutputKind { 143 All, // --output=all 144 Split, // --output=split 145 Json, // --output=json 146 Text // --output=text 147 }; 148 using LVOutputKindSet = std::set<LVOutputKind>; 149 150 enum 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 }; 162 using LVPrintKindSet = std::set<LVPrintKind>; 163 164 enum class LVReportKind { 165 All, // --report=all 166 Children, // --report=children 167 List, // --report=list 168 Parents, // --report=parents 169 View // --report=view 170 }; 171 using LVReportKindSet = std::set<LVReportKind>; 172 173 enum class LVWarningKind { 174 All, // --warning=all 175 Coverages, // --warning=coverages 176 Lines, // --warning=lines 177 Locations, // --warning=locations 178 Ranges // --warning=ranges 179 }; 180 using LVWarningKindSet = std::set<LVWarningKind>; 181 182 enum 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 }; 190 using 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. 197 class 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 287 public: 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(dbgs()); } 442 #endif 443 }; 444 445 inline LVOptions &options() { return (*LVOptions::getOptions()); } 446 inline void setOptions(LVOptions *Options) { LVOptions::setOptions(Options); } 447 448 class 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 548 public: 549 static LVPatterns *getPatterns(); 550 551 LVPatterns() { 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 577 void addRequest(LVElementKindSet &Selection) { 578 addRequest(Selection, ElementDispatch, ElementRequest); 579 } 580 void addRequest(LVLineKindSet &Selection) { 581 addRequest(Selection, LineDispatch, LineRequest); 582 } 583 void addRequest(LVScopeKindSet &Selection) { 584 addRequest(Selection, ScopeDispatch, ScopeRequest); 585 } 586 void addRequest(LVSymbolKindSet &Selection) { 587 addRequest(Selection, SymbolDispatch, SymbolRequest); 588 } 589 void addRequest(LVTypeKindSelection &Selection) { 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'). 597 bool matchGenericPattern(StringRef Input) { 598 return matchPattern(Input, GenericMatchInfo); 599 } 600 bool matchOffsetPattern(LVOffset Offset) { 601 return llvm::is_contained(OffsetMatchInfo, Offset); 602 } 603 604 void resolvePatternMatch(LVLine *Line) { 605 resolveGenericPatternMatch(Line, LineRequest); 606 } 607 608 void resolvePatternMatch(LVScope *Scope) { 609 resolveGenericPatternMatch(Scope, ScopeRequest); 610 } 611 612 void resolvePatternMatch(LVSymbol *Symbol) { 613 resolveGenericPatternMatch(Symbol, SymbolRequest); 614 } 615 616 void resolvePatternMatch(LVType *Type) { 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 640 inline LVPatterns &patterns() { return *LVPatterns::getPatterns(); } 641 642 } // namespace logicalview 643 } // namespace llvm 644 645 #endif // LLVM_DEBUGINFO_LOGICALVIEW_CORE_LVOPTIONS_H 646