Use a single data structure to store all user variables in DwarfDebug

[samsonov]

Summary

Get rid of UserVariables set, and turn DbgValues into MapVector
to get a fixed ordering, as suggested in review for http://reviews.llvm.org/D3573.

[dblaikie]

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1207

You can probably push DIVariable DV(Var) up to DIVariable DV(I.first) and Processed.count(DV) (I think the implicit conversion to MDNode* will work out here). Just to avoid having that raw MDNode* lying around.

Not necessary, up to you if you want to do it at all and either in this commit or separately.

1453

Looks great & makes a lot more sense to me now.

[samsonov]

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1207

Done.

lib/CodeGen/AsmPrinter/DbgValueHistoryCalculator.h

 //===-- llvm/CodeGen/AsmPrinter/DbgValueHistoryCalculator.h ----*- C++ -*--===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef CODEGEN_ASMPRINTER_DBGVALUEHISTORYCALCULATOR_H_
 #define CODEGEN_ASMPRINTER_DBGVALUEHISTORYCALCULATOR_H_
 
-#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/SmallVector.h"
 
 namespace llvm {
 
 class MachineFunction;
 class MachineInstr;
 class MDNode;
 class TargetRegisterInfo;
 
 // For each user variable, keep a list of DBG_VALUE instructions in order.
 // The list can also contain normal instructions that clobber the previous
-// DBG_VALUE.
-typedef DenseMap<const MDNode *, SmallVector<const MachineInstr *, 4>>
+// DBG_VALUE. The variables are listed in order of appearance.
+typedef MapVector<const MDNode *, SmallVector<const MachineInstr *, 4>>
 DbgValueHistoryMap;
 
 void calculateDbgValueHistory(const MachineFunction *MF,
                               const TargetRegisterInfo *TRI,
                               DbgValueHistoryMap &Result);
 }
 
 #endif

lib/CodeGen/AsmPrinter/DwarfDebug.h

class DwarfDebug : public AsmPrinterHandler {
   SmallPtrSet<const MDNode *, 16> ProcessedSPNodes;
 
   // Maps instruction with label emitted before instruction.
   DenseMap<const MachineInstr *, MCSymbol *> LabelsBeforeInsn;
 
   // Maps instruction with label emitted after instruction.
   DenseMap<const MachineInstr *, MCSymbol *> LabelsAfterInsn;
 
-  // Every user variable mentioned by a DBG_VALUE instruction in order of
-  // appearance.
-  SmallVector<const MDNode *, 8> UserVariables;
-
   // History of DBG_VALUE and clobber instructions for each user variable.
+  // Variables are listed in order of appearance.
   DbgValueHistoryMap DbgValues;
 
   // Previous instruction's location information. This is used to determine
   // label location to indicate scope boundries in dwarf debug info.
   DebugLoc PrevInstLoc;
   MCSymbol *PrevLabel;
 
   // This location indicates end of function prologue and beginning of function

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

 void
 DwarfDebug::collectVariableInfo(SmallPtrSet<const MDNode *, 16> &Processed) {
   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
   DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
 
   // Grab the variable info that was squirreled away in the MMI side-table.
   collectVariableInfoFromMMITable(Processed);
 
-  for (const MDNode *Var : UserVariables) {
+  for (const auto &I : DbgValues) {
+    const MDNode *Var = I.first;
     if (Processed.count(Var))
       continue;
 
     // History contains relevant DBG_VALUE instructions for Var and instructions
     // clobbering it.
-    SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
+    const SmallVectorImpl<const MachineInstr *> &History = I.second;
     if (History.empty())
       continue;
     const MachineInstr *MInsn = History.front();
 
     DIVariable DV(Var);
     LexicalScope *Scope = nullptr;
     if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
         DISubprogram(DV.getContext()).describes(CurFn->getFunction()))
       Scope = LScopes.getCurrentFunctionScope();
     else if (MDNode *IA = DV.getInlinedAt())
       Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
     else
       Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
if (!MMI->hasDebugInfo())
     return;
 
   // Grab the lexical scopes for the function, if we don't have any of those
   // then we're not going to be able to do anything.
   LScopes.initialize(*MF);
   if (LScopes.empty())
     return;
 
-  assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
+  assert(DbgValues.empty() && "DbgValues map wasn't cleaned!");
 
   // Make sure that each lexical scope will have a begin/end label.
   identifyScopeMarkers();
 
   // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
   // belongs to so that we add to the correct per-cu line table in the
   // non-asm case.
   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
void DwarfDebug::beginFunction(const MachineFunction *MF) {
   // Assumes in correct section after the entry point.
   Asm->OutStreamer.EmitLabel(FunctionBeginSym);
 
   // Collect user variables, find the end of the prologue.
   for (const auto &MBB : *MF) {
     for (const auto &MI : MBB) {
       if (MI.isDebugValue()) {
         assert(MI.getNumOperands() > 1 && "Invalid machine instruction!");
-        // Keep track of user variables in order of appearance. Store the set
-        // of variables we've already seen as a set of keys in DbgValues.
+        // Keep track of user variables in order of appearance. Create the
+        // empty history for each variable so that the order of keys in
+        // DbgValues is correct. Actual history will be populated in
+        // calculateDbgValueHistory() function.
         const MDNode *Var = MI.getDebugVariable();
-        auto IterPair = DbgValues.insert(
+        DbgValues.insert(
             std::make_pair(Var, SmallVector<const MachineInstr *, 4>()));
-        if (IterPair.second)
-          UserVariables.push_back(Var);
       } else if (!MI.getFlag(MachineInstr::FrameSetup) &&
                  PrologEndLoc.isUnknown() && !MI.getDebugLoc().isUnknown()) {
         // First known non-DBG_VALUE and non-frame setup location marks
         // the beginning of the function body.
         PrologEndLoc = MI.getDebugLoc();
       }
     }
   }
void DwarfDebug::endFunction(const MachineFunction *MF) {
   PrevSection = Asm->getCurrentSection();
   PrevCU = &TheCU;
 
   // Clear debug info
   for (auto &I : ScopeVariables)
     DeleteContainerPointers(I.second);
   ScopeVariables.clear();
   DeleteContainerPointers(CurrentFnArguments);
-  UserVariables.clear();
   DbgValues.clear();
   AbstractVariables.clear();
   LabelsBeforeInsn.clear();
   LabelsAfterInsn.clear();
   PrevLabel = nullptr;
   CurFn = nullptr;
 }