1 #include "llvm/ADT/DenseMap.h"
2 #include "llvm/DebugInfo/DIContext.h"
3 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
4 #include "llvm/DebugInfo/DWARF/DWARFDebugLoc.h"
5 #include "llvm/Object/ObjectFile.h"
6 
7 #define DEBUG_TYPE "dwarfdump"
8 using namespace llvm;
9 using namespace object;
10 
11 /// Holds statistics for one function (or other entity that has a PC range and
12 /// contains variables, such as a compile unit).
13 struct PerFunctionStats {
14   /// Number of inlined instances of this function.
15   unsigned NumFnInlined = 0;
16   /// Number of variables with location across all inlined instances.
17   unsigned TotalVarWithLoc = 0;
18   /// Number of constants with location across all inlined instances.
19   unsigned ConstantMembers = 0;
20   /// List of all Variables in this function.
21   SmallDenseSet<uint32_t, 4> VarsInFunction;
22   /// Compile units also cover a PC range, but have this flag set to false.
23   bool IsFunction = false;
24 };
25 
26 /// Holds accumulated global statistics about local variables.
27 struct GlobalStats {
28   /// Total number of PC range bytes covered by DW_AT_locations.
29   unsigned ScopeBytesCovered = 0;
30   /// Total number of PC range bytes in each variable's enclosing scope,
31   /// starting from the first definition of the variable.
32   unsigned ScopeBytesFromFirstDefinition = 0;
33 };
34 
35 /// Extract the low pc from a Die.
36 static uint64_t getLowPC(DWARFDie Die) {
37   auto RangesOrError = Die.getAddressRanges();
38   DWARFAddressRangesVector Ranges;
39   if (RangesOrError)
40     Ranges = RangesOrError.get();
41   else
42     llvm::consumeError(RangesOrError.takeError());
43   if (Ranges.size())
44     return Ranges[0].LowPC;
45   return dwarf::toAddress(Die.find(dwarf::DW_AT_low_pc), 0);
46 }
47 
48 /// Collect debug info quality metrics for one DIE.
49 static void collectStatsForDie(DWARFDie Die, std::string Prefix,
50                                uint64_t ScopeLowPC, uint64_t BytesInScope,
51                                StringMap<PerFunctionStats> &FnStatMap,
52                                GlobalStats &GlobalStats) {
53   bool HasLoc = false;
54   uint64_t BytesCovered = 0;
55   uint64_t OffsetToFirstDefinition = 0;
56   if (Die.find(dwarf::DW_AT_const_value)) {
57     // This catches constant members *and* variables.
58     HasLoc = true;
59     BytesCovered = BytesInScope;
60   } else if (Die.getTag() == dwarf::DW_TAG_variable ||
61              Die.getTag() == dwarf::DW_TAG_formal_parameter) {
62     // Handle variables and function arguments.
63     auto FormValue = Die.find(dwarf::DW_AT_location);
64     HasLoc = FormValue.hasValue();
65     if (HasLoc) {
66       // Get PC coverage.
67       if (auto DebugLocOffset = FormValue->getAsSectionOffset()) {
68         auto *DebugLoc = Die.getDwarfUnit()->getContext().getDebugLoc();
69         if (auto List = DebugLoc->getLocationListAtOffset(*DebugLocOffset)) {
70           for (auto Entry : List->Entries)
71             BytesCovered += Entry.End - Entry.Begin;
72           if (List->Entries.size()) {
73             uint64_t FirstDef = List->Entries[0].Begin;
74             uint64_t UnitOfs = getLowPC(Die.getDwarfUnit()->getUnitDIE());
75             // Ranges sometimes start before the lexical scope.
76             if (UnitOfs + FirstDef >= ScopeLowPC)
77               OffsetToFirstDefinition = UnitOfs + FirstDef - ScopeLowPC;
78             // Or even after it. Count that as a failure.
79             if (OffsetToFirstDefinition > BytesInScope)
80               OffsetToFirstDefinition = 0;
81           }
82         }
83         assert(BytesInScope);
84       } else {
85         // Assume the entire range is covered by a single location.
86         BytesCovered = BytesInScope;
87       }
88     }
89   } else {
90     // Not a variable or constant member.
91     return;
92   }
93 
94   // Collect PC range coverage data.
95   auto &FnStats = FnStatMap[Prefix];
96   if (DWARFDie D =
97           Die.getAttributeValueAsReferencedDie(dwarf::DW_AT_abstract_origin))
98     Die = D;
99   // This is a unique ID for the variable inside the current object file.
100   unsigned CanonicalDieOffset = Die.getOffset();
101   FnStats.VarsInFunction.insert(CanonicalDieOffset);
102   if (BytesInScope) {
103     FnStats.TotalVarWithLoc += (unsigned)HasLoc;
104     // Adjust for the fact the variables often start their lifetime in the
105     // middle of the scope.
106     BytesInScope -= OffsetToFirstDefinition;
107     // Turns out we have a lot of ranges that extend past the lexical scope.
108     GlobalStats.ScopeBytesCovered += std::min(BytesInScope, BytesCovered);
109     GlobalStats.ScopeBytesFromFirstDefinition += BytesInScope;
110     assert(GlobalStats.ScopeBytesCovered <=
111            GlobalStats.ScopeBytesFromFirstDefinition);
112   } else {
113     FnStats.ConstantMembers++;
114   }
115 }
116 
117 /// Recursively collect debug info quality metrics.
118 static void collectStatsRecursive(DWARFDie Die, std::string Prefix,
119                                   uint64_t ScopeLowPC, uint64_t BytesInScope,
120                                   StringMap<PerFunctionStats> &FnStatMap,
121                                   GlobalStats &GlobalStats) {
122   // Handle any kind of lexical scope.
123   if (Die.getTag() == dwarf::DW_TAG_subprogram ||
124       Die.getTag() == dwarf::DW_TAG_inlined_subroutine ||
125       Die.getTag() == dwarf::DW_TAG_lexical_block) {
126     // Ignore forward declarations.
127     if (Die.find(dwarf::DW_AT_declaration))
128       return;
129 
130     // Count the function.
131     if (Die.getTag() != dwarf::DW_TAG_lexical_block) {
132       StringRef Name = Die.getName(DINameKind::LinkageName);
133       if (Name.empty())
134         Name = Die.getName(DINameKind::ShortName);
135       Prefix = Name;
136       // Skip over abstract origins.
137       if (Die.find(dwarf::DW_AT_inline))
138         return;
139       // We've seen an (inlined) instance of this function.
140       auto &FnStats = FnStatMap[Name];
141       FnStats.NumFnInlined++;
142       FnStats.IsFunction = true;
143     }
144 
145     // PC Ranges.
146     auto RangesOrError = Die.getAddressRanges();
147     if (!RangesOrError) {
148       llvm::consumeError(RangesOrError.takeError());
149       return;
150     }
151 
152     auto Ranges = RangesOrError.get();
153     uint64_t BytesInThisScope = 0;
154     for (auto Range : Ranges)
155       BytesInThisScope += Range.HighPC - Range.LowPC;
156     ScopeLowPC = getLowPC(Die);
157 
158     if (BytesInThisScope)
159       BytesInScope = BytesInThisScope;
160   } else {
161     // Not a scope, visit the Die itself. It could be a variable.
162     collectStatsForDie(Die, Prefix, ScopeLowPC, BytesInScope, FnStatMap,
163                        GlobalStats);
164   }
165 
166   // Traverse children.
167   DWARFDie Child = Die.getFirstChild();
168   while (Child) {
169     collectStatsRecursive(Child, Prefix, ScopeLowPC, BytesInScope, FnStatMap,
170                           GlobalStats);
171     Child = Child.getSibling();
172   }
173 }
174 
175 /// Print machine-readable output.
176 /// The machine-readable format is single-line JSON output.
177 /// \{
178 static void printDatum(raw_ostream &OS, const char *Key, StringRef Value) {
179   OS << ",\"" << Key << "\":\"" << Value << '"';
180   LLVM_DEBUG(llvm::dbgs() << Key << ": " << Value << '\n');
181 }
182 static void printDatum(raw_ostream &OS, const char *Key, uint64_t Value) {
183   OS << ",\"" << Key << "\":" << Value;
184   LLVM_DEBUG(llvm::dbgs() << Key << ": " << Value << '\n');
185 }
186 /// \}
187 
188 /// Collect debug info quality metrics for an entire DIContext.
189 ///
190 /// Do the impossible and reduce the quality of the debug info down to a few
191 /// numbers. The idea is to condense the data into numbers that can be tracked
192 /// over time to identify trends in newer compiler versions and gauge the effect
193 /// of particular optimizations. The raw numbers themselves are not particularly
194 /// useful, only the delta between compiling the same program with different
195 /// compilers is.
196 bool collectStatsForObjectFile(ObjectFile &Obj, DWARFContext &DICtx,
197                                Twine Filename, raw_ostream &OS) {
198   StringRef FormatName = Obj.getFileFormatName();
199   GlobalStats GlobalStats;
200   StringMap<PerFunctionStats> Statistics;
201   for (const auto &CU : static_cast<DWARFContext *>(&DICtx)->compile_units())
202     if (DWARFDie CUDie = CU->getUnitDIE(false))
203       collectStatsRecursive(CUDie, "/", 0, 0, Statistics, GlobalStats);
204 
205   /// The version number should be increased every time the algorithm is changed
206   /// (including bug fixes). New metrics may be added without increasing the
207   /// version.
208   unsigned Version = 1;
209   unsigned VarTotal = 0;
210   unsigned VarUnique = 0;
211   unsigned VarWithLoc = 0;
212   unsigned NumFunctions = 0;
213   unsigned NumInlinedFunctions = 0;
214   for (auto &Entry : Statistics) {
215     PerFunctionStats &Stats = Entry.getValue();
216     unsigned TotalVars = Stats.VarsInFunction.size() * Stats.NumFnInlined;
217     unsigned Constants = Stats.ConstantMembers;
218     VarWithLoc += Stats.TotalVarWithLoc + Constants;
219     VarTotal += TotalVars + Constants;
220     VarUnique += Stats.VarsInFunction.size();
221     LLVM_DEBUG(for (auto V
222                     : Stats.VarsInFunction) llvm::dbgs()
223                << Entry.getKey() << ": " << V << "\n");
224     NumFunctions += Stats.IsFunction;
225     NumInlinedFunctions += Stats.IsFunction * Stats.NumFnInlined;
226   }
227 
228   // Print summary.
229   OS.SetBufferSize(1024);
230   OS << "{\"version\":\"" << Version << '"';
231   LLVM_DEBUG(llvm::dbgs() << "Variable location quality metrics\n";
232              llvm::dbgs() << "---------------------------------\n");
233   printDatum(OS, "file", Filename.str());
234   printDatum(OS, "format", FormatName);
235   printDatum(OS, "source functions", NumFunctions);
236   printDatum(OS, "inlined functions", NumInlinedFunctions);
237   printDatum(OS, "unique source variables", VarUnique);
238   printDatum(OS, "source variables", VarTotal);
239   printDatum(OS, "variables with location", VarWithLoc);
240   printDatum(OS, "scope bytes total",
241              GlobalStats.ScopeBytesFromFirstDefinition);
242   printDatum(OS, "scope bytes covered", GlobalStats.ScopeBytesCovered);
243   OS << "}\n";
244   LLVM_DEBUG(
245       llvm::dbgs() << "Total Availability: "
246                    << (int)std::round((VarWithLoc * 100.0) / VarTotal) << "%\n";
247       llvm::dbgs() << "PC Ranges covered: "
248                    << (int)std::round((GlobalStats.ScopeBytesCovered * 100.0) /
249                                       GlobalStats.ScopeBytesFromFirstDefinition)
250                    << "%\n");
251   return true;
252 }
253