[CodeGen][Debuginfo][NFC] Refactor DIE values SizeOf method to not depend on AsmPrinter.

[avl]

Summary

SizeOf() method of DIE values(unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const)
depends on AsmPrinter. AsmPrinter is too specific class here. This patch removes dependency
on AsmPrinter and use dwarf::FormParams structure instead. It allows calculate DIE values
size without using AsmPrinter. That refactoring is useful for D96035([dsymutil][DWARFlinker]
implement separate multi-thread processing for compile units.)

[dblaikie]

Sounds good

[MaskRay]

llvm/include/llvm/CodeGen/DIE.h

305

sizeOf - If you are going to change the signature, switch the case to stick with the function naming convention.

[MaskRay]

llvm/include/llvm/CodeGen/DIE.h

935–936

As you switch the case, make a minor change per
https://llvm.org/docs/CodingStandards.html#doxygen-use-in-documentation-comments
"Don’t duplicate the documentation comment in the header file and in the implementation file."

And remove the otherwise empty ///

936–937

[avl]

addressed comments(renamed methods, corrected comments)

[MaskRay]

One nit

llvm/include/llvm/BinaryFormat/Dwarf.h

654

I didn't check what this is. For newer code, DWARF vN is preferred over DwarfN.

llvm/include/llvm/BinaryFormat/Dwarf.h

 
 /// A helper struct providing information about the byte size of DW_FORM
 /// values that vary in size depending on the DWARF version, address byte
 /// size, or DWARF32/DWARF64.
 struct FormParams {
   uint16_t Version;
   uint8_t AddrSize;
   DwarfFormat Format;
+  /// True if DWARF v2 output generally uses relocations for references
+  /// to other .debug_* sections.
+  bool DwarfUsesRelocationsAcrossSections = false;
 
   /// The definition of the size of form DW_FORM_ref_addr depends on the
   /// version. In DWARF v2 it's the size of an address; after that, it's the
   /// size of a reference.
   uint8_t getRefAddrByteSize() const {
     if (Version == 2)
       return AddrSize;
     return getDwarfOffsetByteSize();

llvm/include/llvm/CodeGen/AsmPrinter.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CODEGEN_ASMPRINTER_H
 #define LLVM_CODEGEN_ASMPRINTER_H
 
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/CodeGen/AsmPrinterHandler.h"
 #include "llvm/CodeGen/DwarfStringPoolEntry.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
 #include "llvm/IR/InlineAsm.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/SourceMgr.h"
 #include <cstdint>
public:
   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;
 
+  /// Returns information about the byte size of DW_FORM values.
+  dwarf::FormParams getDwarfFormParams() 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;
 

llvm/include/llvm/CodeGen/DIE.h

static dwarf::Form BestForm(bool IsSigned, uint64_t Int) {
     }
     return dwarf::DW_FORM_data8;
   }
 
   uint64_t getValue() const { return Integer; }
   void setValue(uint64_t Val) { Integer = Val; }
 
   void emitValue(const AsmPrinter *Asm, dwarf::Form Form) const;
-  unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
+  unsigned sizeOf(const dwarf::FormParams &FormParams, dwarf::Form Form) const;
 
   void print(raw_ostream &O) const;
 };
 
 //===--------------------------------------------------------------------===//
 /// An expression DIE.
 class DIEExpr {
   const MCExpr *Expr;
 
 public:
   explicit DIEExpr(const MCExpr *E) : Expr(E) {}
 
   /// Get MCExpr.
   const MCExpr *getValue() const { return Expr; }
 
   void emitValue(const AsmPrinter *AP, dwarf::Form Form) const;
-  unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
+  unsigned sizeOf(const dwarf::FormParams &FormParams, dwarf::Form Form) const;
 
   void print(raw_ostream &O) const;
 };
 
 //===--------------------------------------------------------------------===//
 /// A label DIE.
 class DIELabel {
   const MCSymbol *Label;
 
 public:
   explicit DIELabel(const MCSymbol *L) : Label(L) {}
 
   /// Get MCSymbol.
   const MCSymbol *getValue() const { return Label; }
 
   void emitValue(const AsmPrinter *AP, dwarf::Form Form) const;
-  unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
+  unsigned sizeOf(const dwarf::FormParams &FormParams, dwarf::Form Form) const;
 
   void print(raw_ostream &O) const;
 };
 
 //===--------------------------------------------------------------------===//
 /// A BaseTypeRef DIE.
 class DIEBaseTypeRef {
   const DwarfCompileUnit *CU;
   const uint64_t Index;
   static constexpr unsigned ULEB128PadSize = 4;
 
 public:
   explicit DIEBaseTypeRef(const DwarfCompileUnit *TheCU, uint64_t Idx)
     : CU(TheCU), Index(Idx) {}
 
   /// EmitValue - Emit base type reference.
   void emitValue(const AsmPrinter *AP, dwarf::Form Form) const;
-  /// SizeOf - Determine size of the base type reference in bytes.
-  unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
+  /// sizeOf - Determine size of the base type reference in bytes.
+  unsigned sizeOf(const dwarf::FormParams &, dwarf::Form) const;
 
   void print(raw_ostream &O) const;
   uint64_t getIndex() const { return Index; }
 };
 
 //===--------------------------------------------------------------------===//
 /// A simple label difference DIE.
 ///
 class DIEDelta {
   const MCSymbol *LabelHi;
   const MCSymbol *LabelLo;
 
 public:
   DIEDelta(const MCSymbol *Hi, const MCSymbol *Lo) : LabelHi(Hi), LabelLo(Lo) {}
 
   void emitValue(const AsmPrinter *AP, dwarf::Form Form) const;
-  unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
+  unsigned sizeOf(const dwarf::FormParams &FormParams, dwarf::Form Form) const;
 
   void print(raw_ostream &O) const;
 };
 
 //===--------------------------------------------------------------------===//
 /// A container for string pool string values.
 ///
 /// This class is used with the DW_FORM_strp and DW_FORM_GNU_str_index forms.
 class DIEString {
   DwarfStringPoolEntryRef S;
 
 public:
   DIEString(DwarfStringPoolEntryRef S) : S(S) {}
 
   /// Grab the string out of the object.
   StringRef getString() const { return S.getString(); }
 
   void emitValue(const AsmPrinter *AP, dwarf::Form Form) const;
-  unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
+  unsigned sizeOf(const dwarf::FormParams &FormParams, dwarf::Form Form) const;
 
   void print(raw_ostream &O) const;
 };
 
 //===--------------------------------------------------------------------===//
 /// A container for inline string values.
 ///
 /// This class is used with the DW_FORM_string form.
 class DIEInlineString {
   StringRef S;
 
 public:
   template <typename Allocator>
   explicit DIEInlineString(StringRef Str, Allocator &A) : S(Str.copy(A)) {}
 
   ~DIEInlineString() = default;
 
   /// Grab the string out of the object.
   StringRef getString() const { return S; }
 
   void emitValue(const AsmPrinter *AP, dwarf::Form Form) const;
-  unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
+  unsigned sizeOf(const dwarf::FormParams &, dwarf::Form) const;
 
   void print(raw_ostream &O) const;
 };
 
 //===--------------------------------------------------------------------===//
 /// A pointer to another debug information entry.  An instance of this class can
 /// also be used as a proxy for a debug information entry not yet defined
 /// (ie. types.)
 class DIEEntry {
   DIE *Entry;
 
 public:
   DIEEntry() = delete;
   explicit DIEEntry(DIE &E) : Entry(&E) {}
 
   DIE &getEntry() const { return *Entry; }
 
   void emitValue(const AsmPrinter *AP, dwarf::Form Form) const;
-  unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
+  unsigned sizeOf(const dwarf::FormParams &FormParams, dwarf::Form Form) const;
 
   void print(raw_ostream &O) const;
 };
 
 //===--------------------------------------------------------------------===//
 /// Represents a pointer to a location list in the debug_loc
 /// section.
 class DIELocList {
   /// Index into the .debug_loc vector.
   size_t Index;
 
 public:
   DIELocList(size_t I) : Index(I) {}
 
   /// Grab the current index out.
   size_t getValue() const { return Index; }
 
   void emitValue(const AsmPrinter *AP, dwarf::Form Form) const;
-  unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
+  unsigned sizeOf(const dwarf::FormParams &FormParams, dwarf::Form Form) const;
 
   void print(raw_ostream &O) const;
 };
 
 //===--------------------------------------------------------------------===//
 /// A BaseTypeRef DIE.
 class DIEAddrOffset {
   DIEInteger Addr;
   DIEDelta Offset;
 
 public:
   explicit DIEAddrOffset(uint64_t Idx, const MCSymbol *Hi, const MCSymbol *Lo)
       : Addr(Idx), Offset(Hi, Lo) {}
 
   void emitValue(const AsmPrinter *AP, dwarf::Form Form) const;
-  unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
+  unsigned sizeOf(const dwarf::FormParams &FormParams, dwarf::Form Form) const;
 
   void print(raw_ostream &O) const;
 };
 
 //===--------------------------------------------------------------------===//
 /// A debug information entry value. Some of these roughly correlate
 /// to DWARF attribute classes.
 class DIEBlock;
const DIE##T &getDIE##T() const {                                            \
     return **get<const DIE##T *>();                                            \
   }
 #include "llvm/CodeGen/DIEValue.def"
 
   /// Emit value via the Dwarf writer.
   void emitValue(const AsmPrinter *AP) const;
 
   /// Return the size of a value in bytes.
-  unsigned SizeOf(const AsmPrinter *AP) const;
+  unsigned sizeOf(const dwarf::FormParams &FormParams) const;
 
   void print(raw_ostream &O) const;
   void dump() const;
 };
 
 struct IntrusiveBackListNode {
   PointerIntPair<IntrusiveBackListNode *, 1> Next;
 
public:
   /// information and gives each DIE a chance to figure out its CU relative DIE
   /// offset, unique its abbreviation and fill in the abbreviation code, and
   /// return the unit offset that points to where the next DIE will be emitted
   /// within the debug unit section. After this function has been called for all
   /// DIE objects, the DWARF can be generated since all DIEs will be able to
   /// properly refer to other DIE objects since all DIEs have calculated their
   /// offsets.
   ///
-  /// \param AP AsmPrinter to use when calculating sizes.
+  /// \param FormParams Used when calculating sizes.
   /// \param AbbrevSet the abbreviation used to unique DIE abbreviations.
   /// \param CUOffset the compile/type unit relative offset in bytes.
   /// \returns the offset for the DIE that follows this DIE within the
   /// current compile/type unit.
-  unsigned computeOffsetsAndAbbrevs(const AsmPrinter *AP,
+  unsigned computeOffsetsAndAbbrevs(const dwarf::FormParams &FormParams,
                                     DIEAbbrevSet &AbbrevSet, unsigned CUOffset);
 
   /// Climb up the parent chain to get the compile unit or type unit DIE that
   /// this DIE belongs to.
   ///
   /// \returns the compile or type unit DIE that owns this DIE, or NULL if
   /// this DIE hasn't been added to a unit DIE.
   const DIE *getUnitDie() const;

 //===--------------------------------------------------------------------===//
 /// DIELoc - Represents an expression location.
 //
 class DIELoc : public DIEValueList {
   mutable unsigned Size = 0; // Size in bytes excluding size header.
 
 public:
   DIELoc() = default;
 
-  /// ComputeSize - Calculate the size of the location expression.
-  ///
-  unsigned ComputeSize(const AsmPrinter *AP) const;
+  /// Calculate the size of the location expression.
+  unsigned computeSize(const dwarf::FormParams &FormParams) const;
 
   // TODO: move setSize() and Size to DIEValueList.
   void setSize(unsigned size) { Size = size; }
 
   /// BestForm - Choose the best form for data.
   ///
   dwarf::Form BestForm(unsigned DwarfVersion) const {
     if (DwarfVersion > 3)
       return dwarf::DW_FORM_exprloc;
     // Pre-DWARF4 location expressions were blocks and not exprloc.
     if ((unsigned char)Size == Size)
       return dwarf::DW_FORM_block1;
     if ((unsigned short)Size == Size)
       return dwarf::DW_FORM_block2;
     if ((unsigned int)Size == Size)
       return dwarf::DW_FORM_block4;
     return dwarf::DW_FORM_block;
   }
 
   void emitValue(const AsmPrinter *Asm, dwarf::Form Form) const;
-  unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
+  unsigned sizeOf(const dwarf::FormParams &, dwarf::Form Form) const;
 
   void print(raw_ostream &O) const;
 };
 
 //===--------------------------------------------------------------------===//
 /// DIEBlock - Represents a block of values.
 //
 class DIEBlock : public DIEValueList {
   mutable unsigned Size = 0; // Size in bytes excluding size header.
 
 public:
   DIEBlock() = default;
 
-  /// ComputeSize - Calculate the size of the location expression.
-  ///
-  unsigned ComputeSize(const AsmPrinter *AP) const;
+  /// Calculate the size of the location expression.
+  unsigned computeSize(const dwarf::FormParams &FormParams) const;
 
   // TODO: move setSize() and Size to DIEValueList.
   void setSize(unsigned size) { Size = size; }
 
   /// BestForm - Choose the best form for data.
   ///
   dwarf::Form BestForm() const {
     if ((unsigned char)Size == Size)
       return dwarf::DW_FORM_block1;
     if ((unsigned short)Size == Size)
       return dwarf::DW_FORM_block2;
     if ((unsigned int)Size == Size)
       return dwarf::DW_FORM_block4;
     return dwarf::DW_FORM_block;
   }
 
   void emitValue(const AsmPrinter *Asm, dwarf::Form Form) const;
-  unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
+  unsigned sizeOf(const dwarf::FormParams &, dwarf::Form Form) const;
 
   void print(raw_ostream &O) const;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_CODEGEN_DIE_H

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());
 }
 
+dwarf::FormParams AsmPrinter::getDwarfFormParams() const {
+  return {getDwarfVersion(), uint8_t(getPointerSize()),
+          OutStreamer->getContext().getDwarfFormat(),
+          MAI->doesDwarfUseRelocationsAcrossSections()};
+}
+
 unsigned int AsmPrinter::getUnitLengthFieldByteSize() const {
   return dwarf::getUnitLengthFieldByteSize(
       OutStreamer->getContext().getDwarfFormat());
 }

llvm/lib/CodeGen/AsmPrinter/DIE.cpp

 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 LLVM_DUMP_METHOD void DIE::dump() const {
   print(dbgs());
 }
 #endif
 
-unsigned DIE::computeOffsetsAndAbbrevs(const AsmPrinter *AP,
+unsigned DIE::computeOffsetsAndAbbrevs(const dwarf::FormParams &FormParams,
                                        DIEAbbrevSet &AbbrevSet,
                                        unsigned CUOffset) {
   // Unique the abbreviation and fill in the abbreviation number so this DIE
   // can be emitted.
   const DIEAbbrev &Abbrev = AbbrevSet.uniqueAbbreviation(*this);
 
   // Set compile/type unit relative offset of this DIE.
   setOffset(CUOffset);
 
   // Add the byte size of the abbreviation code.
   CUOffset += getULEB128Size(getAbbrevNumber());
 
   // Add the byte size of all the DIE attribute values.
   for (const auto &V : values())
-    CUOffset += V.SizeOf(AP);
+    CUOffset += V.sizeOf(FormParams);
 
   // Let the children compute their offsets and abbreviation numbers.
   if (hasChildren()) {
     (void)Abbrev;
     assert(Abbrev.hasChildren() && "Children flag not set");
 
     for (auto &Child : children())
-      CUOffset = Child.computeOffsetsAndAbbrevs(AP, AbbrevSet, CUOffset);
+      CUOffset =
+          Child.computeOffsetsAndAbbrevs(FormParams, AbbrevSet, CUOffset);
 
     // Each child chain is terminated with a zero byte, adjust the offset.
     CUOffset += sizeof(int8_t);
   }
 
   // Compute the byte size of this DIE and all of its children correctly. This
   // is needed so that top level DIE can help the compile unit set its length
   // correctly.

 #define HANDLE_DIEVALUE(T)                                                     \
   case is##T:                                                                  \
     getDIE##T().emitValue(AP, Form);                                           \
     break;
 #include "llvm/CodeGen/DIEValue.def"
   }
 }
 
-unsigned DIEValue::SizeOf(const AsmPrinter *AP) const {
+unsigned DIEValue::sizeOf(const dwarf::FormParams &FormParams) const {
   switch (Ty) {
   case isNone:
     llvm_unreachable("Expected valid DIEValue");
 #define HANDLE_DIEVALUE(T)                                                     \
   case is##T:                                                                  \
-    return getDIE##T().SizeOf(AP, Form);
+    return getDIE##T().sizeOf(FormParams, Form);
 #include "llvm/CodeGen/DIEValue.def"
   }
   llvm_unreachable("Unknown DIE kind");
 }
 
 LLVM_DUMP_METHOD
 void DIEValue::print(raw_ostream &O) const {
   switch (Ty) {
void DIEInteger::emitValue(const AsmPrinter *Asm, dwarf::Form Form) const {
   case dwarf::DW_FORM_ref_sup8:
   case dwarf::DW_FORM_GNU_ref_alt:
   case dwarf::DW_FORM_GNU_strp_alt:
   case dwarf::DW_FORM_line_strp:
   case dwarf::DW_FORM_sec_offset:
   case dwarf::DW_FORM_strp_sup:
   case dwarf::DW_FORM_addr:
   case dwarf::DW_FORM_ref_addr:
-    Asm->OutStreamer->emitIntValue(Integer, SizeOf(Asm, Form));
+    Asm->OutStreamer->emitIntValue(Integer,
+                                   sizeOf(Asm->getDwarfFormParams(), Form));
     return;
   case dwarf::DW_FORM_GNU_str_index:
   case dwarf::DW_FORM_GNU_addr_index:
   case dwarf::DW_FORM_ref_udata:
   case dwarf::DW_FORM_strx:
   case dwarf::DW_FORM_addrx:
   case dwarf::DW_FORM_rnglistx:
   case dwarf::DW_FORM_udata:
     Asm->emitULEB128(Integer);
     return;
   case dwarf::DW_FORM_sdata:
     Asm->emitSLEB128(Integer);
     return;
   default: llvm_unreachable("DIE Value form not supported yet");
   }
 }
 
-/// SizeOf - Determine size of integer value in bytes.
+/// sizeOf - Determine size of integer value in bytes.
 ///
-unsigned DIEInteger::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
-  assert(AP && "AsmPrinter is required to set FormParams");
-  dwarf::FormParams Params = {AP->getDwarfVersion(),
-                              uint8_t(AP->getPointerSize()),
-                              AP->OutStreamer->getContext().getDwarfFormat()};
-
-  if (Optional<uint8_t> FixedSize = dwarf::getFixedFormByteSize(Form, Params))
+unsigned DIEInteger::sizeOf(const dwarf::FormParams &FormParams,
+                            dwarf::Form Form) const {
+  if (Optional<uint8_t> FixedSize =
+          dwarf::getFixedFormByteSize(Form, FormParams))
     return *FixedSize;
 
   switch (Form) {
   case dwarf::DW_FORM_GNU_str_index:
   case dwarf::DW_FORM_GNU_addr_index:
   case dwarf::DW_FORM_ref_udata:
   case dwarf::DW_FORM_strx:
   case dwarf::DW_FORM_addrx:

 
 //===----------------------------------------------------------------------===//
 // DIEExpr Implementation
 //===----------------------------------------------------------------------===//
 
 /// EmitValue - Emit expression value.
 ///
 void DIEExpr::emitValue(const AsmPrinter *AP, dwarf::Form Form) const {
-  AP->emitDebugValue(Expr, SizeOf(AP, Form));
+  AP->emitDebugValue(Expr, sizeOf(AP->getDwarfFormParams(), Form));
 }
 
 /// SizeOf - Determine size of expression value in bytes.
 ///
-unsigned DIEExpr::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
+unsigned DIEExpr::sizeOf(const dwarf::FormParams &FormParams,
+                         dwarf::Form Form) const {
   switch (Form) {
   case dwarf::DW_FORM_data4:
     return 4;
   case dwarf::DW_FORM_data8:
     return 8;
   case dwarf::DW_FORM_sec_offset:
-    return AP->getDwarfOffsetByteSize();
+    return FormParams.getDwarfOffsetByteSize();
   default:
     llvm_unreachable("DIE Value form not supported yet");
   }
 }
 
 LLVM_DUMP_METHOD
 void DIEExpr::print(raw_ostream &O) const { O << "Expr: " << *Expr; }
 
 //===----------------------------------------------------------------------===//
 // DIELabel Implementation
 //===----------------------------------------------------------------------===//
 
 /// EmitValue - Emit label value.
 ///
 void DIELabel::emitValue(const AsmPrinter *AP, dwarf::Form Form) const {
   bool IsSectionRelative = Form != dwarf::DW_FORM_addr;
-  AP->emitLabelReference(Label, SizeOf(AP, Form), IsSectionRelative);
+  AP->emitLabelReference(Label, sizeOf(AP->getDwarfFormParams(), Form),
+                         IsSectionRelative);
 }
 
-/// SizeOf - Determine size of label value in bytes.
+/// sizeOf - Determine size of label value in bytes.
 ///
-unsigned DIELabel::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
+unsigned DIELabel::sizeOf(const dwarf::FormParams &FormParams,
+                          dwarf::Form Form) const {
   switch (Form) {
   case dwarf::DW_FORM_data4:
     return 4;
   case dwarf::DW_FORM_data8:
     return 8;
   case dwarf::DW_FORM_sec_offset:
   case dwarf::DW_FORM_strp:
-    return AP->getDwarfOffsetByteSize();
+    return FormParams.getDwarfOffsetByteSize();
   case dwarf::DW_FORM_addr:
-    return AP->MAI->getCodePointerSize();
+    return FormParams.AddrSize;
   default:
     llvm_unreachable("DIE Value form not supported yet");
   }
 }
 
 LLVM_DUMP_METHOD
 void DIELabel::print(raw_ostream &O) const { O << "Lbl: " << Label->getName(); }
 
 //===----------------------------------------------------------------------===//
 // DIEBaseTypeRef Implementation
 //===----------------------------------------------------------------------===//
 
 void DIEBaseTypeRef::emitValue(const AsmPrinter *AP, dwarf::Form Form) const {
   uint64_t Offset = CU->ExprRefedBaseTypes[Index].Die->getOffset();
   assert(Offset < (1ULL << (ULEB128PadSize * 7)) && "Offset wont fit");
   AP->emitULEB128(Offset, nullptr, ULEB128PadSize);
 }
 
-unsigned DIEBaseTypeRef::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
+unsigned DIEBaseTypeRef::sizeOf(const dwarf::FormParams &, dwarf::Form) const {
   return ULEB128PadSize;
 }
 
 LLVM_DUMP_METHOD
 void DIEBaseTypeRef::print(raw_ostream &O) const { O << "BaseTypeRef: " << Index; }
 
 //===----------------------------------------------------------------------===//
 // DIEDelta Implementation
 //===----------------------------------------------------------------------===//
 
 /// EmitValue - Emit delta value.
 ///
 void DIEDelta::emitValue(const AsmPrinter *AP, dwarf::Form Form) const {
-  AP->emitLabelDifference(LabelHi, LabelLo, SizeOf(AP, Form));
+  AP->emitLabelDifference(LabelHi, LabelLo,
+                          sizeOf(AP->getDwarfFormParams(), Form));
 }
 
 /// SizeOf - Determine size of delta value in bytes.
 ///
-unsigned DIEDelta::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
+unsigned DIEDelta::sizeOf(const dwarf::FormParams &FormParams,
+                          dwarf::Form Form) const {
   switch (Form) {
   case dwarf::DW_FORM_data4:
     return 4;
   case dwarf::DW_FORM_data8:
     return 8;
   case dwarf::DW_FORM_sec_offset:
-    return AP->getDwarfOffsetByteSize();
+    return FormParams.getDwarfOffsetByteSize();
   default:
     llvm_unreachable("DIE Value form not supported yet");
   }
 }
 
 LLVM_DUMP_METHOD
 void DIEDelta::print(raw_ostream &O) const {
   O << "Del: " << LabelHi->getName() << "-" << LabelLo->getName();
case dwarf::DW_FORM_strp:
     else
       DIEInteger(S.getOffset()).emitValue(AP, Form);
     return;
   default:
     llvm_unreachable("Expected valid string form");
   }
 }
 
-/// SizeOf - Determine size of delta value in bytes.
+/// sizeOf - Determine size of delta value in bytes.
 ///
-unsigned DIEString::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
+unsigned DIEString::sizeOf(const dwarf::FormParams &FormParams,
+                           dwarf::Form Form) const {
   // Index of string in symbol table.
   switch (Form) {
   case dwarf::DW_FORM_GNU_str_index:
   case dwarf::DW_FORM_strx:
   case dwarf::DW_FORM_strx1:
   case dwarf::DW_FORM_strx2:
   case dwarf::DW_FORM_strx3:
   case dwarf::DW_FORM_strx4:
-    return DIEInteger(S.getIndex()).SizeOf(AP, Form);
+    return DIEInteger(S.getIndex()).sizeOf(FormParams, Form);
   case dwarf::DW_FORM_strp:
-    if (AP->MAI->doesDwarfUseRelocationsAcrossSections())
-      return DIELabel(S.getSymbol()).SizeOf(AP, Form);
-    return DIEInteger(S.getOffset()).SizeOf(AP, Form);
+    if (FormParams.DwarfUsesRelocationsAcrossSections)
+      return DIELabel(S.getSymbol()).sizeOf(FormParams, Form);
+    return DIEInteger(S.getOffset()).sizeOf(FormParams, Form);
   default:
     llvm_unreachable("Expected valid string form");
   }
 }
 
 LLVM_DUMP_METHOD
 void DIEString::print(raw_ostream &O) const {
   O << "String: " << S.getString();
 }
 
 //===----------------------------------------------------------------------===//
 // DIEInlineString Implementation
 //===----------------------------------------------------------------------===//
 void DIEInlineString::emitValue(const AsmPrinter *AP, dwarf::Form Form) const {
   if (Form == dwarf::DW_FORM_string) {
     AP->OutStreamer->emitBytes(S);
     AP->emitInt8(0);
     return;
   }
   llvm_unreachable("Expected valid string form");
 }
 
-unsigned DIEInlineString::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
+unsigned DIEInlineString::sizeOf(const dwarf::FormParams &, dwarf::Form) const {
   // Emit string bytes + NULL byte.
   return S.size() + 1;
 }
 
 LLVM_DUMP_METHOD
 void DIEInlineString::print(raw_ostream &O) const {
   O << "InlineString: " << S;
 }
 
 //===----------------------------------------------------------------------===//
 // DIEEntry Implementation
 //===----------------------------------------------------------------------===//
 
 /// EmitValue - Emit debug information entry offset.
 ///
 void DIEEntry::emitValue(const AsmPrinter *AP, dwarf::Form Form) const {
 
   switch (Form) {
   case dwarf::DW_FORM_ref1:
   case dwarf::DW_FORM_ref2:
   case dwarf::DW_FORM_ref4:
   case dwarf::DW_FORM_ref8:
-    AP->OutStreamer->emitIntValue(Entry->getOffset(), SizeOf(AP, Form));
+    AP->OutStreamer->emitIntValue(Entry->getOffset(),
+                                  sizeOf(AP->getDwarfFormParams(), Form));
     return;
 
   case dwarf::DW_FORM_ref_udata:
     AP->emitULEB128(Entry->getOffset());
     return;
 
   case dwarf::DW_FORM_ref_addr: {
     // Get the absolute offset for this DIE within the debug info/types section.
     uint64_t Addr = Entry->getDebugSectionOffset();
     if (const MCSymbol *SectionSym =
             Entry->getUnit()->getCrossSectionRelativeBaseAddress()) {
-      AP->emitLabelPlusOffset(SectionSym, Addr, SizeOf(AP, Form), true);
+      AP->emitLabelPlusOffset(SectionSym, Addr,
+                              sizeOf(AP->getDwarfFormParams(), Form), true);
       return;
     }
 
-    AP->OutStreamer->emitIntValue(Addr, SizeOf(AP, Form));
+    AP->OutStreamer->emitIntValue(Addr, sizeOf(AP->getDwarfFormParams(), Form));
     return;
   }
   default:
     llvm_unreachable("Improper form for DIE reference");
   }
 }
 
-unsigned DIEEntry::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
+unsigned DIEEntry::sizeOf(const dwarf::FormParams &FormParams,
+                          dwarf::Form Form) const {
   switch (Form) {
   case dwarf::DW_FORM_ref1:
     return 1;
   case dwarf::DW_FORM_ref2:
     return 2;
   case dwarf::DW_FORM_ref4:
     return 4;
   case dwarf::DW_FORM_ref8:
     return 8;
   case dwarf::DW_FORM_ref_udata:
     return getULEB128Size(Entry->getOffset());
   case dwarf::DW_FORM_ref_addr:
-    if (AP->getDwarfVersion() == 2)
-      return AP->MAI->getCodePointerSize();
-    switch (AP->OutStreamer->getContext().getDwarfFormat()) {
-    case dwarf::DWARF32:
-      return 4;
-    case dwarf::DWARF64:
-      return 8;
-    }
-    llvm_unreachable("Invalid DWARF format");
+    return FormParams.getRefAddrByteSize();
 
   default:
     llvm_unreachable("Improper form for DIE reference");
   }
 }
 
 LLVM_DUMP_METHOD
 void DIEEntry::print(raw_ostream &O) const {
   O << format("Die: 0x%lx", (long)(intptr_t)&Entry);
 }
 
 //===----------------------------------------------------------------------===//
 // DIELoc Implementation
 //===----------------------------------------------------------------------===//
 
-/// ComputeSize - calculate the size of the location expression.
-///
-unsigned DIELoc::ComputeSize(const AsmPrinter *AP) const {
+unsigned DIELoc::computeSize(const dwarf::FormParams &FormParams) const {
   if (!Size) {
     for (const auto &V : values())
-      Size += V.SizeOf(AP);
+      Size += V.sizeOf(FormParams);
   }
 
   return Size;
 }
 
 /// EmitValue - Emit location data.
 ///
 void DIELoc::emitValue(const AsmPrinter *Asm, dwarf::Form Form) const {
   switch (Form) {
   default: llvm_unreachable("Improper form for block");
   case dwarf::DW_FORM_block1: Asm->emitInt8(Size);    break;
   case dwarf::DW_FORM_block2: Asm->emitInt16(Size);   break;
   case dwarf::DW_FORM_block4: Asm->emitInt32(Size);   break;
   case dwarf::DW_FORM_block:
   case dwarf::DW_FORM_exprloc:
     Asm->emitULEB128(Size);
     break;
   }
 
   for (const auto &V : values())
     V.emitValue(Asm);
 }
 
-/// SizeOf - Determine size of location data in bytes.
+/// sizeOf - Determine size of location data in bytes.
 ///
-unsigned DIELoc::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
+unsigned DIELoc::sizeOf(const dwarf::FormParams &, dwarf::Form Form) const {
   switch (Form) {
   case dwarf::DW_FORM_block1: return Size + sizeof(int8_t);
   case dwarf::DW_FORM_block2: return Size + sizeof(int16_t);
   case dwarf::DW_FORM_block4: return Size + sizeof(int32_t);
   case dwarf::DW_FORM_block:
   case dwarf::DW_FORM_exprloc:
     return Size + getULEB128Size(Size);
   default: llvm_unreachable("Improper form for block");
   }
 }
 
 LLVM_DUMP_METHOD
 void DIELoc::print(raw_ostream &O) const {
   printValues(O, *this, "ExprLoc", Size, 5);
 }
 
 //===----------------------------------------------------------------------===//
 // DIEBlock Implementation
 //===----------------------------------------------------------------------===//
 
-/// ComputeSize - calculate the size of the block.
-///
-unsigned DIEBlock::ComputeSize(const AsmPrinter *AP) const {
+unsigned DIEBlock::computeSize(const dwarf::FormParams &FormParams) const {
   if (!Size) {
     for (const auto &V : values())
-      Size += V.SizeOf(AP);
+      Size += V.sizeOf(FormParams);
   }
 
   return Size;
 }
 
 /// EmitValue - Emit block data.
 ///
 void DIEBlock::emitValue(const AsmPrinter *Asm, dwarf::Form Form) const {
void DIEBlock::emitValue(const AsmPrinter *Asm, dwarf::Form Form) const {
   case dwarf::DW_FORM_string: break;
   case dwarf::DW_FORM_data16: break;
   }
 
   for (const auto &V : values())
     V.emitValue(Asm);
 }
 
-/// SizeOf - Determine size of block data in bytes.
+/// sizeOf - Determine size of block data in bytes.
 ///
-unsigned DIEBlock::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
+unsigned DIEBlock::sizeOf(const dwarf::FormParams &, dwarf::Form Form) const {
   switch (Form) {
   case dwarf::DW_FORM_block1: return Size + sizeof(int8_t);
   case dwarf::DW_FORM_block2: return Size + sizeof(int16_t);
   case dwarf::DW_FORM_block4: return Size + sizeof(int32_t);
   case dwarf::DW_FORM_exprloc:
   case dwarf::DW_FORM_block:  return Size + getULEB128Size(Size);
   case dwarf::DW_FORM_data16: return 16;
   default: llvm_unreachable("Improper form for block");
   }
 }
 
 LLVM_DUMP_METHOD
 void DIEBlock::print(raw_ostream &O) const {
   printValues(O, *this, "Blk", Size, 5);
 }
 
 //===----------------------------------------------------------------------===//
 // DIELocList Implementation
 //===----------------------------------------------------------------------===//
 
-unsigned DIELocList::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
+unsigned DIELocList::sizeOf(const dwarf::FormParams &FormParams,
+                            dwarf::Form Form) const {
   switch (Form) {
   case dwarf::DW_FORM_loclistx:
     return getULEB128Size(Index);
   case dwarf::DW_FORM_data4:
-    assert(!AP->isDwarf64() &&
+    assert(FormParams.Format != dwarf::DWARF64 &&
            "DW_FORM_data4 is not suitable to emit a pointer to a location list "
            "in the 64-bit DWARF format");
     return 4;
   case dwarf::DW_FORM_data8:
-    assert(AP->isDwarf64() &&
+    assert(FormParams.Format == dwarf::DWARF64 &&
            "DW_FORM_data8 is not suitable to emit a pointer to a location list "
            "in the 32-bit DWARF format");
     return 8;
   case dwarf::DW_FORM_sec_offset:
-    return AP->getDwarfOffsetByteSize();
+    return FormParams.getDwarfOffsetByteSize();
   default:
     llvm_unreachable("DIE Value form not supported yet");
   }
 }
 
 /// EmitValue - Emit label value.
 ///
 void DIELocList::emitValue(const AsmPrinter *AP, dwarf::Form Form) const {
   if (Form == dwarf::DW_FORM_loclistx) {
     AP->emitULEB128(Index);
     return;
   }
   DwarfDebug *DD = AP->getDwarfDebug();
   MCSymbol *Label = DD->getDebugLocs().getList(Index).Label;
   AP->emitDwarfSymbolReference(Label, /*ForceOffset*/ DD->useSplitDwarf());
 }
 
 LLVM_DUMP_METHOD
 void DIELocList::print(raw_ostream &O) const { O << "LocList: " << Index; }
 
 //===----------------------------------------------------------------------===//
 // DIEAddrOffset Implementation
 //===----------------------------------------------------------------------===//
 
-unsigned DIEAddrOffset::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
-  return Addr.SizeOf(AP, dwarf::DW_FORM_addrx) +
-         Offset.SizeOf(AP, dwarf::DW_FORM_data4);
+unsigned DIEAddrOffset::sizeOf(const dwarf::FormParams &FormParams,
+                               dwarf::Form) const {
+  return Addr.sizeOf(FormParams, dwarf::DW_FORM_addrx) +
+         Offset.sizeOf(FormParams, dwarf::DW_FORM_data4);
 }
 
 /// EmitValue - Emit label value.
 ///
 void DIEAddrOffset::emitValue(const AsmPrinter *AP, dwarf::Form Form) const {
   Addr.emitValue(AP, dwarf::DW_FORM_addrx);
   Offset.emitValue(AP, dwarf::DW_FORM_data4);
 }
 
 LLVM_DUMP_METHOD
 void DIEAddrOffset::print(raw_ostream &O) const {
   O << "AddrOffset: ";
   Addr.print(O);
   O << " + ";
   Offset.print(O);
 }

llvm/lib/CodeGen/AsmPrinter/DIEHash.cpp

case DIEValue::isInlineString:
     break;
   case DIEValue::isBlock:
   case DIEValue::isLoc:
   case DIEValue::isLocList:
     addULEB128('A');
     addULEB128(Attribute);
     addULEB128(dwarf::DW_FORM_block);
     if (Value.getType() == DIEValue::isBlock) {
-      addULEB128(Value.getDIEBlock().ComputeSize(AP));
+      addULEB128(Value.getDIEBlock().computeSize(AP->getDwarfFormParams()));
       hashBlockData(Value.getDIEBlock().values());
     } else if (Value.getType() == DIEValue::isLoc) {
-      addULEB128(Value.getDIELoc().ComputeSize(AP));
+      addULEB128(Value.getDIELoc().computeSize(AP->getDwarfFormParams()));
       hashBlockData(Value.getDIELoc().values());
     } else {
       // We could add the block length, but that would take
       // a bit of work and not add a lot of uniqueness
       // to the hash in some way we could test.
       hashLocList(Value.getDIELocList());
     }
     break;

llvm/lib/CodeGen/AsmPrinter/DwarfFile.cpp

unsigned DwarfFile::computeSizeAndOffsetsForUnit(DwarfUnit *TheU) {
   // The return value here is CU-relative, after laying out
   // all of the CU DIE.
   return computeSizeAndOffset(TheU->getUnitDie(), Offset);
 }
 
 // Compute the size and offset of a DIE. The offset is relative to start of the
 // CU. It returns the offset after laying out the DIE.
 unsigned DwarfFile::computeSizeAndOffset(DIE &Die, unsigned Offset) {
-  return Die.computeOffsetsAndAbbrevs(Asm, Abbrevs, Offset);
+  return Die.computeOffsetsAndAbbrevs(Asm->getDwarfFormParams(), Abbrevs,
+                                      Offset);
 }
 
 void DwarfFile::emitAbbrevs(MCSection *Section) { Abbrevs.Emit(Asm, Section); }
 
 // Emit strings into a string section.
 void DwarfFile::emitStrings(MCSection *StrSection, MCSection *OffsetSection,
                             bool UseRelativeOffsets) {
   StrPool.emit(*Asm, StrSection, OffsetSection, UseRelativeOffsets);

llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp

 void DIEDwarfExpression::enableTemporaryBuffer() {
   assert(!IsBuffering && "Already buffering?");
   IsBuffering = true;
 }
 
 void DIEDwarfExpression::disableTemporaryBuffer() { IsBuffering = false; }
 
 unsigned DIEDwarfExpression::getTemporaryBufferSize() {
-  return TmpDIE.ComputeSize(&AP);
+  return TmpDIE.computeSize(AP.getDwarfFormParams());
 }
 
 void DIEDwarfExpression::commitTemporaryBuffer() { OutDIE.takeValues(TmpDIE); }
 
 bool DIEDwarfExpression::isFrameRegister(const TargetRegisterInfo &TRI,
                                          llvm::Register MachineReg) {
   return MachineReg == TRI.getFrameRegister(*AP.MF);
 }

 DIE &DwarfUnit::createAndAddDIE(dwarf::Tag Tag, DIE &Parent, const DINode *N) {
   DIE &Die = Parent.addChild(DIE::get(DIEValueAllocator, Tag));
   if (N)
     insertDIE(N, &Die);
   return Die;
 }
 
 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute, DIELoc *Loc) {
-  Loc->ComputeSize(Asm);
+  Loc->computeSize(Asm->getDwarfFormParams());
   DIELocs.push_back(Loc); // Memoize so we can call the destructor later on.
   addAttribute(Die, Attribute, Loc->BestForm(DD->getDwarfVersion()), Loc);
 }
 
 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute, dwarf::Form Form,
                          DIEBlock *Block) {
-  Block->ComputeSize(Asm);
+  Block->computeSize(Asm->getDwarfFormParams());
   DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
   addAttribute(Die, Attribute, Form, Block);
 }
 
 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute,
                          DIEBlock *Block) {
   addBlock(Die, Attribute, Block->BestForm(), Block);
 }

llvm/unittests/CodeGen/DIETest.cpp

 //===- llvm/unittest/CodeGen/DIETest.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 "llvm/CodeGen/DIE.h"
 #include "TestAsmPrinter.h"
+#include "llvm/CodeGen/AsmPrinter.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/Testing/Support/Error.h"
 
 using namespace llvm;
 using testing::_;
 using testing::SaveArg;
 
void SetUp() override {
     Val = MCConstantExpr::create(42, TestPrinter->getCtx());
   }
 
   const MCExpr *Val = nullptr;
 };
 
 TEST_P(DIEExprFixture, SizeOf) {
   DIEExpr Tst(Val);
-  EXPECT_EQ(Size, Tst.SizeOf(TestPrinter->getAP(), Form));
+  EXPECT_EQ(Size, Tst.sizeOf(TestPrinter->getAP()->getDwarfFormParams(), Form));
 }
 
 TEST_P(DIEExprFixture, EmitValue) {
   DIEExpr Tst(Val);
   EXPECT_CALL(TestPrinter->getMS(), emitValueImpl(Val, Size, _));
   Tst.emitValue(TestPrinter->getAP(), Form);
 }
 
void SetUp() override {
     Val = TestPrinter->getCtx().createTempSymbol();
   }
 
   const MCSymbol *Val = nullptr;
 };
 
 TEST_P(DIELabelFixture, SizeOf) {
   DIELabel Tst(Val);
-  EXPECT_EQ(Size, Tst.SizeOf(TestPrinter->getAP(), Form));
+  EXPECT_EQ(Size, Tst.sizeOf(TestPrinter->getAP()->getDwarfFormParams(), Form));
 }
 
 TEST_P(DIELabelFixture, EmitValue) {
   DIELabel Tst(Val);
 
   const MCExpr *Arg0 = nullptr;
   EXPECT_CALL(TestPrinter->getMS(), emitValueImpl(_, Size, _))
       .WillOnce(SaveArg<0>(&Arg0));
struct DIEDeltaFixture : public DIEFixtureBase {
   }
 
   const MCSymbol *Hi = nullptr;
   const MCSymbol *Lo = nullptr;
 };
 
 TEST_P(DIEDeltaFixture, SizeOf) {
   DIEDelta Tst(Hi, Lo);
-  EXPECT_EQ(Size, Tst.SizeOf(TestPrinter->getAP(), Form));
+  EXPECT_EQ(Size, Tst.sizeOf(TestPrinter->getAP()->getDwarfFormParams(), Form));
 }
 
 TEST_P(DIEDeltaFixture, EmitValue) {
   DIEDelta Tst(Hi, Lo);
   EXPECT_CALL(TestPrinter->getMS(), emitAbsoluteSymbolDiff(Hi, Lo, Size));
   Tst.emitValue(TestPrinter->getAP(), Form);
 }
 
 INSTANTIATE_TEST_SUITE_P(
     DIETestParams, DIEDeltaFixture,
     testing::Values(
         DIETestParams{4, dwarf::DWARF32, dwarf::DW_FORM_data4, 4u},
         DIETestParams{4, dwarf::DWARF32, dwarf::DW_FORM_data8, 8u},
         DIETestParams{4, dwarf::DWARF32, dwarf::DW_FORM_sec_offset, 4u},
         DIETestParams{4, dwarf::DWARF64, dwarf::DW_FORM_data4, 4u},
         DIETestParams{4, dwarf::DWARF64, dwarf::DW_FORM_data8, 8u},
         DIETestParams{4, dwarf::DWARF64, dwarf::DW_FORM_sec_offset, 8u}));
 
 struct DIELocListFixture : public DIEFixtureBase {
   void SetUp() override { DIEFixtureBase::SetUp(); }
 };
 
 TEST_P(DIELocListFixture, SizeOf) {
   DIELocList Tst(999);
-  EXPECT_EQ(Size, Tst.SizeOf(TestPrinter->getAP(), Form));
+  EXPECT_EQ(Size, Tst.sizeOf(TestPrinter->getAP()->getDwarfFormParams(), Form));
 }
 
 INSTANTIATE_TEST_SUITE_P(
     DIETestParams, DIELocListFixture,
     testing::Values(
         DIETestParams{4, dwarf::DWARF32, dwarf::DW_FORM_loclistx, 2u},
         DIETestParams{4, dwarf::DWARF32, dwarf::DW_FORM_data4, 4u},
         DIETestParams{4, dwarf::DWARF32, dwarf::DW_FORM_sec_offset, 4u},
         DIETestParams{4, dwarf::DWARF64, dwarf::DW_FORM_loclistx, 2u},
         DIETestParams{4, dwarf::DWARF64, dwarf::DW_FORM_data8, 8u},
         DIETestParams{4, dwarf::DWARF64, dwarf::DW_FORM_sec_offset, 8u}));
 
 } // end namespace

llvm/unittests/DebugInfo/DWARF/DwarfGenerator.cpp

 
 namespace {} // end anonymous namespace
 
 //===----------------------------------------------------------------------===//
 /// dwarfgen::DIE implementation.
 //===----------------------------------------------------------------------===//
 unsigned dwarfgen::DIE::computeSizeAndOffsets(unsigned Offset) {
   auto &DG = CU->getGenerator();
-  return Die->computeOffsetsAndAbbrevs(DG.getAsmPrinter(), DG.getAbbrevSet(),
-                                       Offset);
+  return Die->computeOffsetsAndAbbrevs(DG.getAsmPrinter()->getDwarfFormParams(),
+                                       DG.getAbbrevSet(), Offset);
 }
 
 void dwarfgen::DIE::addAttribute(uint16_t A, dwarf::Form Form, uint64_t U) {
   auto &DG = CU->getGenerator();
   Die->addValue(DG.getAllocator(), static_cast<dwarf::Attribute>(A), Form,
                 DIEInteger(U));
 }
 
void dwarfgen::DIE::addAttribute(uint16_t A, dwarf::Form Form, const void *P,
   auto &DG = CU->getGenerator();
   DIEBlock *Block = new (DG.getAllocator()) DIEBlock;
   for (size_t I = 0; I < S; ++I)
     Block->addValue(
         DG.getAllocator(), (dwarf::Attribute)0, dwarf::DW_FORM_data1,
         DIEInteger(
             (const_cast<uint8_t *>(static_cast<const uint8_t *>(P)))[I]));
 
-  Block->ComputeSize(DG.getAsmPrinter());
+  Block->computeSize(DG.getAsmPrinter()->getDwarfFormParams());
   Die->addValue(DG.getAllocator(), static_cast<dwarf::Attribute>(A), Form,
                 Block);
 }
 
 void dwarfgen::DIE::addAttribute(uint16_t A, dwarf::Form Form) {
   auto &DG = CU->getGenerator();
   assert(Form == DW_FORM_flag_present);
   Die->addValue(DG.getAllocator(), static_cast<dwarf::Attribute>(A), Form,