[llvm-debuginfo-analyzer] 05 - Select elements

[CarlosAlbertoEnciso]

Summary

LLVM debug information visual analyzer

For more information, see the RFC https://discourse.llvm.org/t/llvm-dev-rfc-llvm-dva-debug-information-visual-analyzer/62570

Patches:
01 - Interval Tree
02 - Driver and Documentation
03 - Logical Elements
04 - Locations and Ranges
05 - Select Elements
06 - Warning and Internal Options
07 - Compare Elements
08 - ELF Reader
09 - CodeView Reader
10 - Smart Pointers

This is a high level summary of the changes in this patch.

Select elements

• Support for logical elements selection.

[psamolysov]

Good job! Here is a series of comments, please have a look if you don't mind.

llvm/include/llvm/DebugInfo/LogicalView/Core/LVElement.h

62

Could you add #include <map> and #include <vector> to make the header more self-contained?

llvm/include/llvm/DebugInfo/LogicalView/Core/LVOptions.h

19

Do you mean LVObject.h? Currently it looks like a self-inclusion.

452

The class should either be marked as final or has a virtual destructor.

470

Maybe it makes sense to rename the alias into LVMatchOffsets with s because the code already has LVOffset alias for just uint64_t and it could get the reader in doubt why an instance of LVMatchOffset is a heavy object.

490

What about to add an assert to check that Element is not null?

502

I see no modifications of Dispatch in the function.

503

515

What about to add an assert to check that Element is not null? Also it looks like the Element could have the const T * type.

531

What about to add an assert to check that Element is not null?

532

The lambda captures this and a pointer (Line) only, it makes sense to capture this by reference (implicitly) and Line by value: auto checkPattern = [=]() -> bool { (will this ought to be replaced with [=, this] when LLVM switches on C++ 20?)

537

The previous comment for checkPattern could be applied here too.

561

A typo? = delete should be?

597

Would const LVMatchInfo &MatchInfo work?

602

The LVObject.h header defines an alias LVOffset for uint64_t.

646

I believe this pair of brackets is not needed.

llvm/lib/DebugInfo/LogicalView/Core/LVOptions.cpp

447

Patterns has not been changed in the method.

448

509

llvm/unittests/DebugInfo/LogicalView/SelectElementsTest.cpp

53

An std::bad_alloc will be thrown if the test is out of memory. It makes sense to wrap the line in the try-catch block or use the non-throwing overload of the new operator.

92

It would be better to use EXPECT_EQ on the objects of Element->getName() and Name because the .data() member of StringRef doesn't guarantee that the returned char array will be null-terminated.

276–277

If I get it right, getIsMatched() returns a bool value. GTest's EXPECT_TRUE and EXPECT_FALSE can handle bool values better.

368

[CarlosAlbertoEnciso]

llvm/include/llvm/DebugInfo/LogicalView/Core/LVElement.h

62

Included <map> and <vector>.

llvm/include/llvm/DebugInfo/LogicalView/Core/LVOptions.h

19

Very good catch.
LVObject.h it is not needed as it is included by any of the logical elements.

452

Added final.

470

Renamed to LVMatchOffsets.

490

Added assert(Element && "Element must not be nullptr");

502

Added const.

503

Added const.

515

Added assert(Element && "Element must not be nullptr");

515

I can add the const qualifier, but as side effect a lot of functions needs to be modified as they are not expected a const. They are indirectly called by addElement(Element).

531

Added assert(Line && "Line must not be nullptr");

532

Thanks for the explanation.

Changed to auto CheckPattern = [=]() -> bool {

537

Changed to auto CheckOffset = [=]() -> bool {

561

Good catch. Changed to = delete.

597

Added const.

602

Changed.

646

Removed the wrapping brackets.

llvm/lib/DebugInfo/LogicalView/Core/LVOptions.cpp

447

Added const.

448

Replaced.

509

Added const.

llvm/unittests/DebugInfo/LogicalView/SelectElementsTest.cpp

53

Changed to use the non-throwing overload.

92

Changed to EXPECT_EQ(Element->getName(), Name);

276–277

Replaced with EXPECT_TRUE and EXPECT_FALSE.

368

Fix typo.

[CarlosAlbertoEnciso]

• Addressed the reviewer’s feedback.
• Tool renamed as: llvm-debuginfo-analyzer.

[CarlosAlbertoEnciso]

Ping.

[probinson]

llvm/include/llvm/DebugInfo/LogicalView/Core/LVOptions.h

555

No need to repeat public:

633

No need to repeat public:

llvm/include/llvm/DebugInfo/LogicalView/Core/LVSymbol.h

163

No need to repeat public:

llvm/unittests/DebugInfo/LogicalView/SelectElementsTest.cpp

55

Use ASSERT_NE to bail out of the test if the allocation fails.

[CarlosAlbertoEnciso]

Update patch due to changes in previous patches.

[CarlosAlbertoEnciso]

llvm/include/llvm/DebugInfo/LogicalView/Core/LVOptions.h

555

Removed public:.

633

Removed public:.

llvm/include/llvm/DebugInfo/LogicalView/Core/LVSymbol.h

163

Removed public:.

llvm/unittests/DebugInfo/LogicalView/SelectElementsTest.cpp

55

ASSERT_NE can be used only inside functions that don't return a value.

See https://google.github.io/googletest/advanced.html#assertion-placement

The one constraint is that assertions that generate a fatal failure (FAIL* and ASSERT_*) can only be used in void-returning functions.

[probinson]

Looks like the patch needs to be updated with the latest changes.

llvm/include/llvm/DebugInfo/LogicalView/Core/LVScope.h

278

No need to repeat public:

llvm/include/llvm/DebugInfo/LogicalView/Core/LVType.h

116

No need to repeat public:

[CarlosAlbertoEnciso]

Address points raised by @probinson.

[probinson]

LGTM, with just a few remaining nits about public:

llvm/include/llvm/DebugInfo/LogicalView/Core/LVLine.h

88

Repeated public:

llvm/include/llvm/DebugInfo/LogicalView/Core/LVReader.h

166

Here and above, more duplicate public:

[CarlosAlbertoEnciso]

llvm/include/llvm/DebugInfo/LogicalView/Core/LVLine.h

88

Removed the repeated public:.

llvm/include/llvm/DebugInfo/LogicalView/Core/LVReader.h

166

Removed the repeated public:.

[CarlosAlbertoEnciso]

Updated patch:

• Removes some redundant public: modifiers.

[CarlosAlbertoEnciso]

@psamolysov , @probinson Thanks very much for all your valuable reviews.

[CarlosAlbertoEnciso]

The following patch fixed some buildbot sanitizer issues: https://reviews.llvm.org/D136444

llvm/include/llvm/DebugInfo/LogicalView/Core/LVElement.h

enum class LVSubclassID : unsigned char {
   LV_TYPE_IMPORT,
   LV_TYPE_PARAM,
   LV_TYPE_SUBRANGE,
   LV_TYPE_LAST
 };
 
 enum class LVElementKind { Discarded, Global, Optimized, LastEntry };
 using LVElementKindSet = std::set<LVElementKind>;
+using LVElementDispatch = std::map<LVElementKind, LVElementGetFunction>;
+using LVElementRequest = std::vector<LVElementGetFunction>;
 
 class LVElement : public LVObject {
   enum class Property {
     IsLine,   // A logical line.
     IsScope,  // A logical scope.
     IsSymbol, // A logical symbol.
     IsType,   // A logical type.
     IsEnumClass,
enum class Property {
     IsReferencedType,
     IsSystem,
     OffsetFromTypeIndex,
     IsAnonymous,
     LastEntry
   };
   // Typed bitvector with properties for this element.
   LVProperties<Property> Properties;
+  static LVElementDispatch Dispatch;
 
   /// RTTI.
   const LVSubclassID SubclassID;
 
   // Indexes in the String Pool.
   size_t NameIndex = 0;
   size_t QualifiedNameIndex = 0;
   size_t FilenameIndex = 0;
public:
   // is executed in order to collect their additional information.
   // The following functions 'resolve' some of their properties, such as
   // name, references, parents, extra information based on the element kind.
   virtual void resolve();
   virtual void resolveExtra() {}
   virtual void resolveName();
   virtual void resolveReferences() {}
   void resolveParents();
+
+public:
+  static LVElementDispatch &getDispatch() { return Dispatch; }
 };
 
 } // end namespace logicalview
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_LOGICALVIEW_CORE_LVELEMENT_H

llvm/include/llvm/DebugInfo/LogicalView/Core/LVLine.h

enum class LVLineKind {
   IsLineAssembler,
   IsNewStatement, // Shared with CodeView 'IsStatement' flag.
   IsPrologueEnd,
   IsAlwaysStepInto, // CodeView
   IsNeverStepInto,  // CodeView
   LastEntry
 };
 using LVLineKindSet = std::set<LVLineKind>;
+using LVLineDispatch = std::map<LVLineKind, LVLineGetFunction>;
+using LVLineRequest = std::vector<LVLineGetFunction>;
 
 // Class to represent a logical line.
 class LVLine : public LVElement {
   // Typed bitvector with kinds for this line.
   LVProperties<LVLineKind> Kinds;
+  static LVLineDispatch Dispatch;
 
 public:
   LVLine() : LVElement(LVSubclassID::LV_LINE) {
     setIsLine();
     setIncludeInPrint();
   }
   LVLine(const LVLine &) = delete;
   LVLine &operator=(LVLine const &) = delete;
public:
 
   // Line number for display; in the case of Inlined Functions, we use the
   // DW_AT_call_line attribute; otherwise use DW_AT_decl_line attribute.
   std::string lineNumberAsString(bool ShowZero = false) const override {
     return lineAsString(getLineNumber(), getDiscriminator(), ShowZero);
   }
 
 public:
+  static LVLineDispatch &getDispatch() { return Dispatch; }
+
+public:
   virtual void print(raw_ostream &OS, bool Full = true) const override;
   virtual void printExtra(raw_ostream &OS, bool Full = true) const override{};
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   virtual void dump() const override { print(dbgs()); }
 #endif
 };
 

llvm/include/llvm/DebugInfo/LogicalView/Core/LVOptions.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_LOGICALVIEW_CORE_LVOPTIONS_H
 #define LLVM_DEBUGINFO_LOGICALVIEW_CORE_LVOPTIONS_H
 
 #include "llvm/ADT/StringSet.h"
 #include "llvm/DebugInfo/LogicalView/Core/LVLine.h"
 #include "llvm/DebugInfo/LogicalView/Core/LVOptions.h"
 #include "llvm/DebugInfo/LogicalView/Core/LVScope.h"
 #include "llvm/DebugInfo/LogicalView/Core/LVSymbol.h"
 #include "llvm/DebugInfo/LogicalView/Core/LVType.h"
+#include "llvm/Support/Regex.h"
 
 namespace llvm {
 namespace logicalview {
 
 // Generate get and set 'bool' functions.
 #define BOOL_FUNCTION(FAMILY, FIELD)                                           \
   bool get##FAMILY##FIELD() const { return FAMILY.FIELD; }                     \
   void set##FAMILY##FIELD() { FAMILY.FIELD = true; }                           \

 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   void dump() const { print(dbgs()); }
 #endif
 };
 
 inline LVOptions &options() { return (*LVOptions::getOptions()); }
 inline void setOptions(LVOptions *Options) { LVOptions::setOptions(Options); }
 
+class LVPatterns {
+  // Pattern Mode.
+  enum class LVMatchMode {
+    None = 0, // No given pattern.
+    Match,    // Perfect match.
+    NoCase,   // Ignore case.
+    Regex     // Regular expression.
+  };
+
+  // Keep the search pattern information.
+  struct LVMatch {
+    std::string Pattern;                  // Normal pattern.
+    std::shared_ptr<Regex> RE;            // Regular Expression Pattern.
+    LVMatchMode Mode = LVMatchMode::None; // Match mode.
+  };
+
+  using LVMatchInfo = std::vector<LVMatch>;
+  LVMatchInfo GenericMatchInfo;
+  using LVMatchOffset = std::vector<uint64_t>;
+  LVMatchOffset OffsetMatchInfo;
+
+  // Element selection.
+  LVElementDispatch ElementDispatch;
+  LVLineDispatch LineDispatch;
+  LVScopeDispatch ScopeDispatch;
+  LVSymbolDispatch SymbolDispatch;
+  LVTypeDispatch TypeDispatch;
+
+  // Element selection request.
+  LVElementRequest ElementRequest;
+  LVLineRequest LineRequest;
+  LVScopeRequest ScopeRequest;
+  LVSymbolRequest SymbolRequest;
+  LVTypeRequest TypeRequest;
+
+  // Check an element printing Request.
+  template <typename T, typename U>
+  bool checkElementRequest(const T *Element, const U &Requests) const {
+    for (const auto &Request : Requests)
+      if ((Element->*Request)())
+        return true;
+    // Check generic element requests.
+    for (const LVElementGetFunction &Request : ElementRequest)
+      if ((Element->*Request)())
+        return true;
+    return false;
+  }
+
+  // Add an element printing request based on its kind.
+  template <typename T, typename U, typename V>
+  void addRequest(const T &Selection, U &Dispatch, V &Request) const {
+    for (auto &Entry : Selection) {
+      // Find target function to fullfit request.
+      typename U::iterator Iter = Dispatch.find(Entry);
+      if (Iter != Dispatch.end())
+        Request.push_back(Iter->second);
+    }
+  }
+
+  void addElement(LVElement *Element);
+
+  template <typename T, typename U>
+  void resolveGenericPatternMatch(T *Element, const U &Requests) {
+    auto checkPattern = [&]() -> bool {
+      return Element->isNamed() &&
+             (matchGenericPattern(Element->getName()) ||
+              matchGenericPattern(Element->getTypeName()));
+    };
+    auto checkOffset = [&]() -> bool {
+      return matchOffsetPattern(Element->getOffset());
+    };
+    if ((options().getSelectGenericPattern() && checkPattern()) ||
+        (options().getSelectOffsetPattern() && checkOffset()) ||
+        ((Requests.size() || ElementRequest.size()) &&
+         checkElementRequest(Element, Requests)))
+      addElement(Element);
+  }
+
+  template <typename U>
+  void resolveGenericPatternMatch(LVLine *Line, const U &Requests) {
+    auto checkPattern = [&]() -> bool {
+      return matchGenericPattern(Line->lineNumberAsStringStripped()) ||
+             matchGenericPattern(Line->getName()) ||
+             matchGenericPattern(Line->getPathname());
+    };
+    auto checkOffset = [&]() -> bool {
+      return matchOffsetPattern(Line->getAddress());
+    };
+    if ((options().getSelectGenericPattern() && checkPattern()) ||
+        (options().getSelectOffsetPattern() && checkOffset()) ||
+        (Requests.size() && checkElementRequest(Line, Requests)))
+      addElement(Line);
+  }
+
+  Error createMatchEntry(LVMatchInfo &Filters, StringRef Pattern,
+                         bool IgnoreCase, bool UseRegex);
+
+public:
+  static LVPatterns *getPatterns();
+
+public:
+  LVPatterns() {
+    ElementDispatch = LVElement::getDispatch();
+    LineDispatch = LVLine::getDispatch();
+    ScopeDispatch = LVScope::getDispatch();
+    SymbolDispatch = LVSymbol::getDispatch();
+    TypeDispatch = LVType::getDispatch();
+  }
+  LVPatterns(const LVPatterns &) = delete;
+  LVPatterns &operator=(LVPatterns const &) = default;
+  ~LVPatterns() = default;
+
+  // Clear any existing patterns.
+  void clear() {
+    GenericMatchInfo.clear();
+    OffsetMatchInfo.clear();
+    ElementRequest.clear();
+    LineRequest.clear();
+    ScopeRequest.clear();
+    SymbolRequest.clear();
+    TypeRequest.clear();
+
+    options().resetSelectGenericKind();
+    options().resetSelectGenericPattern();
+    options().resetSelectOffsetPattern();
+  }
+
+  void addRequest(LVElementKindSet &Selection) {
+    addRequest(Selection, ElementDispatch, ElementRequest);
+  }
+  void addRequest(LVLineKindSet &Selection) {
+    addRequest(Selection, LineDispatch, LineRequest);
+  }
+  void addRequest(LVScopeKindSet &Selection) {
+    addRequest(Selection, ScopeDispatch, ScopeRequest);
+  }
+  void addRequest(LVSymbolKindSet &Selection) {
+    addRequest(Selection, SymbolDispatch, SymbolRequest);
+  }
+  void addRequest(LVTypeKindSelection &Selection) {
+    addRequest(Selection, TypeDispatch, TypeRequest);
+  }
+
+  void updateReportOptions();
+
+  bool matchPattern(StringRef Input, LVMatchInfo &MatchInfo);
+  // Match a pattern (--select='pattern').
+  bool matchGenericPattern(StringRef Input) {
+    return matchPattern(Input, GenericMatchInfo);
+  }
+  bool matchOffsetPattern(uint64_t Offset) {
+    return std::find(OffsetMatchInfo.begin(), OffsetMatchInfo.end(), Offset) !=
+           OffsetMatchInfo.end();
+  }
+
+  void resolvePatternMatch(LVLine *Line) {
+    resolveGenericPatternMatch(Line, LineRequest);
+  }
+
+  void resolvePatternMatch(LVScope *Scope) {
+    resolveGenericPatternMatch(Scope, ScopeRequest);
+  }
+
+  void resolvePatternMatch(LVSymbol *Symbol) {
+    resolveGenericPatternMatch(Symbol, SymbolRequest);
+  }
+
+  void resolvePatternMatch(LVType *Type) {
+    resolveGenericPatternMatch(Type, TypeRequest);
+  }
+
+  void addPatterns(StringSet<> &Patterns, LVMatchInfo &Filters);
+
+public:
+  // Add generic and offset patterns info.
+  void addGenericPatterns(StringSet<> &Patterns);
+  void addOffsetPatterns(LVOffsetSet &Patterns);
+
+public:
+  // Conditions to print an object.
+  bool printElement(const LVLine *Line) const;
+  bool printObject(const LVLocation *Location) const;
+  bool printElement(const LVScope *Scope) const;
+  bool printElement(const LVSymbol *Symbol) const;
+  bool printElement(const LVType *Type) const;
+
+public:
+  void print(raw_ostream &OS) const;
+
+#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+  void dump() const { print(dbgs()); }
+#endif
+};
+
+inline LVPatterns &patterns() { return (*LVPatterns::getPatterns()); }
+
 } // namespace logicalview
 } // namespace llvm
 
 #endif // LLVM_DEBUGINFO_LOGICALVIEW_CORE_LVOPTIONS_H

llvm/include/llvm/DebugInfo/LogicalView/Core/LVReader.h

virtual bool isSystemEntry(LVElement *Element, StringRef Name = {}) {
     return false;
   };
 
   // Access to split context.
   LVSplitContext &getSplitContext() { return SplitContext; }
 
 public:
   // Conditions to print an object.
-  bool doPrintLine(const LVLine *Line) const { return true; }
-  bool doPrintLocation(const LVLocation *Location) const { return true; }
-  bool doPrintScope(const LVScope *Scope) const { return true; }
-  bool doPrintSymbol(const LVSymbol *Symbol) const { return true; }
-  bool doPrintType(const LVType *Type) const { return true; }
+  bool doPrintLine(const LVLine *Line) const {
+    return patterns().printElement(Line);
+  }
+  bool doPrintLocation(const LVLocation *Location) const {
+    return patterns().printObject(Location);
+  }
+  bool doPrintScope(const LVScope *Scope) const {
+    return patterns().printElement(Scope);
+  }
+  bool doPrintSymbol(const LVSymbol *Symbol) const {
+    return patterns().printElement(Symbol);
+  }
+  bool doPrintType(const LVType *Type) const {
+    return patterns().printElement(Type);
+  }
 
 public:
   static LVReader &getInstance();
   static void setInstance(LVReader *Reader);
 
 public:
   void print(raw_ostream &OS) const;
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   void dump() const { print(dbgs()); }
 #endif
 };
 
 inline LVReader &getReader() { return LVReader::getInstance(); }

llvm/include/llvm/DebugInfo/LogicalView/Core/LVScope.h

enum class LVScopeKind {
   IsTemplate,
   IsTemplateAlias,
   IsTemplatePack,
   IsTryBlock,
   IsUnion,
   LastEntry
 };
 using LVScopeKindSet = std::set<LVScopeKind>;
+using LVScopeDispatch = std::map<LVScopeKind, LVScopeGetFunction>;
+using LVScopeRequest = std::vector<LVScopeGetFunction>;
 
 using LVOffsetElementMap = std::map<LVOffset, LVElement *>;
 
 // Class to represent a DWARF Scope.
 class LVScope : public LVElement {
   enum class Property {
     HasDiscriminator,
     CanHaveRanges,
enum class Property {
     HasRanges,
     AddedMissing, // Added missing referenced symbols.
     LastEntry
   };
 
   // Typed bitvector with kinds and properties for this scope.
   LVProperties<LVScopeKind> Kinds;
   LVProperties<Property> Properties;
+  static LVScopeDispatch Dispatch;
 
   // Coverage factor in units (bytes).
   unsigned CoverageFactor = 0;
 
   // Calculate coverage factor.
   void calculateCoverage() {
     float CoveragePercentage = 0;
     LVLocation::calculateCoverage(Ranges, CoverageFactor, CoveragePercentage);
public:
   void getQualifiedName(std::string &QualifiedName) const;
   // Encode the template arguments.
   void encodeTemplateArguments(std::string &Name) const;
   void encodeTemplateArguments(std::string &Name, const LVTypes *Types) const;
 
   void resolveElements();
 
 public:
+  static LVScopeDispatch &getDispatch() { return Dispatch; }
+
+public:
   virtual void print(raw_ostream &OS, bool Full = true) const override;
   virtual void printExtra(raw_ostream &OS, bool Full = true) const override;
   virtual void printMatchedElements(raw_ostream &OS, bool UseMatchedElements){};
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   virtual void dump() const override { print(dbgs()); }
 #endif
 };

 public:
   LVScopeCompileUnit() : LVScope(), Totals(TotalInitialSize, {0, 0.0}) {
     setIsCompileUnit();
   }
   LVScopeCompileUnit(const LVScopeCompileUnit &) = delete;
   LVScopeCompileUnit &operator=(LVScopeCompileUnit const &) = delete;
   ~LVScopeCompileUnit() = default;
 
+  LVScope *getCompileUnitParent() const override {
+    return static_cast<LVScope *>(const_cast<LVScopeCompileUnit *>(this));
+  }
+
   // Get the line located at the given address.
   LVLine *lineLowerBound(LVAddress Address) const;
   LVLine *lineUpperBound(LVAddress Address) const;
 
   StringRef getCompilationDirectory() const {
     return getStringPool().getString(CompilationDirectoryIndex);
   }
   void setCompilationDirectory(StringRef CompilationDirectory) {
public:
   void setProducer(StringRef ProducerName) override {
     ProducerIndex = getStringPool().getIndex(ProducerName);
   }
 
   // Process ranges, locations and calculate coverage.
   void processRangeLocationCoverage(
       LVValidLocation ValidLocation = &LVLocation::validateRanges);
 
+  // Add matched element.
+  void addMatched(LVElement *Element) { MatchedElements.push_back(Element); }
+  void addMatched(LVScope *Scope) { MatchedScopes.push_back(Scope); }
+  void propagatePatternMatch();
+
+  const LVElements &getMatchedElements() const { return MatchedElements; }
+  const LVScopes &getMatchedScopes() const { return MatchedScopes; }
+
   void printLocalNames(raw_ostream &OS, bool Full = true) const;
   void printSummary(raw_ostream &OS, const LVCounter &Counter,
                     const char *Header) const;
 
   void incrementPrintedLines();
   void incrementPrintedScopes();
   void incrementPrintedSymbols();
   void incrementPrintedTypes();

llvm/include/llvm/DebugInfo/LogicalView/Core/LVSymbol.h

enum class LVSymbolKind {
   IsInheritance,
   IsMember,
   IsParameter,
   IsUnspecified,
   IsVariable,
   LastEntry
 };
 using LVSymbolKindSet = std::set<LVSymbolKind>;
+using LVSymbolDispatch = std::map<LVSymbolKind, LVSymbolGetFunction>;
+using LVSymbolRequest = std::vector<LVSymbolGetFunction>;
 
 class LVSymbol final : public LVElement {
   enum class Property { HasLocation, FillGaps, LastEntry };
 
   // Typed bitvector with kinds and properties for this symbol.
   LVProperties<LVSymbolKind> Kinds;
   LVProperties<Property> Properties;
+  static LVSymbolDispatch Dispatch;
 
   // CodeView symbol Linkage name.
   size_t LinkageNameIndex = 0;
 
   // Reference to DW_AT_specification, DW_AT_abstract_origin attribute.
   LVSymbol *Reference = nullptr;
   LVAutoLocations *Locations = nullptr;
   LVLocation *CurrentLocation = nullptr;
public:
   // Follow a chain of references given by DW_AT_abstract_origin and/or
   // DW_AT_specification and update the symbol name.
   StringRef resolveReferencesChain();
 
   void resolveName() override;
   void resolveReferences() override;
 
 public:
+  static LVSymbolDispatch &getDispatch() { return Dispatch; }
+
+public:
   void print(raw_ostream &OS, bool Full = true) const override;
   void printExtra(raw_ostream &OS, bool Full = true) const override;
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   void dump() const override { print(dbgs()); }
 #endif
 };
 
 } // end namespace logicalview
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_LOGICALVIEW_CORE_LVSYMBOL_H

llvm/include/llvm/DebugInfo/LogicalView/Core/LVType.h

enum class LVTypeKind {
   IsTypedef,
   IsUnaligned,
   IsUnspecified,
   IsVolatile,
   IsModifier, // CodeView - LF_MODIFIER
   LastEntry
 };
 using LVTypeKindSelection = std::set<LVTypeKind>;
+using LVTypeDispatch = std::map<LVTypeKind, LVTypeGetFunction>;
+using LVTypeRequest = std::vector<LVTypeGetFunction>;
 
 // Class to represent a DWARF Type.
 class LVType : public LVElement {
   enum class Property { IsSubrangeCount, LastEntry };
 
   // Typed bitvector with kinds and properties for this type.
   LVProperties<LVTypeKind> Kinds;
   LVProperties<Property> Properties;
+  static LVTypeDispatch Dispatch;
 
 public:
   LVType() : LVElement(LVSubclassID::LV_TYPE) { setIsType(); }
   LVType(const LVType &) = delete;
   LVType &operator=(LVType const &) = delete;
   virtual ~LVType() = default;
 
   static bool classof(const LVElement *Element) {
public:
   // Return the underlying type for a type definition.
   virtual LVElement *getUnderlyingType() { return nullptr; }
   virtual void setUnderlyingType(LVElement *Element) {}
 
   void resolveName() override;
   void resolveReferences() override;
 
 public:
+  static LVTypeDispatch &getDispatch() { return Dispatch; }
+
+public:
   virtual void print(raw_ostream &OS, bool Full = true) const override;
   virtual void printExtra(raw_ostream &OS, bool Full = true) const override;
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   virtual void dump() const override { print(dbgs()); }
 #endif
 };
 

llvm/lib/DebugInfo/LogicalView/Core/LVElement.cpp

 #include "llvm/DebugInfo/LogicalView/Core/LVSymbol.h"
 #include "llvm/DebugInfo/LogicalView/Core/LVType.h"
 
 using namespace llvm;
 using namespace llvm::logicalview;
 
 #define DEBUG_TYPE "Element"
 
+LVElementDispatch LVElement::Dispatch = {
+    {LVElementKind::Discarded, &LVElement::getIsDiscarded},
+    {LVElementKind::Global, &LVElement::getIsGlobalReference},
+    {LVElementKind::Optimized, &LVElement::getIsOptimized}};
+
 LVType *LVElement::getTypeAsType() const {
   return ElementType && ElementType->getIsType()
              ? static_cast<LVType *>(ElementType)
              : nullptr;
 }
 
 LVScope *LVElement::getTypeAsScope() const {
   return ElementType && ElementType->getIsScope()

llvm/lib/DebugInfo/LogicalView/Core/LVLine.cpp

const char *LVLine::kind() const {
   static const char *Kind = KindUndefined;
   if (getIsLineDebug())
     Kind = KindLineDebug;
   else if (getIsLineAssembler())
     Kind = KindLineSource;
   return Kind;
 }
 
+LVLineDispatch LVLine::Dispatch = {
+    {LVLineKind::IsBasicBlock, &LVLine::getIsBasicBlock},
+    {LVLineKind::IsDiscriminator, &LVLine::getIsDiscriminator},
+    {LVLineKind::IsEndSequence, &LVLine::getIsEndSequence},
+    {LVLineKind::IsLineDebug, &LVLine::getIsLineDebug},
+    {LVLineKind::IsLineAssembler, &LVLine::getIsLineAssembler},
+    {LVLineKind::IsNewStatement, &LVLine::getIsNewStatement},
+    {LVLineKind::IsEpilogueBegin, &LVLine::getIsEpilogueBegin},
+    {LVLineKind::IsPrologueEnd, &LVLine::getIsPrologueEnd},
+    {LVLineKind::IsAlwaysStepInto, &LVLine::getIsAlwaysStepInto},
+    {LVLineKind::IsNeverStepInto, &LVLine::getIsNeverStepInto}};
+
 // String used as padding for printing elements with no line number.
 std::string LVLine::noLineAsString(bool ShowZero) const {
   return (ShowZero || options().getAttributeZero()) ? ("    0   ")
                                                     : ("    -   ");
 }
 
 void LVLine::print(raw_ostream &OS, bool Full) const {
   if (getReader().doPrintLine(this)) {

llvm/lib/DebugInfo/LogicalView/Core/LVOptions.cpp

 //===-- LVOptions.cpp -----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This implements the LVOptions class.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/LogicalView/Core/LVOptions.h"
+#include "llvm/DebugInfo/LogicalView/Core/LVReader.h"
+#include "llvm/Support/Errc.h"
 
 using namespace llvm;
 using namespace llvm::logicalview;
 
 #define DEBUG_TYPE "Options"
 
 //===----------------------------------------------------------------------===//
 // Options extracted from the command line.
OS << "** Internal **\n"
      << "All:       " << Options.getInternalAll() << ", "
      << "Cmdline:   " << Options.getInternalCmdline() << ", "
      << "ID:        " << Options.getInternalID() << ", "
      << "Integrity: " << Options.getInternalIntegrity() << ", "
      << "None:      " << Options.getInternalNone() << "\n"
      << "Tag:       " << Options.getInternalTag() << "\n"
      << "\n";
 }
+
+//===----------------------------------------------------------------------===//
+// Logical element selection using patterns.
+//===----------------------------------------------------------------------===//
+LVPatterns *LVPatterns::getPatterns() {
+  static LVPatterns Patterns;
+  return &Patterns;
+}
+
+Error LVPatterns::createMatchEntry(LVMatchInfo &Filters, StringRef Pattern,
+                                   bool IgnoreCase, bool UseRegex) {
+  LVMatch Match;
+  // Process pattern as regular expression.
+  if (UseRegex) {
+    Match.Pattern = std::string(Pattern);
+    if (Pattern.size()) {
+      Match.RE = std::make_shared<Regex>(Pattern, IgnoreCase ? Regex::IgnoreCase
+                                                             : Regex::NoFlags);
+      std::string Error;
+      if (!Match.RE->isValid(Error))
+        return createStringError(errc::invalid_argument,
+                                 "Error in regular expression: %s",
+                                 Error.c_str());
+
+      Match.Mode = LVMatchMode::Regex;
+      Filters.push_back(Match);
+      return Error::success();
+    }
+  }
+
+  // Process pattern as an exact string match, depending on the case.
+  Match.Pattern = std::string(Pattern);
+  if (Match.Pattern.size()) {
+    Match.Mode = IgnoreCase ? LVMatchMode::NoCase : LVMatchMode::Match;
+    Filters.push_back(Match);
+  }
+
+  return Error::success();
+}
+
+void LVPatterns::addGenericPatterns(StringSet<> &Patterns) {
+  addPatterns(Patterns, GenericMatchInfo);
+  if (GenericMatchInfo.size()) {
+    options().setSelectGenericPattern();
+    options().setSelectExecute();
+  }
+}
+
+void LVPatterns::addOffsetPatterns(LVOffsetSet &Patterns) {
+  for (const uint64_t &Entry : Patterns)
+    OffsetMatchInfo.push_back(Entry);
+  if (OffsetMatchInfo.size()) {
+    options().setSelectOffsetPattern();
+    options().setSelectExecute();
+  }
+}
+
+void LVPatterns::addPatterns(StringSet<> &Patterns, LVMatchInfo &Filters) {
+  bool IgnoreCase = options().getSelectIgnoreCase();
+  bool UseRegex = options().getSelectUseRegex();
+  for (const StringSet<>::value_type &Entry : Patterns) {
+    StringRef Pattern = Entry.first();
+    if (Error Err = createMatchEntry(Filters, Pattern, IgnoreCase, UseRegex))
+      consumeError(std::move(Err));
+  }
+
+  LLVM_DEBUG({
+    dbgs() << "\nPattern Information:\n";
+    for (LVMatch &Match : Filters)
+      dbgs() << "Mode: "
+             << (Match.Mode == LVMatchMode::Match ? "Match" : "Regex")
+             << " Pattern: '" << Match.Pattern << "'\n";
+  });
+}
+
+void LVPatterns::addElement(LVElement *Element) {
+  // Mark any element that matches a given pattern.
+  Element->setIsMatched();
+  options().setSelectExecute();
+  if (options().getReportList())
+    getReaderCompileUnit()->addMatched(Element);
+  if (options().getReportAnyView()) {
+    getReaderCompileUnit()->addMatched(Element->getIsScope()
+                                           ? static_cast<LVScope *>(Element)
+                                           : Element->getParentScope());
+    // Mark element as matched.
+    if (!Element->getIsScope())
+      Element->setHasPattern();
+  }
+}
+
+void LVPatterns::updateReportOptions() {
+  if (ElementRequest.size() || LineRequest.size() || ScopeRequest.size() ||
+      SymbolRequest.size() || TypeRequest.size()) {
+    options().setSelectGenericKind();
+    options().setSelectExecute();
+  }
+
+  // If we have selected requests and there are no specified report options,
+  // assume the 'details' option.
+  if (options().getSelectExecute() && !options().getReportExecute()) {
+    options().setReportExecute();
+    options().setReportList();
+  }
+}
+
+// Match a general pattern.
+bool LVPatterns::matchPattern(StringRef Input, LVMatchInfo &MatchInfo) {
+  bool Matched = false;
+  // Traverse all match specifications.
+  for (LVMatch &Match : MatchInfo) {
+    switch (Match.Mode) {
+    case LVMatchMode::Match:
+      Matched = Input.equals(Match.Pattern);
+      break;
+    case LVMatchMode::NoCase:
+      Matched = Input.equals_insensitive(Match.Pattern);
+      break;
+    case LVMatchMode::Regex:
+      Matched = Match.RE->match(Input);
+      break;
+    default:
+      break;
+    }
+    // Return if we have a match.
+    if (Matched)
+      return true;
+  }
+  return Matched;
+}
+
+bool LVPatterns::printElement(const LVLine *Line) const {
+  return (options().getPrintLines() && Line->getIsLineDebug()) ||
+         (options().getPrintInstructions() && Line->getIsLineAssembler());
+}
+
+bool LVPatterns::printObject(const LVLocation *Location) const {
+  if (options().getAttributeAll())
+    return true;
+  bool DoPrint = options().getAttributeAnyLocation();
+  // Consider the case of filler locations.
+  if (DoPrint && Location && Location->getIsGapEntry())
+    DoPrint = options().getAttributeGaps();
+  return DoPrint;
+}
+
+bool LVPatterns::printElement(const LVScope *Scope) const {
+  // A scope will be printed depending on the following rules:
+  // - Request to print scopes.
+  // - Request to print any of its children.
+  // - If the scope is Root or CompileUnit:
+  //     Request to print summary, sizes or warnings.
+  return options().getPrintScopes() ||
+         (options().getPrintSymbols() && Scope->getHasSymbols()) ||
+         (options().getPrintAnyLine() && Scope->getHasLines()) ||
+         (options().getPrintTypes() && Scope->getHasTypes()) ||
+         ((options().getPrintSizesSummary() || options().getPrintWarnings()) &&
+          (Scope->getIsRoot() || Scope->getIsCompileUnit()));
+}
+
+bool LVPatterns::printElement(const LVSymbol *Symbol) const {
+  // Print compiler generated symbols only if command line option.
+  if (Symbol->getIsArtificial())
+    return options().getAttributeGenerated() && options().getPrintSymbols();
+  return options().getPrintSymbols();
+}
+
+bool LVPatterns::printElement(const LVType *Type) const {
+  // Print array subranges only if print types is requested.
+  if (Type->getIsSubrange())
+    return options().getAttributeSubrange() && options().getPrintTypes();
+  return options().getPrintTypes();
+}
+
+void LVPatterns::print(raw_ostream &OS) const {
+  OS << "LVPatterns\n";
+  LLVM_DEBUG(dbgs() << "Print Patterns\n");
+}

llvm/lib/DebugInfo/LogicalView/Core/LVReader.cpp

 //   * Detect invalid ranges and locations.
 //   * "resolve" the logical elements. During this pass, the names and
 //      file information are updated, to reflect any dependency with other
 //     logical elements.
 Error LVReader::doLoad() {
   // Set current Reader instance.
   setInstance(this);
 
+  // Before any scopes creation, process any pattern specified by the
+  // --select and --select-offsets options.
+  patterns().addGenericPatterns(options().Select.Generic);
+  patterns().addOffsetPatterns(options().Select.Offsets);
+
+  // Add any specific element printing requests based on the element kind.
+  patterns().addRequest(options().Select.Elements);
+  patterns().addRequest(options().Select.Lines);
+  patterns().addRequest(options().Select.Scopes);
+  patterns().addRequest(options().Select.Symbols);
+  patterns().addRequest(options().Select.Types);
+
+  // Once we have processed the requests for any particular kind of elements,
+  // we need to update the report options, in order to have a default value.
+  patterns().updateReportOptions();
+
   // Delegate the scope tree creation to the specific reader.
   if (Error Err = createScopes())
     return Err;
 
   // Calculate symbol coverage and detect invalid debug locations and ranges.
   Root->processRangeInformation();
 
   // As the elements can depend on elements from a different compile unit,
   // information such as name and file/line source information needs to be
   // updated.
   Root->resolveElements();
 
   sortScopes();
   return Error::success();
 }
 
 // Default handler for a generic reader.
 Error LVReader::doPrint() {
   // Set current Reader instance.
   setInstance(this);
 
+  // Check for any '--report' request.
+  if (options().getReportExecute()) {
+    // Requested details.
+    if (options().getReportList())
+      if (Error Err = printMatchedElements(/*UseMatchedElements=*/true))
+        return Err;
+    // Requested only children.
+    if (options().getReportChildren() && !options().getReportParents())
+      if (Error Err = printMatchedElements(/*UseMatchedElements=*/false))
+        return Err;
+    // Requested (parents) or (parents and children).
+    if (options().getReportParents() || options().getReportView())
+      if (Error Err = printScopes())
+        return Err;
+
+    return Error::success();
+  }
+
   return printScopes();
 }
 
 Error LVReader::printScopes() {
   if (bool DoPrint = options().getPrintExecute()) {
     if (Error Err = createSplitFolder())
       return Err;
 
     // Start printing from the root.
-    bool DoMatch = false;
+    bool DoMatch = options().getSelectGenericPattern() ||
+                   options().getSelectGenericKind() ||
+                   options().getSelectOffsetPattern();
     return Root->doPrint(OutputSplit, DoMatch, DoPrint, OS);
   }
 
   return Error::success();
 }
 
 Error LVReader::printMatchedElements(bool UseMatchedElements) {
   if (Error Err = createSplitFolder())

llvm/lib/DebugInfo/LogicalView/Core/LVScope.cpp

else if (getIsFunction())
     Kind = KindFunction;
   else if (getIsStructure())
     Kind = KindStruct;
   else if (getIsUnion())
     Kind = KindUnion;
   return Kind;
 }
 
+LVScopeDispatch LVScope::Dispatch = {
+    {LVScopeKind::IsAggregate, &LVScope::getIsAggregate},
+    {LVScopeKind::IsArray, &LVScope::getIsArray},
+    {LVScopeKind::IsBlock, &LVScope::getIsBlock},
+    {LVScopeKind::IsCallSite, &LVScope::getIsCallSite},
+    {LVScopeKind::IsCatchBlock, &LVScope::getIsCatchBlock},
+    {LVScopeKind::IsClass, &LVScope::getIsClass},
+    {LVScopeKind::IsCompileUnit, &LVScope::getIsCompileUnit},
+    {LVScopeKind::IsEntryPoint, &LVScope::getIsEntryPoint},
+    {LVScopeKind::IsEnumeration, &LVScope::getIsEnumeration},
+    {LVScopeKind::IsFunction, &LVScope::getIsFunction},
+    {LVScopeKind::IsFunctionType, &LVScope::getIsFunctionType},
+    {LVScopeKind::IsInlinedFunction, &LVScope::getIsInlinedFunction},
+    {LVScopeKind::IsLabel, &LVScope::getIsLabel},
+    {LVScopeKind::IsLexicalBlock, &LVScope::getIsLexicalBlock},
+    {LVScopeKind::IsNamespace, &LVScope::getIsNamespace},
+    {LVScopeKind::IsRoot, &LVScope::getIsRoot},
+    {LVScopeKind::IsStructure, &LVScope::getIsStructure},
+    {LVScopeKind::IsTemplate, &LVScope::getIsTemplate},
+    {LVScopeKind::IsTemplateAlias, &LVScope::getIsTemplateAlias},
+    {LVScopeKind::IsTemplatePack, &LVScope::getIsTemplatePack},
+    {LVScopeKind::IsTryBlock, &LVScope::getIsTryBlock},
+    {LVScopeKind::IsUnion, &LVScope::getIsUnion}};
+
 void LVScope::addToChildren(LVElement *Element) {
   if (!Children)
     Children = new LVElements();
   Children->push_back(Element);
 }
 
 void LVScope::addElement(LVElement *Element) {
   assert(Element && "Invalid element.");
void LVScope::resolveName() {
   if (!isNamed()) {
     if (getIsArtificial())
       setName(getLinkageName());
     else
       generateName();
   }
 
   LVElement::resolveName();
+
+  // Resolve any given pattern.
+  patterns().resolvePatternMatch(this);
 }
 
 void LVScope::resolveReferences() {
   // The scopes can have the following references to other elements:
   //   A type:
   //     DW_AT_type             ->  Type or Scope
   //     DW_AT_import           ->  Type
   //   A Reference:
void LVScope::resolveElements() {
   // The current element represents the Root. Traverse each Compile Unit.
   if (!Scopes)
     return;
 
   for (LVScope *Scope : *Scopes) {
     LVScopeCompileUnit *CompileUnit = static_cast<LVScopeCompileUnit *>(Scope);
     getReader().setCompileUnit(CompileUnit);
     CompileUnit->resolve();
+    // Propagate any matching information into the scopes tree.
+    CompileUnit->propagatePatternMatch();
   }
 }
 
 StringRef LVScope::resolveReferencesChain() {
   // If the scope have a DW_AT_specification or DW_AT_abstract_origin,
   // follow the chain to resolve the name from those references.
   if (getHasReference() && !isNamed())
     setName(getReference()->resolveReferencesChain());
for (const LVType *Type : *Types) {
       AddComma = true;
     }
   }
 
   Name.append(">");
 }
 
 bool LVScope::resolvePrinting() const {
+  // In selection mode, always print the root scope regardless of the
+  // number of matched elements. If no matches, the root by itself will
+  // indicate no matches.
+  if (options().getSelectExecute()) {
+    return getIsRoot() || getIsCompileUnit() || getHasPattern();
+  }
+
   bool Globals = options().getAttributeGlobal();
   bool Locals = options().getAttributeLocal();
   if ((Globals && Locals) || (!Globals && !Locals)) {
     // Print both Global and Local.
   } else {
     // Check for Global or Local Objects.
     if ((Globals && !(getHasGlobals() || getIsGlobalReference())) ||
         (Locals && !(getHasLocals() || !getIsGlobalReference())))
void LVScope::printEncodedArgs(raw_ostream &OS, bool Full) const {
   if (options().getPrintFormatting() && options().getAttributeEncoded())
     printAttributes(OS, Full, "{Encoded} ", const_cast<LVScope *>(this),
                     getEncodedArgs(), /*UseQuotes=*/false, /*PrintRef=*/false);
 }
 
 void LVScope::print(raw_ostream &OS, bool Full) const {
   if (getIncludeInPrint() && getReader().doPrintScope(this)) {
     // For a summary (printed elements), do not count the scope root.
-    if (!(getIsRoot()))
+    // For a summary (selected elements) do not count a compile unit.
+    if (!(getIsRoot() || (getIsCompileUnit() && options().getSelectExecute())))
       getReaderCompileUnit()->incrementPrintedScopes();
     LVElement::print(OS, Full);
     printExtra(OS, Full);
   }
 }
 
 void LVScope::printExtra(raw_ostream &OS, bool Full) const {
   OS << formattedKind(kind());
void LVScopeCompileUnit::addSize(LVScope *Scope, LVOffset Lower,
   // debug information in sequential order.
   LVOffset Size = Upper - Lower;
   Sizes[Scope] = Size;
   if (this == Scope)
     // Record contribution size for the compilation unit.
     CUContributionSize = Size;
 }
 
+// Update parents and children with pattern information.
+void LVScopeCompileUnit::propagatePatternMatch() {
+  // At this stage, we have finished creating the Scopes tree and we have
+  // a list of elements that match the pattern specified in the command line.
+  // The pattern corresponds to a scope or element; mark parents and/or
+  // children as having that pattern, before any printing is done.
+  if (!options().getSelectExecute())
+    return;
+
+  if (MatchedScopes.size()) {
+    for (LVScope *Scope : MatchedScopes)
+      Scope->traverseParentsAndChildren(&LVScope::getHasPattern,
+                                        &LVScope::setHasPattern);
+  } else {
+    // Mark the compile unit as having a pattern to enable any requests to
+    // print sizes and summary as that information is recorded at that level.
+    setHasPattern();
+  }
+}
+
 void LVScopeCompileUnit::processRangeLocationCoverage(
     LVValidLocation ValidLocation) {
 
   if (options().getAttributeRange()) {
     // Traverse the scopes to get scopes that have invalid ranges.
     LVLocations Locations;
     bool RecordInvalid = false;
     getRanges(Locations, ValidLocation, RecordInvalid);

 }
 
 StringRef LVScopeCompileUnit::getFilename(size_t Index) const {
   if (Index <= 0 || Index > Filenames.size())
     return StringRef();
   return getStringPool().getString(Filenames[Index - 1]);
 }
 
-void LVScopeCompileUnit::incrementPrintedLines() { ++Printed.Lines; }
-void LVScopeCompileUnit::incrementPrintedScopes() { ++Printed.Scopes; }
-void LVScopeCompileUnit::incrementPrintedSymbols() { ++Printed.Symbols; }
-void LVScopeCompileUnit::incrementPrintedTypes() { ++Printed.Types; }
+void LVScopeCompileUnit::incrementPrintedLines() {
+  options().getSelectExecute() ? ++Found.Lines : ++Printed.Lines;
+}
+void LVScopeCompileUnit::incrementPrintedScopes() {
+  options().getSelectExecute() ? ++Found.Scopes : ++Printed.Scopes;
+}
+void LVScopeCompileUnit::incrementPrintedSymbols() {
+  options().getSelectExecute() ? ++Found.Symbols : ++Printed.Symbols;
+}
+void LVScopeCompileUnit::incrementPrintedTypes() {
+  options().getSelectExecute() ? ++Found.Types : ++Printed.Types;
+}
 
 // Values are used by '--summary' option (allocated).
 void LVScopeCompileUnit::increment(LVLine *Line) {
   if (Line->getIncludeInPrint())
     ++Allocated.Lines;
 }
 void LVScopeCompileUnit::increment(LVScope *Scope) {
   if (Scope->getIncludeInPrint())
if (Iter != Sizes.end()) {
     Totals[Level].first += Size;
     Totals[Level].second += Percentage;
   }
 }
 
 void LVScopeCompileUnit::printSizes(raw_ostream &OS) const {
   // Recursively print the contributions for each scope.
   std::function<void(LVScope * Scope)> printScope = [&](LVScope *Scope) {
+    // If we have selection criteria, then use only the selected scopes.
+    if (options().getSelectExecute() && options().getReportAnyView()) {
+      for (LVScope *Scope : MatchedScopes)
+        if (Scope->getLevel() < options().getOutputLevel())
+          printScopeSize(Scope, OS);
+      return;
+    }
     if (Scope->getLevel() < options().getOutputLevel()) {
       if (const LVScopes *Scopes = Scope->getScopes())
         for (LVScope *Scope : *Scopes) {
           printScopeSize(Scope, OS);
           printScope(Scope);
         }
     }
   };
void LVScopeCompileUnit::printSizes(raw_ostream &OS) const {
   options().resetPrintOffset();
   options().setPrintFormatting();
 
   if (!PrintScopes)
     options().resetPrintScopes();
 }
 
 void LVScopeCompileUnit::printSummary(raw_ostream &OS) const {
-  printSummary(OS, Printed, "Printed");
+  printSummary(OS, options().getSelectExecute() ? Found : Printed, "Printed");
 }
 
 // Print summary details for the scopes tree.
 void LVScopeCompileUnit::printSummary(raw_ostream &OS, const LVCounter &Counter,
                                       const char *Header) const {
   std::string Separator = std::string(29, '-');
   auto printSeparator = [&]() { OS << Separator << "\n"; };
   auto printHeadingRow = [&](const char *T, const char *U, const char *V) {

llvm/lib/DebugInfo/LogicalView/Core/LVSymbol.cpp

else if (getIsParameter())
     Kind = KindParameter;
   else if (getIsUnspecified())
     Kind = KindUnspecified;
   else if (getIsVariable())
     Kind = KindVariable;
   return Kind;
 }
 
+LVSymbolDispatch LVSymbol::Dispatch = {
+    {LVSymbolKind::IsCallSiteParameter, &LVSymbol::getIsCallSiteParameter},
+    {LVSymbolKind::IsConstant, &LVSymbol::getIsConstant},
+    {LVSymbolKind::IsInheritance, &LVSymbol::getIsInheritance},
+    {LVSymbolKind::IsMember, &LVSymbol::getIsMember},
+    {LVSymbolKind::IsParameter, &LVSymbol::getIsParameter},
+    {LVSymbolKind::IsUnspecified, &LVSymbol::getIsUnspecified},
+    {LVSymbolKind::IsVariable, &LVSymbol::getIsVariable}};
+
 // Add a Location Entry.
 void LVSymbol::addLocation(dwarf::Attribute Attr, LVAddress LowPC,
                            LVAddress HighPC, LVUnsigned SectionOffset,
                            uint64_t LocDescOffset, bool CallSiteLocation) {
   if (!Locations)
     Locations = new LVAutoLocations();
 
   // Create the location entry.

 }
 
 void LVSymbol::resolveName() {
   if (getIsResolvedName())
     return;
   setIsResolvedName();
 
   LVElement::resolveName();
+
+  // Resolve any given pattern.
+  patterns().resolvePatternMatch(this);
 }
 
 void LVSymbol::resolveReferences() {
   // The symbols can have the following references to other elements:
   //   A Type:
   //     DW_AT_type             ->  Type or Scope
   //     DW_AT_import           ->  Type
   //   A Reference:

llvm/lib/DebugInfo/LogicalView/Core/LVType.cpp

else if (getIsUnaligned())
     Kind = KindUnaligned;
   else if (getIsUnspecified())
     Kind = KindUnspecified;
   else if (getIsVolatile())
     Kind = KindVolatile;
   return Kind;
 }
 
+LVTypeDispatch LVType::Dispatch = {
+    {LVTypeKind::IsBase, &LVType::getIsBase},
+    {LVTypeKind::IsConst, &LVType::getIsConst},
+    {LVTypeKind::IsEnumerator, &LVType::getIsEnumerator},
+    {LVTypeKind::IsImport, &LVType::getIsImport},
+    {LVTypeKind::IsImportDeclaration, &LVType::getIsImportDeclaration},
+    {LVTypeKind::IsImportModule, &LVType::getIsImportModule},
+    {LVTypeKind::IsPointer, &LVType::getIsPointer},
+    {LVTypeKind::IsPointerMember, &LVType::getIsPointerMember},
+    {LVTypeKind::IsReference, &LVType::getIsReference},
+    {LVTypeKind::IsRestrict, &LVType::getIsRestrict},
+    {LVTypeKind::IsRvalueReference, &LVType::getIsRvalueReference},
+    {LVTypeKind::IsSubrange, &LVType::getIsSubrange},
+    {LVTypeKind::IsTemplateParam, &LVType::getIsTemplateParam},
+    {LVTypeKind::IsTemplateTemplateParam, &LVType::getIsTemplateTemplateParam},
+    {LVTypeKind::IsTemplateTypeParam, &LVType::getIsTemplateTypeParam},
+    {LVTypeKind::IsTemplateValueParam, &LVType::getIsTemplateValueParam},
+    {LVTypeKind::IsTypedef, &LVType::getIsTypedef},
+    {LVTypeKind::IsUnaligned, &LVType::getIsUnaligned},
+    {LVTypeKind::IsUnspecified, &LVType::getIsUnspecified},
+    {LVTypeKind::IsVolatile, &LVType::getIsVolatile}};
+
 void LVType::resolveReferences() {
   // Some DWARF tags are the representation of types. However, we associate
   // some of them to scopes. The ones associated with types, do not have
   // any reference tags, such as DW_AT_specification, DW_AT_abstract_origin,
   // DW_AT_extension.
 
   // Set the file/line information using the Debug Information entry.
   setFile(/*Reference=*/nullptr);
void LVType::resolveName() {
   resolveFullname(BaseType, getName());
 
   // In the case of unnamed types, try to generate a name for it, using
   // the parents name and the line information. Ignore the template
   if (!isNamed() && !getIsTemplateParam())
     generateName();
 
   LVElement::resolveName();
+
+  // Resolve any given pattern.
+  patterns().resolvePatternMatch(this);
 }
 
 StringRef LVType::resolveReferencesChain() {
   // The types do not have a DW_AT_specification or DW_AT_abstract_origin
   // reference. Just return the type name.
   return getName();
 }
 

llvm/unittests/DebugInfo/LogicalView/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   DebugInfoLogicalView
   )
 
 add_llvm_unittest(DebugInfoLogicalViewTests
   CommandLineOptionsTest.cpp
+  SelectElementsTest.cpp
   LocationRangesTest.cpp
   LogicalElementsTest.cpp
   StringPoolTest.cpp
   )
 
 target_link_libraries(DebugInfoLogicalViewTests PRIVATE LLVMTestingSupport)

llvm/unittests/DebugInfo/LogicalView/SelectElementsTest.cpp

+//===- llvm/unittest/DebugInfo/LogicalView/SelectElementsTest.cpp ---------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/DebugInfo/LogicalView/Core/LVLine.h"
+#include "llvm/DebugInfo/LogicalView/Core/LVReader.h"
+#include "llvm/DebugInfo/LogicalView/Core/LVScope.h"
+#include "llvm/DebugInfo/LogicalView/Core/LVSymbol.h"
+#include "llvm/DebugInfo/LogicalView/Core/LVType.h"
+#include "llvm/Support/ScopedPrinter.h"
+#include "llvm/Support/ToolOutputFile.h"
+#include "llvm/Testing/Support/Error.h"
+
+#include "gtest/gtest.h"
+
+using namespace llvm;
+using namespace llvm::logicalview;
+
+namespace {
+
+class ReaderTestSelection : public LVReader {
+  // Types.
+  LVType *IntegerType = nullptr;
+
+  // Scopes.
+  LVScope *NestedScope = nullptr;
+  LVScopeAggregate *Aggregate = nullptr;
+  LVScopeFunction *Function = nullptr;
+  LVScopeNamespace *Namespace = nullptr;
+
+  // Symbols.
+  LVSymbol *ClassMember = nullptr;
+  LVSymbol *LocalVariable = nullptr;
+  LVSymbol *NestedVariable = nullptr;
+  LVSymbol *Parameter = nullptr;
+
+  // Lines.
+  LVLine *LineOne = nullptr;
+  LVLine *LineTwo = nullptr;
+  LVLine *LineThree = nullptr;
+  LVLine *LineFour = nullptr;
+  LVLine *LineFive = nullptr;
+
+protected:
+  void add(LVScope *Parent, LVElement *Element);
+  template <typename T, typename F> T *create(F Function) {
+    // 'Function' will update a specific kind of the logical element to
+    // have the ability of kind selection.
+    T *Element = new T();
+    EXPECT_NE(Element, nullptr);
+    (Element->*Function)();
+    return Element;
+  }
+  void set(LVElement *Element, StringRef Name, LVOffset Offset,
+           uint32_t LineNumber = 0, LVElement *Type = nullptr);
+
+public:
+  ReaderTestSelection(ScopedPrinter &W) : LVReader("", "", W) {
+    setInstance(this);
+  }
+
+  Error createScopes() { return LVReader::createScopes(); }
+
+  void createElements();
+  void addElements();
+  void initElements();
+  void resolvePatterns(LVPatterns &Patterns);
+  void checkFlexiblePatterns();
+  void checkGenericPatterns();
+  void checkKindPatterns();
+};
+
+// Helper function to add a logical element to a given scope.
+void ReaderTestSelection::add(LVScope *Parent, LVElement *Child) {
+  Parent->addElement(Child);
+  EXPECT_EQ(Child->getParent(), Parent);
+  EXPECT_EQ(Child->getLevel(), Parent->getLevel() + 1);
+}
+
+// Helper function to set the initial values for a given logical element.
+void ReaderTestSelection::set(LVElement *Element, StringRef Name,
+                              LVOffset Offset, uint32_t LineNumber,
+                              LVElement *Type) {
+  Element->setName(Name);
+  Element->setOffset(Offset);
+  Element->setLineNumber(LineNumber);
+  Element->setType(Type);
+  EXPECT_STREQ(Element->getName().data(), Name.data());
+  EXPECT_EQ(Element->getOffset(), Offset);
+  EXPECT_EQ(Element->getLineNumber(), LineNumber);
+  EXPECT_EQ(Element->getType(), Type);
+}
+
+// Create the logical elements.
+void ReaderTestSelection::createElements() {
+  // Create scope root.
+  Error Err = createScopes();
+  ASSERT_THAT_ERROR(std::move(Err), Succeeded());
+  Root = getScopesRoot();
+  EXPECT_NE(Root, nullptr);
+
+  // Create the logical types.
+  IntegerType = create<LVType, LVTypeSetFunction>(&LVType::setIsBase);
+
+  // Create the logical scopes.
+  CompileUnit = create<LVScopeCompileUnit, LVScopeSetFunction>(
+      &LVScope::setIsCompileUnit);
+  Function =
+      create<LVScopeFunction, LVScopeSetFunction>(&LVScope::setIsFunction);
+  NestedScope =
+      create<LVScope, LVScopeSetFunction>(&LVScope::setIsLexicalBlock);
+  Namespace =
+      create<LVScopeNamespace, LVScopeSetFunction>(&LVScope::setIsNamespace);
+  Aggregate =
+      create<LVScopeAggregate, LVScopeSetFunction>(&LVScope::setIsAggregate);
+
+  // Create the logical symbols.
+  ClassMember = create<LVSymbol, LVSymbolSetFunction>(&LVSymbol::setIsMember);
+  LocalVariable =
+      create<LVSymbol, LVSymbolSetFunction>(&LVSymbol::setIsVariable);
+  NestedVariable =
+      create<LVSymbol, LVSymbolSetFunction>(&LVSymbol::setIsVariable);
+  Parameter = create<LVSymbol, LVSymbolSetFunction>(&LVSymbol::setIsParameter);
+
+  // Create the logical lines.
+  LineOne = create<LVLine, LVLineSetFunction>(&LVLine::setIsLineDebug);
+  LineTwo = create<LVLine, LVLineSetFunction>(&LVLine::setIsBasicBlock);
+  LineThree = create<LVLine, LVLineSetFunction>(&LVLine::setIsNewStatement);
+  LineFour = create<LVLine, LVLineSetFunction>(&LVLine::setIsPrologueEnd);
+  LineFive = create<LVLine, LVLineSetFunction>(&LVLine::setIsLineAssembler);
+}
+
+// Create the logical view adding the created logical elements.
+void ReaderTestSelection::addElements() {
+  setCompileUnit(CompileUnit);
+
+  // Root
+  //   CompileUnit
+  //     IntegerType
+  //     Namespace
+  //       Aggregate
+  //         ClassMember
+  //     Function
+  //       Parameter
+  //       LocalVariable
+  //       LineOne
+  //       LineTwo
+  //       NestedScope
+  //         NestedVariable
+  //         LineThree
+  //         LineFour
+  //       LineFive
+
+  // Add elements to Root.
+  add(Root, CompileUnit);
+
+  // Add elements to CompileUnit.
+  add(CompileUnit, IntegerType);
+  add(CompileUnit, Namespace);
+  add(CompileUnit, Function);
+
+  // Add elements to Namespace.
+  add(Namespace, Aggregate);
+
+  // Add elements to Function.
+  add(Function, Parameter);
+  add(Function, LocalVariable);
+  add(Function, LineOne);
+  add(Function, LineTwo);
+  add(Function, LineFive);
+  add(Function, NestedScope);
+
+  // Add elements to Aggregate.
+  add(Aggregate, ClassMember);
+
+  // Add elements to NestedScope.
+  add(NestedScope, NestedVariable);
+  add(NestedScope, LineThree);
+  add(NestedScope, LineFour);
+}
+
+void ReaderTestSelection::resolvePatterns(LVPatterns &Patterns) {
+  // Traverse the given scope and its children applying the pattern match.
+  // Before applying the pattern, reset previous matched state.
+  std::function<void(LVScope * Parent)> traverseScope = [&](LVScope *Parent) {
+    auto traverse = [&](const auto *Set) {
+      if (Set)
+        for (const auto &Entry : *Set) {
+          Entry->resetIsMatched();
+          Patterns.resolvePatternMatch(Entry);
+        }
+    };
+
+    Parent->resetIsMatched();
+    Patterns.resolvePatternMatch(Parent);
+
+    traverse(Parent->getSymbols());
+    traverse(Parent->getTypes());
+    traverse(Parent->getLines());
+
+    if (const LVScopes *Scopes = Parent->getScopes())
+      for (LVScope *Scope : *Scopes) {
+        Scope->resetIsMatched();
+        Patterns.resolvePatternMatch(Scope);
+        traverseScope(Scope);
+      }
+  };
+
+  // Start traversing the scopes root and apply any matching pattern.
+  traverseScope(Root);
+}
+
+// Set initial values to logical elements.
+void ReaderTestSelection::initElements() {
+  // Types.
+  set(IntegerType, "int", 0x1000);
+
+  // Scopes.
+  set(CompileUnit, "test.cpp", 0x2000);
+  set(Namespace, "anyNamespace", 0x3000, 300);
+  set(Aggregate, "anyClass", 0x4000, 400);
+  set(Function, "anyFunction", 0x5000, 500, IntegerType);
+  set(NestedScope, "", 0x6000, 600);
+
+  // Symbols.
+  set(Parameter, "Param", 0x5100, 510, IntegerType);
+  set(LocalVariable, "LocalVariable", 0x5200, 520, IntegerType);
+  set(NestedVariable, "NestedVariable", 0x6200, 620, IntegerType);
+
+  // Lines.
+  set(LineOne, "", 0x5110, 511);
+  set(LineTwo, "", 0x5210, 521);
+  set(LineThree, "", 0x6110, 611);
+  set(LineFour, "", 0x6210, 621);
+  set(LineFive, "", 0x7110, 711);
+}
+
+// Check logical elements kind patterns.
+void ReaderTestSelection::checkKindPatterns() {
+  // Add patterns.
+  LVPatterns &Patterns = patterns();
+  Patterns.clear();
+
+  LVElementKindSet KindElements; // --select-elements=<Kind>
+  LVLineKindSet KindLines;       // --select-lines=<Kind>
+  LVScopeKindSet KindScopes;     // --select-scopes=<Kind>
+  LVSymbolKindSet KindSymbols;   // --select-symbols=<Kind>
+  LVTypeKindSelection KindTypes; // --select-types=<Kind>
+
+  KindElements.insert(LVElementKind::Global);
+  KindLines.insert(LVLineKind::IsLineDebug);
+  KindLines.insert(LVLineKind::IsNewStatement);
+  KindLines.insert(LVLineKind::IsLineAssembler);
+  KindScopes.insert(LVScopeKind::IsLexicalBlock);
+  KindSymbols.insert(LVSymbolKind::IsMember);
+  KindSymbols.insert(LVSymbolKind::IsParameter);
+  KindTypes.insert(LVTypeKind::IsBase);
+
+  // Add requests based on the element kind.
+  Patterns.addRequest(KindElements);
+  Patterns.addRequest(KindLines);
+  Patterns.addRequest(KindScopes);
+  Patterns.addRequest(KindSymbols);
+  Patterns.addRequest(KindTypes);
+
+  // Apply the collected patterns.
+  resolvePatterns(Patterns);
+
+  EXPECT_EQ(CompileUnit->getIsMatched(), 0);
+  EXPECT_EQ(Namespace->getIsMatched(), 0);
+  EXPECT_EQ(Aggregate->getIsMatched(), 0);
+  EXPECT_EQ(Function->getIsMatched(), 0);
+  EXPECT_EQ(NestedScope->getIsMatched(), 1);
+
+  EXPECT_EQ(IntegerType->getIsMatched(), 1);
+
+  EXPECT_EQ(ClassMember->getIsMatched(), 1);
+  EXPECT_EQ(Parameter->getIsMatched(), 1);
+  EXPECT_EQ(LocalVariable->getIsMatched(), 0);
+  EXPECT_EQ(NestedVariable->getIsMatched(), 0);
+
+  EXPECT_EQ(LineOne->getIsMatched(), 1);
+  EXPECT_EQ(LineTwo->getIsMatched(), 0);
+  EXPECT_EQ(LineThree->getIsMatched(), 1);
+  EXPECT_EQ(LineFour->getIsMatched(), 0);
+  EXPECT_EQ(LineFive->getIsMatched(), 1);
+}
+
+// Check logical elements generic patterns (Case sensitive).
+void ReaderTestSelection::checkGenericPatterns() {
+  // Add patterns.
+  LVPatterns &Patterns = patterns();
+  Patterns.clear();
+
+  StringSet<> Generic;                      // --select=<Pattern>
+  Generic.insert(Function->getName());      // anyFunction
+  Generic.insert(Namespace->getName());     // anyNamespace
+  Generic.insert(LocalVariable->getName()); // LocalVariable
+
+  LVOffsetSet Offsets; // --select-offset=<Offset>
+  Offsets.insert(IntegerType->getOffset());
+  Offsets.insert(LineOne->getOffset());
+  Offsets.insert(LineTwo->getOffset());
+
+  // Add requests based on the generic string and offset.
+  Patterns.addGenericPatterns(Generic);
+  Patterns.addOffsetPatterns(Offsets);
+
+  // Apply the collected patterns.
+  resolvePatterns(Patterns);
+
+  EXPECT_EQ(CompileUnit->getIsMatched(), 0);
+  EXPECT_EQ(Namespace->getIsMatched(), 1);
+  EXPECT_EQ(Aggregate->getIsMatched(), 0);
+  EXPECT_EQ(Function->getIsMatched(), 1);
+  EXPECT_EQ(NestedScope->getIsMatched(), 0);
+
+  EXPECT_EQ(IntegerType->getIsMatched(), 1);
+
+  EXPECT_EQ(ClassMember->getIsMatched(), 0);
+  EXPECT_EQ(Parameter->getIsMatched(), 0);
+  EXPECT_EQ(LocalVariable->getIsMatched(), 1);
+  EXPECT_EQ(NestedVariable->getIsMatched(), 0);
+
+  EXPECT_EQ(LineOne->getIsMatched(), 1);
+  EXPECT_EQ(LineTwo->getIsMatched(), 1);
+  EXPECT_EQ(LineThree->getIsMatched(), 0);
+  EXPECT_EQ(LineFour->getIsMatched(), 0);
+  EXPECT_EQ(LineFive->getIsMatched(), 0);
+}
+
+// Check logical elements flexible patterns (case insensitive, RegEx).
+void ReaderTestSelection::checkFlexiblePatterns() {
+  options().setSelectIgnoreCase();
+  options().setSelectUseRegex();
+
+  // Add patterns.
+  LVPatterns &Patterns = patterns();
+  Patterns.clear();
+
+  StringSet<> Generic; // --select=<Pattern>
+  Generic.insert("function");
+  Generic.insert("NaMeSpAcE");
+  Generic.insert("[a-z]*Variable");
+  Generic.insert("[0-9]21");
+
+  // Add requests based on the flexible string.
+  Patterns.addGenericPatterns(Generic);
+
+  // Apply the collected patterns.
+  resolvePatterns(Patterns);
+
+  EXPECT_EQ(CompileUnit->getIsMatched(), 0);
+  EXPECT_EQ(Namespace->getIsMatched(), 1); // anyNamespace
+  EXPECT_EQ(Aggregate->getIsMatched(), 0);
+  EXPECT_EQ(Function->getIsMatched(), 1); // anyFunction
+  EXPECT_EQ(NestedScope->getIsMatched(), 0);
+
+  EXPECT_EQ(IntegerType->getIsMatched(), 0);
+
+  EXPECT_EQ(ClassMember->getIsMatched(), 0);
+  EXPECT_EQ(Parameter->getIsMatched(), 0);
+  EXPECT_EQ(LocalVariable->getIsMatched(), 1);  // LocalVariable
+  EXPECT_EQ(NestedVariable->getIsMatched(), 1); // NesteVariable
+
+  EXPECT_EQ(LineOne->getIsMatched(), 0);
+  EXPECT_EQ(LineTwo->getIsMatched(), 1); // 521
+  EXPECT_EQ(LineThree->getIsMatched(), 0);
+  EXPECT_EQ(LineFour->getIsMatched(), 1); // 621
+  EXPECT_EQ(LineFive->getIsMatched(), 0);
+}
+
+TEST(LogicalViewTest, SelectElements) {
+  ScopedPrinter W(outs());
+  ReaderTestSelection Reader(W);
+
+  // Reader options.
+  LVOptions ReaderOptions;
+  ReaderOptions.setAttributeOffset();
+  ReaderOptions.setPrintAll();
+  ReaderOptions.setReportList();
+  ReaderOptions.setReportAnyView();
+
+  ReaderOptions.resolveDependencies();
+  options().setOptions(&ReaderOptions);
+
+  Reader.createElements();
+  Reader.addElements();
+  Reader.initElements();
+  Reader.checkKindPatterns();
+  Reader.checkGenericPatterns();
+  Reader.checkFlexiblePatterns();
+}
+
+} // namespace