[llvm-dwarfdump][Statistics] Ignore declarations of global variables

[djtodoro]

This makes sense to me!

[djtodoro]

Please add a test case.

[krisb]

Add a test.

[krisb]

@djtodoro thanks! Are you okay with this test case?

[djtodoro]

Nice, thanks!

llvm/test/tools/llvm-dwarfdump/X86/statistics.ll

 ; RUN: llc -O0 %s -o - -filetype=obj \
 ; RUN:   | llvm-dwarfdump -statistics - | FileCheck %s
 ; CHECK: "version":4
 
+; namespace test {
+;  extern int a;
+; }
+; using test::a;
+;
 ; int GlobalConst = 42;
 ; int Global;
 ;
 ; struct S {
 ;   static const int constant = 24;
 ;   int (*fn)(int);
 ; } s;
 ;
 ; int __attribute__((always_inline)) square(int i) { return i * i; }
 ; int cube(int i) {
 ;   int squared = square(i);
 ;   return squared*i;
 ; }
 
 ; Following variables/arguments/members should be counted:
 ;     - GlobalConst,
 ;     - Global,
-;     - s, s.constant ('fn' and its arguments should be skipped),
+;     - s, s.constant,
 ;     - square::i,
 ;     - cube::i, cube::squared
+; Skipped entities:
+;     - declaration of test::a,
+;     - non-constant member S:fn,
+;     - arguments of S:fn.
 
 ; CHECK: "unique source variables":7
 ; +1 extra inline i.
 ; CHECK: "source variables":8
 ; -1 square::i
 ; CHECK: "variables with location":7
 ; CHECK: "scope bytes total":[[BYTES:[0-9]+]]
 ; Because of the dbg.value in the middle of the function, the pc range coverage

 attributes #2 = { noinline nounwind optnone ssp uwtable }
 
 !llvm.dbg.cu = !{!2}
 !llvm.module.flags = !{!15, !16, !17, !18}
 !llvm.ident = !{!19}
 
 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = distinct !DIGlobalVariable(name: "GlobalConst", scope: !2, file: !3, line: 1, type: !8, isLocal: false, isDefinition: true)
-!2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !3, producer: "clang version 6.0.0 (trunk 310529) (llvm/trunk 310534)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5)
+!2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !3, producer: "clang version 6.0.0 (trunk 310529) (llvm/trunk 310534)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, imports: !48, globals: !5)
 !3 = !DIFile(filename: "/tmp/quality.cpp", directory: "/Volumes/Data/llvm")
 !4 = !{}
 !5 = !{!0, !6, !9}
 !6 = !DIGlobalVariableExpression(var: !7, expr: !DIExpression())
 !7 = distinct !DIGlobalVariable(name: "Global", scope: !2, file: !3, line: 2, type: !8, isLocal: false, isDefinition: true)
 !8 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
 !9 = !DIGlobalVariableExpression(var: !10, expr: !DIExpression())
 !10 = distinct !DIGlobalVariable(name: "s", scope: !2, file: !3, line: 6, type: !11, isLocal: false, isDefinition: true)

 !40 = !DILocation(line: 8, column: 61, scope: !20, inlinedAt: !32)
 !41 = !DILocation(line: 11, column: 10, scope: !30)
 !42 = !DILocation(line: 11, column: 18, scope: !30)
 !43 = !DILocation(line: 11, column: 17, scope: !30)
 !44 = !DILocation(line: 11, column: 3, scope: !30)
 !45 = !DIDerivedType(tag: DW_TAG_member, name: "fn", scope: !11, file: !3, line: 5, baseType: !46, size: 64)
 !46 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !47, size: 64)
 !47 = !DISubroutineType(types: !22)
+!48 = !{!49}
+!49 = !DIImportedEntity(tag: DW_TAG_imported_declaration, scope: !2, entity: !50, file: !3, line: 2)
+!50 = !DIGlobalVariable(name: "a", linkageName: "_ZN4test1aE", scope: !51, file: !3, line: 2, type: !8, isLocal: false, isDefinition: false)
+!51 = !DINamespace(name: "test", scope: !2)

llvm/tools/llvm-dwarfdump/Statistics.cpp

static void collectStatsForDie(DWARFDie Die, std::string FnPrefix,
   bool HasLoc = false;
   bool HasSrcLoc = false;
   bool HasType = false;
   bool IsArtificial = false;
   uint64_t BytesCovered = 0;
   uint64_t BytesEntryValuesCovered = 0;
   auto &FnStats = FnStatMap[FnPrefix];
   bool IsParam = Die.getTag() == dwarf::DW_TAG_formal_parameter;
-  bool IsLocalVar = Die.getTag() == dwarf::DW_TAG_variable;
+  bool IsVariable = Die.getTag() == dwarf::DW_TAG_variable;
 
   if (Die.getTag() == dwarf::DW_TAG_call_site ||
       Die.getTag() == dwarf::DW_TAG_GNU_call_site) {
     GlobalStats.CallSiteDIEs++;
     return;
   }
 
   if (Die.getTag() == dwarf::DW_TAG_call_site_parameter ||
       Die.getTag() == dwarf::DW_TAG_GNU_call_site_parameter) {
     GlobalStats.CallSiteParamDIEs++;
     return;
   }
 
-  if (!IsParam && !IsLocalVar && Die.getTag() != dwarf::DW_TAG_member) {
+  if (!IsParam && !IsVariable && Die.getTag() != dwarf::DW_TAG_member) {
     // Not a variable or constant member.
     return;
   }
 
+  // Ignore declarations of global variables.
+  if (IsVariable && Die.find(dwarf::DW_AT_declaration))
+    return;
+
   if (Die.findRecursively(dwarf::DW_AT_decl_file) &&
       Die.findRecursively(dwarf::DW_AT_decl_line))
     HasSrcLoc = true;
 
   if (Die.findRecursively(dwarf::DW_AT_type))
     HasType = true;
 
   if (Die.find(dwarf::DW_AT_artificial))
if (Die.find(dwarf::DW_AT_const_value)) {
     }
   }
 
   // Calculate the debug location statistics.
   if (BytesInScope) {
     LocStats.NumVarParam++;
     if (IsParam)
       LocStats.NumParam++;
-    else if (IsLocalVar)
+    else if (IsVariable)
       LocStats.NumVar++;
 
     collectLocStats(BytesCovered, BytesInScope, LocStats.VarParamLocStats,
                     LocStats.ParamLocStats, LocStats.VarLocStats, IsParam,
-                    IsLocalVar);
+                    IsVariable);
     // Non debug entry values coverage statistics.
     collectLocStats(BytesCovered - BytesEntryValuesCovered, BytesInScope,
                     LocStats.VarParamNonEntryValLocStats,
                     LocStats.ParamNonEntryValLocStats,
-                    LocStats.VarNonEntryValLocStats, IsParam, IsLocalVar);
+                    LocStats.VarNonEntryValLocStats, IsParam, IsVariable);
   }
 
   // Collect PC range coverage data.
   if (DWARFDie D =
           Die.getAttributeValueAsReferencedDie(dwarf::DW_AT_abstract_origin))
     Die = D;
 
   std::string VarID = constructDieID(Die, VarPrefix);
   FnStats.VarsInFunction.insert(VarID);
 
   if (BytesInScope) {
     FnStats.TotalVarWithLoc += (unsigned)HasLoc;
     // Turns out we have a lot of ranges that extend past the lexical scope.
     GlobalStats.ScopeBytesCovered += std::min(BytesInScope, BytesCovered);
     GlobalStats.ScopeBytes += BytesInScope;
     GlobalStats.ScopeEntryValueBytesCovered += BytesEntryValuesCovered;
     if (IsParam) {
       GlobalStats.ParamScopeBytesCovered +=
           std::min(BytesInScope, BytesCovered);
       GlobalStats.ParamScopeBytes += BytesInScope;
       GlobalStats.ParamScopeEntryValueBytesCovered += BytesEntryValuesCovered;
-    } else if (IsLocalVar) {
+    } else if (IsVariable) {
       GlobalStats.VarScopeBytesCovered += std::min(BytesInScope, BytesCovered);
       GlobalStats.VarScopeBytes += BytesInScope;
       GlobalStats.VarScopeEntryValueBytesCovered += BytesEntryValuesCovered;
     }
     assert(GlobalStats.ScopeBytesCovered <= GlobalStats.ScopeBytes);
   } else if (Die.getTag() == dwarf::DW_TAG_member) {
     FnStats.ConstantMembers++;
   } else {
     FnStats.TotalVarWithLoc += (unsigned)HasLoc;
   }
   if (!IsArtificial) {
     if (IsParam) {
       FnStats.NumParams++;
       if (HasType)
         FnStats.NumParamTypes++;
       if (HasSrcLoc)
         FnStats.NumParamSourceLocations++;
       if (HasLoc)
         FnStats.NumParamLocations++;
-    } else if (IsLocalVar) {
+    } else if (IsVariable) {
       FnStats.NumVars++;
       if (HasType)
         FnStats.NumVarTypes++;
       if (HasSrcLoc)
         FnStats.NumVarSourceLocations++;
       if (HasLoc)
         FnStats.NumVarLocations++;
     }