[DebugInfo] Prepare debug information of labels in DebugHandlerBase.

[HsiangKai]

Summary

DebugHandlerBase is a child class of AsmPrinterHandler. It is the parent
class of DwarfDebug and CodeViewDebug, it depends on which debug format
you want to generate. DwarfDebug will generate DWARF format debug info
through AsmPrinter.

Before DwarfDebug generate DWARF format finally, DebugHandlerBase need to
collect label information from MI listing first. This patch collects
mappings of DILabel to (DILocation, MachineInstr) from DBG_LABEL MI.
We record DBG_LABEL MI in the mapping due to the MCSymbol is not ready as
collecting the mappings in DebugHandlerBase::beginFunction().

lib/CodeGen/AsmPrinter/DebugHandlerBase.h

struct DbgVariableLocation {
   /// This will only work if Instruction is a debug value instruction
   /// and the associated DIExpression is in one of the supported forms.
   /// If these requirements are not met, the returned Optional will not
   /// have a value.
   static Optional<DbgVariableLocation>
   extractFromMachineInstruction(const MachineInstr &Instruction);
 };
 
+typedef std::pair<const DILocation *, const MachineInstr *> LabelInfo;
+typedef std::pair<const DILabel *, LabelInfo> InlinedLabel;
+typedef SmallVector<InlinedLabel, 4> DbgLabelList;
+
 /// Base class for debug information backends. Common functionality related to
 /// tracking which variables and scopes are alive at a given PC live here.
 class DebugHandlerBase : public AsmPrinterHandler {
 protected:
   DebugHandlerBase(AsmPrinter *A);
 
   /// Target of debug info emission.
   AsmPrinter *Asm;
protected:
   const MachineInstr *CurMI = nullptr;
 
   LexicalScopes LScopes;
 
   /// History of DBG_VALUE and clobber instructions for each user
   /// variable.  Variables are listed in order of appearance.
   DbgValueHistoryMap DbgValues;
 
+  /// Labels are listed in order of appearance.
+  DbgLabelList DbgLabels;
+
   /// Maps instruction with label emitted before instruction.
   /// FIXME: Make this private from DwarfDebug, we have the necessary accessors
   /// for it.
   DenseMap<const MachineInstr *, MCSymbol *> LabelsBeforeInsn;
 
   /// Maps instruction with label emitted after instruction.
   DenseMap<const MachineInstr *, MCSymbol *> LabelsAfterInsn;
 
   /// Indentify instructions that are marking the beginning of or
   /// ending of a scope.
   void identifyScopeMarkers();
 
   /// Ensure that a label will be emitted before MI.
   void requestLabelBeforeInsn(const MachineInstr *MI) {
     LabelsBeforeInsn.insert(std::make_pair(MI, nullptr));
   }
 
   /// Ensure that a label will be emitted after MI.
   void requestLabelAfterInsn(const MachineInstr *MI) {
     LabelsAfterInsn.insert(std::make_pair(MI, nullptr));
   }
 
+  void collectDbgLabel(const MachineFunction *MF, DbgLabelList &Result);
+
   virtual void beginFunctionImpl(const MachineFunction *MF) = 0;
   virtual void endFunctionImpl(const MachineFunction *MF) = 0;
   virtual void skippedNonDebugFunction() {}
 
   // AsmPrinterHandler overrides.
 public:
   void beginInstruction(const MachineInstr *MI) override;
   void endInstruction() override;

lib/CodeGen/AsmPrinter/DebugHandlerBase.cpp

if (!SP)
     return false;
   assert(SP->getUnit());
   auto EK = SP->getUnit()->getEmissionKind();
   if (EK == DICompileUnit::NoDebug)
     return false;
   return true;
 }
 
+void DebugHandlerBase::collectDbgLabel(const MachineFunction *MF,
+                                       DbgLabelList &Result) {
+  for (const auto &MBB : *MF) {
+    for (const auto &MI : MBB) {
+      if (MI.isDebugLabel()) {
+        assert(MI.getNumOperands() == 1 && "Invalid DBG_LABEL instruction!");
+        const DILabel *RawLabel = MI.getDebugLabel();
+        assert(RawLabel->isValidLocationForIntrinsic(MI.getDebugLoc()) &&
+               "Expected inlined-at fields to agree");
+        requestLabelBeforeInsn(&MI);
+        Result.push_back(std::make_pair(RawLabel,
+                           std::make_pair(MI.getDebugLoc()->getInlinedAt(),
+                        &MI)));
+      }
+    }
+  }
+}
+
 void DebugHandlerBase::beginFunction(const MachineFunction *MF) {
   PrevInstBB = nullptr;
 
   if (!Asm || !hasDebugInfo(MMI, MF)) {
     skippedNonDebugFunction();
     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()) {
     beginFunctionImpl(MF);
     return;
   }
 
   // Make sure that each lexical scope will have a begin/end label.
   identifyScopeMarkers();
 
   // Calculate history for local variables.
   assert(DbgValues.empty() && "DbgValues map wasn't cleaned!");
   calculateDbgValueHistory(MF, Asm->MF->getSubtarget().getRegisterInfo(),
                            DbgValues);
 
+  // Collect local labels.
+  collectDbgLabel(MF, DbgLabels);
+
   // Request labels for the full history.
   for (const auto &I : DbgValues) {
     const auto &Ranges = I.second;
     if (Ranges.empty())
       continue;
 
     // The first mention of a function argument gets the CurrentFnBegin
     // label, so arguments are visible when breaking at function entry.