[DebugInfo] Add new emitting methods for values which depend on the DWARF format (3/19).

[ikudrin]

Summary

These methods are going to be used in subsequent patches.

[dblaikie]

Might be too fine-grained, may be better off rolling this into whatever patch uses this functionality & testing it end-to-end there, rather than with a unit test? (unless there are cases that are especially hard to reach via the usual functional tests)

[ikudrin]

In D87010#2252619, @dblaikie wrote:

Might be too fine-grained, may be better off rolling this into whatever patch uses this functionality & testing it end-to-end there, rather than with a unit test? (unless there are cases that are especially hard to reach via the usual functional tests)

That is possible, but that would tie patches for independent tables closer than necessary. That would also make patches that introduce the functions less focused.

[dblaikie]

Looks good - thanks!

llvm/include/llvm/CodeGen/AsmPrinter.h

public:
   uint16_t getDwarfVersion() const;
   void setDwarfVersion(uint16_t Version);
 
   bool isDwarf64() const;
 
   /// Returns 4 for DWARF32 and 8 for DWARF64.
   unsigned int getDwarfOffsetByteSize() const;
 
+  /// Returns 4 for DWARF32 and 12 for DWARF64.
+  unsigned int getUnitLengthFieldByteSize() const;
+
   bool isPositionIndependent() const;
 
   /// Return true if assembly output should contain comments.
   bool isVerbose() const { return VerboseAsm; }
 
   /// Return a unique ID for the current function.
   unsigned getFunctionNumber() const;
 
public:
   void emitDwarfStringOffset(DwarfStringPoolEntryRef S) const {
     emitDwarfStringOffset(S.getEntry());
   }
 
   /// Emit something like ".long Label + Offset" or ".quad Label + Offset"
   /// depending on the DWARF format.
   void emitDwarfOffset(const MCSymbol *Label, uint64_t Offset) const;
 
+  /// Emit 32- or 64-bit value depending on the DWARF format.
+  void emitDwarfLengthOrOffset(uint64_t Value) const;
+
+  /// Emit a special value of 0xffffffff if producing 64-bit debugging info.
+  void maybeEmitDwarf64Mark() const;
+
+  /// Emit a unit length field. The actual format, DWARF32 or DWARF64, is chosen
+  /// according to the settings.
+  void emitDwarfUnitLength(uint64_t Length, const Twine &Comment) const;
+
+  /// Emit a unit length field. The actual format, DWARF32 or DWARF64, is chosen
+  /// according to the settings.
+  void emitDwarfUnitLength(const MCSymbol *Hi, const MCSymbol *Lo,
+                           const Twine &Comment) const;
+
   /// Emit reference to a call site with a specified encoding
   void emitCallSiteOffset(const MCSymbol *Hi, const MCSymbol *Lo,
                           unsigned Encoding) const;
   /// Emit an integer value corresponding to the call site encoding
   void emitCallSiteValue(uint64_t Value, unsigned Encoding) const;
 
   /// Get the value for DW_AT_APPLE_isa. Zero if no isa encoding specified.
   virtual unsigned getISAEncoding() { return 0; }

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

 bool AsmPrinter::isDwarf64() const {
   return OutStreamer->getContext().getDwarfFormat() == dwarf::DWARF64;
 }
 
 unsigned int AsmPrinter::getDwarfOffsetByteSize() const {
   return dwarf::getDwarfOffsetByteSize(
       OutStreamer->getContext().getDwarfFormat());
 }
+
+unsigned int AsmPrinter::getUnitLengthFieldByteSize() const {
+  return dwarf::getUnitLengthFieldByteSize(
+      OutStreamer->getContext().getDwarfFormat());
+}

llvm/lib/CodeGen/AsmPrinter/AsmPrinterDwarf.cpp

 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCSection.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/MachineLocation.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Target/TargetLoweringObjectFile.h"
 #include "llvm/Target/TargetMachine.h"
+#include <cstdint>
 using namespace llvm;
 
 #define DEBUG_TYPE "asm-printer"
 
 //===----------------------------------------------------------------------===//
 // Dwarf Emission Helper Routines
 //===----------------------------------------------------------------------===//
 
void AsmPrinter::emitDwarfStringOffset(DwarfStringPoolEntry S) const {
   // Just emit the offset directly; no need for symbol math.
   OutStreamer->emitIntValue(S.Offset, getDwarfOffsetByteSize());
 }
 
 void AsmPrinter::emitDwarfOffset(const MCSymbol *Label, uint64_t Offset) const {
   emitLabelPlusOffset(Label, Offset, getDwarfOffsetByteSize());
 }
 
+void AsmPrinter::emitDwarfLengthOrOffset(uint64_t Value) const {
+  assert(isDwarf64() || Value <= UINT32_MAX);
+  OutStreamer->emitIntValue(Value, getDwarfOffsetByteSize());
+}
+
+void AsmPrinter::maybeEmitDwarf64Mark() const {
+  if (!isDwarf64())
+    return;
+  OutStreamer->AddComment("DWARF64 Mark");
+  OutStreamer->emitInt32(dwarf::DW_LENGTH_DWARF64);
+}
+
+void AsmPrinter::emitDwarfUnitLength(uint64_t Length,
+                                     const Twine &Comment) const {
+  assert(isDwarf64() || Length <= dwarf::DW_LENGTH_lo_reserved);
+  maybeEmitDwarf64Mark();
+  OutStreamer->AddComment(Comment);
+  OutStreamer->emitIntValue(Length, getDwarfOffsetByteSize());
+}
+
+void AsmPrinter::emitDwarfUnitLength(const MCSymbol *Hi, const MCSymbol *Lo,
+                                     const Twine &Comment) const {
+  maybeEmitDwarf64Mark();
+  OutStreamer->AddComment(Comment);
+  OutStreamer->emitAbsoluteSymbolDiff(Hi, Lo, getDwarfOffsetByteSize());
+}
+
 void AsmPrinter::emitCallSiteOffset(const MCSymbol *Hi, const MCSymbol *Lo,
                                     unsigned Encoding) const {
   // The least significant 3 bits specify the width of the encoding
   if ((Encoding & 0x7) == dwarf::DW_EH_PE_uleb128)
     emitLabelDifferenceAsULEB128(Hi, Lo);
   else
     emitLabelDifference(Hi, Lo, GetSizeOfEncodedValue(Encoding));
 }

llvm/unittests/CodeGen/AsmPrinterDwarfTest.cpp

 //===- llvm/unittest/CodeGen/AsmPrinterDwarfTest.cpp ----------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "TestAsmPrinter.h"
 #include "llvm/CodeGen/AsmPrinter.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCSectionELF.h"
 #include "llvm/Testing/Support/Error.h"
 
 using namespace llvm;
 using testing::_;
+using testing::InSequence;
 using testing::SaveArg;
 
 namespace {
 
 class AsmPrinterFixtureBase : public testing::Test {
   void setupTestPrinter(const std::string &TripleStr, unsigned DwarfVersion,
                         dwarf::DwarfFormat DwarfFormat) {
     auto ExpectedTestPrinter =
TEST_F(AsmPrinterEmitDwarfOffsetTest, DWARF64) {
   EXPECT_EQ(&(ActualLHS->getSymbol()), Label);
 
   const MCConstantExpr *ActualRHS =
       dyn_cast_or_null<MCConstantExpr>(ActualArg0->getRHS());
   ASSERT_NE(ActualRHS, nullptr);
   EXPECT_EQ(static_cast<uint64_t>(ActualRHS->getValue()), Offset);
 }
 
+class AsmPrinterEmitDwarfLengthOrOffsetTest : public AsmPrinterFixtureBase {
+protected:
+  uint64_t Val = 42;
+};
+
+TEST_F(AsmPrinterEmitDwarfLengthOrOffsetTest, DWARF32) {
+  if (!init("x86_64-pc-linux", /*DwarfVersion=*/4, dwarf::DWARF32))
+    return;
+
+  EXPECT_CALL(TestPrinter->getMS(), emitIntValue(Val, 4));
+  TestPrinter->getAP()->emitDwarfLengthOrOffset(Val);
+}
+
+TEST_F(AsmPrinterEmitDwarfLengthOrOffsetTest, DWARF64) {
+  if (!init("x86_64-pc-linux", /*DwarfVersion=*/4, dwarf::DWARF64))
+    return;
+
+  EXPECT_CALL(TestPrinter->getMS(), emitIntValue(Val, 8));
+  TestPrinter->getAP()->emitDwarfLengthOrOffset(Val);
+}
+
+class AsmPrinterGetUnitLengthFieldByteSizeTest : public AsmPrinterFixtureBase {
+};
+
+TEST_F(AsmPrinterGetUnitLengthFieldByteSizeTest, DWARF32) {
+  if (!init("x86_64-pc-linux", /*DwarfVersion=*/4, dwarf::DWARF32))
+    return;
+
+  EXPECT_EQ(TestPrinter->getAP()->getUnitLengthFieldByteSize(), 4u);
+}
+
+TEST_F(AsmPrinterGetUnitLengthFieldByteSizeTest, DWARF64) {
+  if (!init("x86_64-pc-linux", /*DwarfVersion=*/4, dwarf::DWARF64))
+    return;
+
+  EXPECT_EQ(TestPrinter->getAP()->getUnitLengthFieldByteSize(), 12u);
+}
+
+class AsmPrinterMaybeEmitDwarf64MarkTest : public AsmPrinterFixtureBase {};
+
+TEST_F(AsmPrinterMaybeEmitDwarf64MarkTest, DWARF32) {
+  if (!init("x86_64-pc-linux", /*DwarfVersion=*/4, dwarf::DWARF32))
+    return;
+
+  EXPECT_CALL(TestPrinter->getMS(), emitIntValue(_, _)).Times(0);
+  TestPrinter->getAP()->maybeEmitDwarf64Mark();
+}
+
+TEST_F(AsmPrinterMaybeEmitDwarf64MarkTest, DWARF64) {
+  if (!init("x86_64-pc-linux", /*DwarfVersion=*/4, dwarf::DWARF64))
+    return;
+
+  EXPECT_CALL(TestPrinter->getMS(), emitIntValue(dwarf::DW_LENGTH_DWARF64, 4));
+  TestPrinter->getAP()->maybeEmitDwarf64Mark();
+}
+
+class AsmPrinterEmitDwarfUnitLengthAsIntTest : public AsmPrinterFixtureBase {
+protected:
+  uint64_t Val = 42;
+};
+
+TEST_F(AsmPrinterEmitDwarfUnitLengthAsIntTest, DWARF32) {
+  if (!init("x86_64-pc-linux", /*DwarfVersion=*/4, dwarf::DWARF32))
+    return;
+
+  EXPECT_CALL(TestPrinter->getMS(), emitIntValue(Val, 4));
+  TestPrinter->getAP()->emitDwarfUnitLength(Val, "");
+}
+
+TEST_F(AsmPrinterEmitDwarfUnitLengthAsIntTest, DWARF64) {
+  if (!init("x86_64-pc-linux", /*DwarfVersion=*/4, dwarf::DWARF64))
+    return;
+
+  InSequence S;
+  EXPECT_CALL(TestPrinter->getMS(), emitIntValue(dwarf::DW_LENGTH_DWARF64, 4));
+  EXPECT_CALL(TestPrinter->getMS(), emitIntValue(Val, 8));
+
+  TestPrinter->getAP()->emitDwarfUnitLength(Val, "");
+}
+
+class AsmPrinterEmitDwarfUnitLengthAsHiLoDiffTest
+    : public AsmPrinterFixtureBase {
+protected:
+  bool init(const std::string &TripleStr, unsigned DwarfVersion,
+            dwarf::DwarfFormat DwarfFormat) {
+    if (!AsmPrinterFixtureBase::init(TripleStr, DwarfVersion, DwarfFormat))
+      return false;
+
+    Hi = TestPrinter->getCtx().createTempSymbol();
+    Lo = TestPrinter->getCtx().createTempSymbol();
+    return true;
+  }
+
+  MCSymbol *Hi = nullptr;
+  MCSymbol *Lo = nullptr;
+};
+
+TEST_F(AsmPrinterEmitDwarfUnitLengthAsHiLoDiffTest, DWARF32) {
+  if (!init("x86_64-pc-linux", /*DwarfVersion=*/4, dwarf::DWARF32))
+    return;
+
+  EXPECT_CALL(TestPrinter->getMS(), emitAbsoluteSymbolDiff(Hi, Lo, 4));
+  TestPrinter->getAP()->emitDwarfUnitLength(Hi, Lo, "");
+}
+
+TEST_F(AsmPrinterEmitDwarfUnitLengthAsHiLoDiffTest, DWARF64) {
+  if (!init("x86_64-pc-linux", /*DwarfVersion=*/4, dwarf::DWARF64))
+    return;
+
+  InSequence S;
+  EXPECT_CALL(TestPrinter->getMS(), emitIntValue(dwarf::DW_LENGTH_DWARF64, 4));
+  EXPECT_CALL(TestPrinter->getMS(), emitAbsoluteSymbolDiff(Hi, Lo, 8));
+
+  TestPrinter->getAP()->emitDwarfUnitLength(Hi, Lo, "");
+}
+
 } // end namespace