[DWARF] Support emitting AdvanceLineAddrAbs

llvm/include/llvm/MC/MCContext.h

public:
     }
 
     /// Saves the information from the currently parsed dwarf .loc directive
     /// and sets DwarfLocSeen.  When the next instruction is assembled an entry
     /// in the line number table with this information and the address of the
     /// instruction will be created.
     void setCurrentDwarfLoc(unsigned FileNum, unsigned Line, unsigned Column,
                             unsigned Flags, unsigned Isa,
-                            unsigned Discriminator) {
+                            unsigned Discriminator, uint64_t Addr = -1ULL) {
       CurrentDwarfLoc.setFileNum(FileNum);
       CurrentDwarfLoc.setLine(Line);
       CurrentDwarfLoc.setColumn(Column);
       CurrentDwarfLoc.setFlags(Flags);
       CurrentDwarfLoc.setIsa(Isa);
       CurrentDwarfLoc.setDiscriminator(Discriminator);
+      CurrentDwarfLoc.setAbsoluteAddr(Addr);
       DwarfLocSeen = true;
     }
 
     void clearDwarfLocSeen() { DwarfLocSeen = false; }
 
     bool getDwarfLocSeen() { return DwarfLocSeen; }
     const MCDwarfLoc &getCurrentDwarfLoc() { return CurrentDwarfLoc; }
 

llvm/include/llvm/MC/MCDwarf.h

 class MCDwarfLoc {
   uint32_t FileNum;
   uint32_t Line;
   uint16_t Column;
   // Flags (see #define's below)
   uint8_t Flags;
   uint8_t Isa;
   uint32_t Discriminator;
+  uint64_t AbsoluteAddr;
 
 // Flag that indicates the initial value of the is_stmt_start flag.
 #define DWARF2_LINE_DEFAULT_IS_STMT 1
 
 #define DWARF2_FLAG_IS_STMT (1 << 0)
 #define DWARF2_FLAG_BASIC_BLOCK (1 << 1)
 #define DWARF2_FLAG_PROLOGUE_END (1 << 2)
 #define DWARF2_FLAG_EPILOGUE_BEGIN (1 << 3)
 
 private: // MCContext manages these
   friend class MCContext;
   friend class MCDwarfLineEntry;
 
   MCDwarfLoc(unsigned fileNum, unsigned line, unsigned column, unsigned flags,
-             unsigned isa, unsigned discriminator)
+             unsigned isa, unsigned discriminator, uint64_t addr=-1ULL)
       : FileNum(fileNum), Line(line), Column(column), Flags(flags), Isa(isa),
-        Discriminator(discriminator) {}
+        Discriminator(discriminator), AbsoluteAddr(addr) {}
 
   // Allow the default copy constructor and assignment operator to be used
   // for an MCDwarfLoc object.
 
 public:
+  /// \brief Get the AbsoluteAddr of this MCDwarfLoc.
+  uint64_t getAbsoluteAddr() const { return AbsoluteAddr; }
+
   /// Get the FileNum of this MCDwarfLoc.
   unsigned getFileNum() const { return FileNum; }
 
   /// Get the Line of this MCDwarfLoc.
   unsigned getLine() const { return Line; }
 
   /// Get the Column of this MCDwarfLoc.
   unsigned getColumn() const { return Column; }
void setIsa(unsigned isa) {
     assert(isa <= UINT8_MAX);
     Isa = isa;
   }
 
   /// Set the Discriminator of this MCDwarfLoc.
   void setDiscriminator(unsigned discriminator) {
     Discriminator = discriminator;
   }
+
+  /// \brief Set the AbsoluteAddr of this MCDwarfLoc.
+  void setAbsoluteAddr(uint64_t addr) {
+    AbsoluteAddr = addr;
+  }
 };
 
 /// Instances of this class represent the line information for
 /// the dwarf line table entries.  Which is created after a machine
 /// instruction is assembled and uses an address from a temporary label
 /// created at the current address in the current section and the info from
 /// the last .loc directive seen as stored in the context.
 class MCDwarfLineEntry : public MCDwarfLoc {

llvm/include/llvm/MC/MCObjectStreamer.h

public:
   void emitDwarfLocDirective(unsigned FileNo, unsigned Line, unsigned Column,
                              unsigned Flags, unsigned Isa,
                              unsigned Discriminator,
                              StringRef FileName) override;
   void emitDwarfAdvanceLineAddr(int64_t LineDelta, const MCSymbol *LastLabel,
                                 const MCSymbol *Label,
                                 unsigned PointerSize) override;
   void emitDwarfLineEndEntry(MCSection *Section, MCSymbol *LastLabel) override;
+  void emitDwarfAdvanceLineAddrAbs(int64_t LineDelta, uint64_t Address,
+                                   uint64_t AddressDelta,
+                                   unsigned PointerSize) override;
   void emitDwarfAdvanceFrameAddr(const MCSymbol *LastLabel,
                                  const MCSymbol *Label);
   void emitCVLocDirective(unsigned FunctionId, unsigned FileNo, unsigned Line,
                           unsigned Column, bool PrologueEnd, bool IsStmt,
                           StringRef FileName, SMLoc Loc) override;
   void emitCVLinetableDirective(unsigned FunctionId, const MCSymbol *Begin,
                                 const MCSymbol *End) override;
   void emitCVInlineLinetableDirective(unsigned PrimaryFunctionId,

llvm/include/llvm/MC/MCStreamer.h

public:
   /// If targets does not support representing debug line section by .loc/.file
   /// directives in assembly output, we need to populate debug line section with
   /// raw debug line contents.
   virtual void emitDwarfAdvanceLineAddr(int64_t LineDelta,
                                         const MCSymbol *LastLabel,
                                         const MCSymbol *Label,
                                         unsigned PointerSize) {}
 
+  virtual void emitDwarfAdvanceLineAddrAbs(int64_t LineDelta, uint64_t Address,
+                                           uint64_t AddressDelta,
+                                           unsigned PointerSize) {}
+
   /// Do finalization for the streamer at the end of a section.
   virtual void doFinalizationAtSectionEnd(MCSection *Section) {}
 };
 
 /// Create a dummy machine code streamer, which does nothing. This is useful for
 /// timing the assembler front end.
 MCStreamer *createNullStreamer(MCContext &Ctx);
 
 } // end namespace llvm
 
 #endif // LLVM_MC_MCSTREAMER_H

llvm/lib/MC/MCDwarf.cpp

static inline void emitDwarfLineTable(
     MCStreamer *MCOS, MCSection *Section,
     const MCLineSection::MCDwarfLineEntryCollection &LineEntries) {
   unsigned FileNum = 1;
   unsigned LastLine = 1;
   unsigned Column = 0;
   unsigned Flags = DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_IS_STMT : 0;
   unsigned Isa = 0;
   unsigned Discriminator = 0;
+  uint64_t LastAddress = -1ULL;
   MCSymbol *LastLabel = nullptr;
+  const MCAsmInfo *AsmInfo = MCOS->getContext().getAsmInfo();
 
   // Loop through each MCDwarfLineEntry and encode the dwarf line number table.
-  for (const MCDwarfLineEntry &LineEntry : LineEntries) {
+  for (auto it = LineEntries.begin(),
+            ie = LineEntries.end();
+       it != ie; ++it) {
+    const MCDwarfLineEntry &LineEntry = *it;
     int64_t LineDelta = static_cast<int64_t>(LineEntry.getLine()) - LastLine;
 
+    const uint64_t Address = LineEntry.getAbsoluteAddr();
+    if (Address != -1ULL && std::next(it) == ie) {
+      // If emitting absolute addresses, the last entry only carries address
+      // info for the DW_LNE_end_sequence. This entry compensates for the lack
+      // of the section context used to emit the end of section label.
+      MCOS->emitDwarfAdvanceLineAddrAbs(INT64_MAX, -1ULL, Address - LastAddress,
+                                        AsmInfo->getCodePointerSize());
+      return;
+    }
+
     if (FileNum != LineEntry.getFileNum()) {
       FileNum = LineEntry.getFileNum();
       MCOS->emitInt8(dwarf::DW_LNS_set_file);
       MCOS->emitULEB128IntValue(FileNum);
     }
     if (Column != LineEntry.getColumn()) {
       Column = LineEntry.getColumn();
       MCOS->emitInt8(dwarf::DW_LNS_set_column);
for (auto it = LineEntries.begin(),
     }
     if (LineEntry.getFlags() & DWARF2_FLAG_BASIC_BLOCK)
       MCOS->emitInt8(dwarf::DW_LNS_set_basic_block);
     if (LineEntry.getFlags() & DWARF2_FLAG_PROLOGUE_END)
       MCOS->emitInt8(dwarf::DW_LNS_set_prologue_end);
     if (LineEntry.getFlags() & DWARF2_FLAG_EPILOGUE_BEGIN)
       MCOS->emitInt8(dwarf::DW_LNS_set_epilogue_begin);
 
+    if (Address == -1ULL) {
+      assert(LastAddress == -1ULL &&
+             "Absolute addresses can only be added at the end of the table.");
+
       MCSymbol *Label = LineEntry.getLabel();
 
-    // At this point we want to emit/create the sequence to encode the delta in
-    // line numbers and the increment of the address from the previous Label
-    // and the current Label.
-    const MCAsmInfo *asmInfo = MCOS->getContext().getAsmInfo();
+      // At this point we want to emit/create the sequence to encode the delta
+      // in line numbers and the increment of the address from the previous
+      // Label and the current Label.
       MCOS->emitDwarfAdvanceLineAddr(LineDelta, LastLabel, Label,
-                                   asmInfo->getCodePointerSize());
+                                     AsmInfo->getCodePointerSize());
+      LastLabel = Label;
+      LastAddress = -1ULL;
+    } else {
+      if (LastAddress == -1ULL) {
+        MCOS->emitDwarfAdvanceLineAddrAbs(LineDelta, Address, 0,
+                                          AsmInfo->getCodePointerSize());
+      } else {
+        MCOS->emitDwarfAdvanceLineAddrAbs(LineDelta, -1ULL,
+                                          Address - LastAddress,
+                                          AsmInfo->getCodePointerSize());
+      }
+      LastAddress = Address;
+      LastLabel = nullptr;
+    }
 
     Discriminator = 0;
     LastLine = LineEntry.getLine();
-    LastLabel = Label;
   }
 
   // Generate DWARF line end entry.
   MCOS->emitDwarfLineEndEntry(Section, LastLabel);
 }
 
 //
 // This emits the Dwarf file and the line tables.

llvm/lib/MC/MCObjectStreamer.cpp

static const MCExpr *buildSymbolDiff(MCObjectStreamer &OS, const MCSymbol *A,
   MCSymbolRefExpr::VariantKind Variant = MCSymbolRefExpr::VK_None;
   const MCExpr *ARef = MCSymbolRefExpr::create(A, Variant, Context);
   const MCExpr *BRef = MCSymbolRefExpr::create(B, Variant, Context);
   const MCExpr *AddrDelta =
       MCBinaryExpr::create(MCBinaryExpr::Sub, ARef, BRef, Context);
   return AddrDelta;
 }
 
+static void emitDwarfSetLineAddrAbs(MCObjectStreamer &OS,
+                                    MCDwarfLineTableParams Params,
+                                    int64_t LineDelta, uint64_t Address,
+                                    int PointerSize) {
+  // emit the sequence to set the address
+  OS.emitIntValue(dwarf::DW_LNS_extended_op, 1);
+  OS.emitULEB128IntValue(PointerSize + 1);
+  OS.emitIntValue(dwarf::DW_LNE_set_address, 1);
+  OS.emitIntValue(Address, PointerSize);
+
+  // emit the sequence for the LineDelta (from 1) and a zero address delta.
+  MCDwarfLineAddr::Emit(&OS, Params, LineDelta, 0);
+}
+
+void MCObjectStreamer::emitDwarfAdvanceLineAddrAbs(int64_t LineDelta,
+                                                   uint64_t Address,
+                                                   uint64_t AddressDelta,
+                                                   unsigned PointerSize) {
+  if (Address != -1ULL) {
+    emitDwarfSetLineAddrAbs(*this, Assembler->getDWARFLinetableParams(),
+                            LineDelta, Address, PointerSize);
+    return;
+  }
+  MCDwarfLineAddr::Emit(this, Assembler->getDWARFLinetableParams(), LineDelta,
+                        AddressDelta);
+}
+
 static void emitDwarfSetLineAddr(MCObjectStreamer &OS,
                                  MCDwarfLineTableParams Params,
                                  int64_t LineDelta, const MCSymbol *Label,
                                  int PointerSize) {
   // emit the sequence to set the address
   OS.emitIntValue(dwarf::DW_LNS_extended_op, 1);
   OS.emitULEB128IntValue(PointerSize + 1);
   OS.emitIntValue(dwarf::DW_LNE_set_address, 1);