[llvm-debuginfo-analyzer] Add combined selection for logical elements.

[CarlosAlbertoEnciso]

Summary

Sometimes the output generated by any of the options:

--select=<pattern>
--select-elements=<condition[,condition,...]>
--select-lines=<kind[,kind,...]>
--select-scopes=<kind[,kind,...]>
--select-symbols=<kind[,kind,...]>
--select-types=<kind[,kind,...]>

is too general and includes information that is not required.

Add a combined selection feature, that includes the <pattern> AND <kind> as a criteria, to allow the selection of a specific <kind>
of logical element, line, scope, symbol or type that matches the given <pattern>.

--select=<pattern> --select-elements=<condition[,condition,...]>
--select=<pattern> --select-lines=<kind[,kind,...]>
--select=<pattern> --select-scopes=<kind[,kind,...]>
--select=<pattern> --select-symbols=<kind[,kind,...]>
--select=<pattern> --select-types=<kind[,kind,...]>

For the --report=view, include only elements that meet the criteria.

[jmorse]

Sounds good, some questions / suggestions inline

llvm/docs/CommandGuide/llvm-debuginfo-analyzer.rst

467–469

Good place to forward-reference the filtering/combined section?

581

Could I suggest that this section is titled and described in terms of "filter" rather than "combined selection" -- I think the meaning of "filter" is clear to all readers, and it'll be easier + quicker to understand the command line options if written in those terms.

As far as I understand it, all of the options you're adding are to reduce the number of things printed by filtering for a particular condition, right?

632

What do you mean by mix here -- you can use multiple --select-something options, or you need to add pairs of --select and --select-something?

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

545–546

It's not completely clear to me what's going on here (docu-comments appreciated), in particular, shouldn't the getSelectCombinedPattern case be a stricter version of the other side of the branch? And if so, why is it different, can't it be implemented as

if (doesnt-match-filter)
    return;
the-rest-of-the-body();

?

[CarlosAlbertoEnciso]

llvm/docs/CommandGuide/llvm-debuginfo-analyzer.rst

467–469

Added a forward-reference to FILTER section.

581

Section changed to FILTER.

Your understanding is correct.

[CarlosAlbertoEnciso]

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

545–546

'SelectCombinedPattern` is set when:

(--select-elements or --select-lines or --select-scopes or --select-symbols or --select-types) and (--select) are specified in the command line.

The matching conditions for both branches are different.
I can remove the else branch and add return on the if branch to simplify the code. Basically the combined takes priority over the normal selection.

[CarlosAlbertoEnciso]

llvm/docs/CommandGuide/llvm-debuginfo-analyzer.rst

632

Yes. You can use multiple --select-something options and multiple --select. They don't need to be paired.

[CarlosAlbertoEnciso]

@jmorse Thanks for your review. I have addressed the raised points.

[CarlosAlbertoEnciso]

Ping.

[jmorse]

I've got a reasonable amount of confusion here -- what's currently line 634 reads "for more specific combined criterias", and further up you agree that the point of the option is to "filter" and reduce the number of elements presented. However the explanatory text,

A logical element, line, scope, symbol or type will be selected if their name or line number matches any of the given <pattern>s **and** their <kind> or <condition> matches any of the given <kind>s or <condition>s.

actually broadens the number of elements presented: given that only one "--select" pattern needs to be matched, additional "--select" patterns will expand the number of elements presented, and it's the same for the "kind" selections. Am I misunderstanding this or are the two opposed; and if so, which is it supposed to be? I can see use-cases for both behaviours.

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

512–520

This feels more like documentation for the option, rather than the following function, resolveGenericPatternMatch -- it's the purpose of the function that's unclear to me.

llvm/docs/CommandGuide/llvm-debuginfo-analyzer.rst

  Pattern matching is case-insensitive when using :option:`--select`.
 
 .. option:: --select-regex
 
  Treat any <pattern> strings as regular expressions when selecting with
  :option:`--select` option. If :option:`--select-nocase` is specified,
  the regular expression becomes case-insensitive.
 
-If the <pattern> criteria is too general, a more selective option can
-be specified to target a particular category of elements:
+If the <pattern> criteria is too general, a more selective option
+(:ref:`filter-label`) can be specified to target a particular category
+of elements:
 lines (:option:`--select-lines`), scopes (:option:`--select-scopes`),
 symbols (:option:`--select-symbols`) and types (:option:`--select-types`).
+
 These options require knowledge of the debug information format (DWARF,
-CodeView, COFF), as the given **kind** describes a very specific type
+CodeView), as the given **kind** describes a very specific type
 of element.
 
 LINES
 ^^^^^
 The following options allow printing of lines that match the given <kind>.
 The given criteria describes the debug line state machine registers.
 
 .. option:: --select-lines=<kind[,kind,...]>
.. code-block:: text
     =TemplateParam: Template parameter.
     =TemplateTemplateParam: Template template parameter.
     =TemplateTypeParam: Template type parameter.
     =TemplateValueParam: Template value parameter.
     =Typedef: Type definition.
     =Unspecified: Unspecified type.
     =Volatile: Volatile specifier.
 
+.. _filter-label:
+
+FILTER
+^^^^^^
+If the output generated by any of the options (:option:`--select`),
+(:option:`--select-elements`), (:option:`--select-lines`),
+(:option:`--select-scopes`), (:option:`--select-symbols`),
+(:option:`--select-types`) is too general, a combined selection can be
+used to add extra filtering.
+
+:program:`llvm-debuginfo-analyzer` supports a combined selection feature,
+that includes the <pattern> and <kind> as a criteria, to allow the
+selection of a specific <kind> of logical element, line, scope, symbol
+or type that matches the given <pattern>.
+
+The most basic combined criteria will include one of the following
+options:
+
+.. code-block:: none
+
+  --select=<pattern> --select-elements=<condition>
+
+which select logical elements that satisfy the given <condition>
+**and** whose name or line number matches the given <pattern>.
+
+.. code-block:: none
+
+  --select=<pattern> --select-lines=<kind>
+
+which select logical lines that match the given <kind> **and** whose
+line number matches <pattern>.
+
+.. code-block:: none
+
+  --select=<pattern> --select-scopes=<kind>
+
+which select logical scopes that match the given <kind> **and** whose
+name matches the given <pattern>.
+
+.. code-block:: none
+
+  --select=<pattern> --select-symbols=<kind>
+
+which select logical symbols that match the given <kind> **and** whose
+name matches the given <pattern>.
+
+.. code-block:: none
+
+  --select=<pattern> --select-types=<kind>
+
+which select logical types that match the given <kind> **and** whose
+name matches the given <pattern>.
+
+For more specific combined criterias, a mix of the following options
+
+.. code-block:: none
+
+  --select=<pattern> --select-elements=<condition[,condition,...]>
+  --select=<pattern> --select-lines=<kind[,kind,...]>
+  --select=<pattern> --select-scopes=<kind[,kind,...]>
+  --select=<pattern> --select-symbols=<kind[,kind,...]>
+  --select=<pattern> --select-types=<kind[,kind,...]>
+
+can be specified. A logical element, line, scope, symbol or type will
+be selected if their name or line number matches any of the given
+<pattern>s **and** their <kind> or <condition> matches any of the given
+<kind>s or <condition>s.
+
 .. _compare_:
 
 COMPARE
 ~~~~~~~
 When dealing with debug information, there are situations when the
 printing of the elements is not the correct approach. That is the case,
 when we are interested in the effects caused by different versions of
 the same toolchain, or the impact of specific compiler optimizations.
 
 For those cases, we are looking to see which elements have been added
 or removed. Due to the complicated debug information format, it is very
 difficult to use a regular diff tool to find those elements; even
 impossible when dealing with different debug formats.
 
 :program:`llvm-debuginfo-analyzer` supports a logical element comparison,
 allowing to find semantic differences between logical views, produced by
 different toolchain versions or even debug information formats.
 
 When comparing logical views created from different debug formats, its
 accuracy depends on how close the debug information represents the
 user code. For instance, a logical view created from a binary file with
 DWARF debug information may include more detailed data than a logical
-view created from a binary file with CodeView/COFF debug information.
+view created from a binary file with CodeView debug information.
 
 The following options describe the elements to compare.
 
 .. option:: --compare=<value[,value,...]>
 
  With **value** being one of the options in the following list.
 
  .. code-block:: text
.. code-block:: none
   -----------------------------
   Scopes           3          0
   Symbols          4          1
   Types            2          1
   Lines           17          6
   -----------------------------
   Total           26          8
 
+COMBINED SELECT LOGICAL ELEMENTS
+""""""""""""""""""""""""""""""""
+The following prints all *scopes* that are **Function**, all *lines*
+that are **LineDebug** or **LineAssembler**, all *symbols* that are
+**Parameter** and all *types* that are **Typedef** and that contain
+**'foo'** or **'ParamBool'** or **'retq'** or **'INTEGER'** or **'6'**
+in their names, types, assembler instructions or line numbers, using
+a tab layout and given the number of matches.
+
+.. code-block:: none
+
+  llvm-debuginfo-analyzer --attribute=level
+                          --select=foo
+                          --select=ParamBool
+                          --select=retq
+                          --select=INTEGER
+                          --select=6
+                          --select-lines=LineAssembler,LineDebug
+                          --select-scopes=Function
+                          --select-symbols=Parameter
+                          --select-types=Typedef
+                          --report=list
+                          --print=elements,summary
+                          test-dwarf-clang.o
+
+  Logical View:
+  [000]           {File} 'test-dwarf-clang.o'
+
+  [001]           {CompileUnit} 'test.cpp'
+  [003]           {Code} 'retq'
+  [003]     2     {Parameter} 'ParamBool' -> 'bool'
+  [002]     2     {Function} extern not_inlined 'foo' -> 'int'
+  [003]     4     {TypeAlias} 'INTEGER' -> 'int'
+  [004]     6     {Line}
+
+  -----------------------------
+  Element      Total      Found
+  -----------------------------
+  Scopes           3          1
+  Symbols          4          1
+  Types            2          1
+  Lines           25          2
+  -----------------------------
+  Total           34          5
+
 COMPARISON MODE
 ^^^^^^^^^^^^^^^
 In this mode :program:`llvm-debuginfo-analyzer` compares logical views
 to produce a report with the logical elements that are missing or added.
 This a very powerful aid in finding semantic differences in the debug
 information produced by different toolchain versions or even completely
 different toolchains altogether (For example a compiler producing DWARF
 can be directly compared against a completely different compiler that

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

class LVOptions {
   public:
     LVReportKindSet Kinds; // --report=<kind>
     bool AnyView = false;  // View, Parents or Children.
     bool Execute = false;  // Report requested.
   };
 
   class LVSelect {
   public:
-    bool IgnoreCase = false;     // --select-ignore-case
-    bool UseRegex = false;       // --select-use-regex
-    bool Execute = false;        // Select requested.
-    bool GenericKind = false;    // We have collected generic kinds.
-    bool GenericPattern = false; // We have collected generic patterns.
-    bool OffsetPattern = false;  // We have collected offset patterns.
-    StringSet<> Generic;         // --select=<Pattern>
-    LVOffsetSet Offsets;         // --select-offset=<Offset>
-    LVElementKindSet Elements;   // --select-elements=<Kind>
-    LVLineKindSet Lines;         // --select-lines=<Kind>
-    LVScopeKindSet Scopes;       // --select-scopes=<Kind>
-    LVSymbolKindSet Symbols;     // --select-symbols=<Kind>
-    LVTypeKindSelection Types;   // --select-types=<Kind>
+    bool IgnoreCase = false;      // --select-ignore-case
+    bool UseRegex = false;        // --select-use-regex
+    bool Execute = false;         // Select requested.
+    bool GenericKind = false;     // We have collected generic kinds.
+    bool GenericPattern = false;  // We have collected generic patterns.
+    bool OffsetPattern = false;   // We have collected offset patterns.
+    bool CombinedPattern = false; // We have combined selection.
+    StringSet<> Generic;          // --select=<Pattern>
+    LVOffsetSet Offsets;          // --select-offset=<Offset>
+    LVElementKindSet Elements;    // --select-elements=<Kind>
+    LVLineKindSet Lines;          // --select-lines=<Kind>
+    LVScopeKindSet Scopes;        // --select-scopes=<Kind>
+    LVSymbolKindSet Symbols;      // --select-symbols=<Kind>
+    LVTypeKindSelection Types;    // --select-types=<Kind>
   };
 
   class LVOutput {
   public:
     LVOutputKindSet Kinds;                  // --output=<kind>
     LVSortMode SortMode = LVSortMode::None; // --output-sort=<SortMode>
     std::string Folder;                     // --output-folder=<Folder>
     unsigned Level = -1U;                   // --output-level=<level>
public:
 
   // --select.
   BOOL_FUNCTION(Select, IgnoreCase);
   BOOL_FUNCTION(Select, UseRegex);
   BOOL_FUNCTION(Select, Execute);
   BOOL_FUNCTION(Select, GenericKind);
   BOOL_FUNCTION(Select, GenericPattern);
   BOOL_FUNCTION(Select, OffsetPattern);
+  BOOL_FUNCTION(Select, CombinedPattern);
 
   // --warning.
   WARNING_OPTION(All);
   WARNING_OPTION(Coverages);
   WARNING_OPTION(Lines);
   WARNING_OPTION(Locations);
   WARNING_OPTION(Ranges);
 
for (const auto &Entry : Selection) {
       typename U::const_iterator Iter = Dispatch.find(Entry);
       if (Iter != Dispatch.end())
         Request.push_back(Iter->second);
     }
   }
 
   void addElement(LVElement *Element);
 
+  // 'SelectCombinedPattern' is set when one or more of the '--select-xxx'
+  // and at least one '--select' options are specified in the command line,
+  // with '--select-xxx' being:
+  //   --select-elements, --select-lines,  --select-scopes
+  //   --select-symbols, --select-types`
+  //
+  // There are 2 cases for the combined selection matching, with target being:
+  // - LVLine
+  // - LVScopes, LVSymbols, LVTypes
+
   template <typename T, typename U>
   void resolveGenericPatternMatch(T *Element, const U &Requests) {
     assert(Element && "Element must not be nullptr");
     auto CheckPattern = [=]() -> bool {
       return (Element->isNamed() &&
               (matchGenericPattern(Element->getName()) ||
                matchGenericPattern(Element->getLinkageName()))) ||
              (Element->isTyped() &&
               matchGenericPattern(Element->getTypeName()));
     };
     auto CheckOffset = [=]() -> bool {
       return matchOffsetPattern(Element->getOffset());
     };
+    if (options().getSelectCombinedPattern()) {
+      if (CheckPattern() && (Requests.size() || ElementRequest.size()) &&
+          checkElementRequest(Element, Requests))
+        addElement(Element);
+      return;
+    }
     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) {
     assert(Line && "Line must not be nullptr");
     auto CheckPattern = [=]() -> bool {
       return matchGenericPattern(Line->lineNumberAsStringStripped()) ||
              matchGenericPattern(Line->getName()) ||
              matchGenericPattern(Line->getPathname());
     };
     auto CheckOffset = [=]() -> bool {
       return matchOffsetPattern(Line->getAddress());
     };
+    if (options().getSelectCombinedPattern()) {
+      if (CheckPattern() &&
+          (Requests.size() && checkElementRequest(Line, Requests)))
+        addElement(Line);
+      return;
+    }
     if ((options().getSelectGenericPattern() && CheckPattern()) ||
         (options().getSelectOffsetPattern() && CheckOffset()) ||
         (Requests.size() && checkElementRequest(Line, Requests)))
       addElement(Line);
   }
 
   Error createMatchEntry(LVMatchInfo &Filters, StringRef Pattern,
                          bool IgnoreCase, bool UseRegex);

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

OS << "** Report **\n"
      << "Parents:  " << getReportParents() << ", "
      << "View:     " << getReportView() << "\n";
   OS << "AnyView:  " << getReportAnyView() << ", "
      << "Execute:  " << getReportExecute() << "\n"
      << "\n";
 
   // --select
   OS << "** Select **\n"
-     << "IgnoreCase:     " << getSelectIgnoreCase() << ", "
-     << "UseRegex:       " << getSelectUseRegex() << ", "
-     << "Execute:        " << getSelectExecute() << ", "
-     << "GenericKind:    " << getSelectGenericKind() << "\n"
-     << "GenericPattern: " << getSelectGenericPattern() << ", "
-     << "OffsetPattern:  " << getSelectOffsetPattern() << "\n"
+     << "IgnoreCase:      " << getSelectIgnoreCase() << ", "
+     << "UseRegex:        " << getSelectUseRegex() << ", "
+     << "Execute:         " << getSelectExecute() << ", "
+     << "GenericKind:     " << getSelectGenericKind() << "\n"
+     << "GenericPattern:  " << getSelectGenericPattern() << ", "
+     << "OffsetPattern:   " << getSelectOffsetPattern() << ","
+     << "CombinedPattern: " << getSelectCombinedPattern() << "\n"
      << "\n";
 
   // --warning
   OS << "** Warning **\n"
      << "All:       " << getWarningAll() << ", "
      << "Coverage:  " << getWarningCoverages() << ", "
      << "Lines:     " << getWarningLines() << ", "
      << "Locations: " << getWarningLocations() << ", "
if (options().getReportAnyView()) {
     if (!Element->getIsScope())
       Element->setHasPattern();
   }
 }
 
 void LVPatterns::updateReportOptions() {
   if (ElementRequest.size() || LineRequest.size() || ScopeRequest.size() ||
       SymbolRequest.size() || TypeRequest.size()) {
+    // Compound selection.
+    if (options().getSelectGenericPattern())
+      options().setSelectCombinedPattern();
     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();

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

std::function<void(LVScope * Scope)> TraverseChildren = [&](LVScope *Scope) {
     auto Traverse = [&](const auto *Set) {
       if (Set)
         for (const auto &Entry : *Set)
           (Entry->*SetFunction)();
     };
 
     (Scope->*SetFunction)();
 
-    Traverse(Scope->getTypes());
-    Traverse(Scope->getSymbols());
-    Traverse(Scope->getLines());
+    // The 'HasPattern' property for all the elements that meet the selection
+    // criteria is already set to true. Do not traverse the children that are
+    // types, symbols or lines, because that will include elements that do not
+    // meet the selection criteria.
 
     if (const LVScopes *Scopes = Scope->getScopes())
       for (LVScope *Scope : *Scopes)
         TraverseChildren(Scope);
   };
 
   if (options().getReportChildren())
     TraverseChildren(this);

llvm/test/tools/llvm-debuginfo-analyzer/COFF/01-coff-select-logical-elements.test

 ; THREE-NEXT: [001]           {CompileUnit} 'test.cpp'
 ; THREE-NEXT: [002]           {Function} extern not_inlined 'foo' -> 'int'
 ; THREE-EMPTY:
 ; THREE:      Logical View:
 ; THREE-NEXT: [000]           {File} 'test-codeview-msvc.o'
 ; THREE-EMPTY:
 ; THREE-NEXT: [001]           {CompileUnit} 'test.cpp'
 ; THREE-NEXT: [002]           {Function} extern not_inlined 'foo' -> 'int'
+
+; Select logical elements (Combined).
+; The following prints all 'scopes:Function', 'lines:LineDebug',
+; 'instructions:LineAssembler', 'symbols:Parameter' and 'types:Typedef'
+; that contain 'foo', 'ParamBool', 'retq', 'INTEGER' or '6' in their
+; names, types or line number, using a tab layout and given the number
+; of matches.
+
+; RUN: llvm-debuginfo-analyzer --attribute=level \
+; RUN:                         --select=foo \
+; RUN:                         --select=ParamBool \
+; RUN:                         --select=retq \
+; RUN:                         --select=INTEGER \
+; RUN:                         --select=6 \
+; RUN:                         --select-lines=LineAssembler,LineDebug \
+; RUN:                         --select-scopes=Function \
+; RUN:                         --select-symbols=Parameter \
+; RUN:                         --select-types=Typedef \
+; RUN:                         --report=list \
+; RUN:                         --print=elements \
+; RUN:                         %p/Inputs/test-codeview-clang.o \
+; RUN:                         %p/Inputs/test-codeview-msvc.o 2>&1 | \
+; RUN: FileCheck --strict-whitespace -check-prefix=FOUR %s
+
+; FOUR:      Logical View:
+; FOUR-NEXT: [000]           {File} 'test-codeview-clang.o'
+; FOUR-EMPTY:
+; FOUR-NEXT: [001]           {CompileUnit} 'test.cpp'
+; FOUR-NEXT: [003]           {TypeAlias} 'INTEGER' -> 'int'
+; FOUR-NEXT: [003]           {Parameter} 'ParamBool' -> 'bool'
+; FOUR-NEXT: [002]           {Function} extern not_inlined 'foo' -> 'int'
+; FOUR-NEXT: [003]           {Code} 'retq'
+; FOUR-NEXT: [004]     6     {Line}
+; FOUR-EMPTY:
+; FOUR-NEXT: Logical View:
+; FOUR-NEXT: [000]           {File} 'test-codeview-msvc.o'
+; FOUR-EMPTY:
+; FOUR-NEXT: [001]           {CompileUnit} 'test.cpp'
+; FOUR-NEXT: [004]           {TypeAlias} 'INTEGER' -> 'int'
+; FOUR-NEXT: [002]           {Function} extern not_inlined 'foo' -> 'int'
+; FOUR-NEXT: [003]           {Code} 'retq'
+; FOUR-NEXT: [004]     6     {Line}

llvm/test/tools/llvm-debuginfo-analyzer/DWARF/01-dwarf-select-logical-elements.test

 ; THREE-NEXT: [001]           {CompileUnit} 'test.cpp'
 ; THREE-NEXT: [002]     2     {Function} extern not_inlined 'foo' -> 'int'
 ; THREE-EMPTY:
 ; THREE:      Logical View:
 ; THREE-NEXT: [000]           {File} 'pr-57040-test-dwarf-gcc.o'
 ; THREE-EMPTY:
 ; THREE-NEXT: [001]           {CompileUnit} 'test.cpp'
 ; THREE-NEXT: [002]     2     {Function} extern not_inlined 'foo' -> 'int'
+
+; Select logical elements (Combined).
+; The following prints all 'scopes:Function', 'lines:LineDebug',
+; 'instructions:LineAssembler', 'symbols:Parameter' and 'types:Typedef'
+; that contain 'foo', 'ParamBool', 'retq', 'INTEGER' or '6' in their
+; names, types or line number, using a tab layout and given the number
+; of matches.
+
+; RUN: llvm-debuginfo-analyzer --attribute=level \
+; RUN:                         --select=foo \
+; RUN:                         --select=ParamBool \
+; RUN:                         --select=retq \
+; RUN:                         --select=INTEGER \
+; RUN:                         --select=6 \
+; RUN:                         --select-lines=LineAssembler,LineDebug \
+; RUN:                         --select-scopes=Function \
+; RUN:                         --select-symbols=Parameter \
+; RUN:                         --select-types=Typedef \
+; RUN:                         --report=list \
+; RUN:                         --print=elements \
+; RUN:                         %p/Inputs/test-dwarf-clang.o \
+; RUN:                         %p/Inputs/test-dwarf-gcc.o 2>&1 | \
+; RUN: FileCheck --strict-whitespace -check-prefix=FOUR %s
+
+; FOUR:      Logical View:
+; FOUR-NEXT: [000]           {File} 'test-dwarf-clang.o'
+; FOUR-EMPTY:
+; FOUR-NEXT: [001]           {CompileUnit} 'test.cpp'
+; FOUR-NEXT: [003]           {Code} 'retq'
+; FOUR-NEXT: [003]     2     {Parameter} 'ParamBool' -> 'bool'
+; FOUR-NEXT: [002]     2     {Function} extern not_inlined 'foo' -> 'int'
+; FOUR-NEXT: [003]     4     {TypeAlias} 'INTEGER' -> 'int'
+; FOUR-NEXT: [004]     6     {Line}
+; FOUR-EMPTY:
+; FOUR-NEXT: Logical View:
+; FOUR-NEXT: [000]           {File} 'test-dwarf-gcc.o'
+; FOUR-EMPTY:
+; FOUR-NEXT: [001]           {CompileUnit} 'test.cpp'
+; FOUR-NEXT: [003]           {Code} 'retq'
+; FOUR-NEXT: [003]     2     {Parameter} 'ParamBool' -> 'bool'
+; FOUR-NEXT: [002]     2     {Function} extern not_inlined 'foo' -> 'int'
+; FOUR-NEXT: [004]     4     {TypeAlias} 'INTEGER' -> 'int'
+; FOUR-NEXT: [004]     6     {Line}