Address comments

Author: Sterling-Augustine

llvm/include/llvm/DebugInfo/DWARF/DWARFCFIPrinter.h

@@ -24,10 +24,10 @@ namespace dwarf {
 class CFIPrinter {
 public:
   static void print(const CFIProgram &P, raw_ostream &OS,
-                    DIDumpOptions DumpOpts, unsigned IndentLevel,
+                    DIDumpOptions &DumpOpts, unsigned IndentLevel,
                     std::optional<uint64_t> Address);
 
-  static void printOperand(raw_ostream &OS, DIDumpOptions DumpOpts,
+  static void printOperand(raw_ostream &OS, DIDumpOptions &DumpOpts,
                            const CFIProgram &P,
                            const CFIProgram::Instruction &Instr,
                            unsigned OperandIdx, uint64_t Operand,

llvm/include/llvm/DebugInfo/DWARF/DWARFCFIProgram.h

@@ -37,7 +37,6 @@ class CFIProgram {
 public:
   static constexpr size_t MaxOperands = 3;
   typedef SmallVector<uint64_t, MaxOperands> Operands;
-  friend CFIPrinter;
 
   /// An instruction consists of a DWARF CFI opcode and an optional sequence of
   /// operands. If it refers to an expression, then this expression has its own
@@ -89,6 +88,32 @@ class CFIProgram {
   /// Get a DWARF CFI call frame string for the given DW_CFA opcode.
   LLVM_ABI StringRef callFrameString(unsigned Opcode) const;
 
+  /// Types of operands to CFI instructions
+  /// In DWARF, this type is implicitly tied to a CFI instruction opcode and
+  /// thus this type doesn't need to be explicitly written to the file (this is
+  /// not a DWARF encoding). The relationship of instrs to operand types can
+  /// be obtained from getOperandTypes() and is only used to simplify
+  /// instruction printing and error messages.
+  enum OperandType {
+    OT_Unset,
+    OT_None,
+    OT_Address,
+    OT_Offset,
+    OT_FactoredCodeOffset,
+    OT_SignedFactDataOffset,
+    OT_UnsignedFactDataOffset,
+    OT_Register,
+    OT_AddressSpace,
+    OT_Expression
+  };
+
+  /// Get the OperandType as a "const char *".
+  static const char *operandTypeString(OperandType OT);
+
+  /// Retrieve the array describing the types of operands according to the enum
+  /// above. This is indexed by opcode.
+  static ArrayRef<OperandType[MaxOperands]> getOperandTypes();
+
 private:
   std::vector<Instruction> Instructions;
   const uint64_t CodeAlignmentFactor;
@@ -121,32 +146,6 @@ class CFIProgram {
     Instructions.back().Ops.push_back(Operand2);
     Instructions.back().Ops.push_back(Operand3);
   }
-
-  /// Types of operands to CFI instructions
-  /// In DWARF, this type is implicitly tied to a CFI instruction opcode and
-  /// thus this type doesn't need to be explicitly written to the file (this is
-  /// not a DWARF encoding). The relationship of instrs to operand types can
-  /// be obtained from getOperandTypes() and is only used to simplify
-  /// instruction printing.
-  enum OperandType {
-    OT_Unset,
-    OT_None,
-    OT_Address,
-    OT_Offset,
-    OT_FactoredCodeOffset,
-    OT_SignedFactDataOffset,
-    OT_UnsignedFactDataOffset,
-    OT_Register,
-    OT_AddressSpace,
-    OT_Expression
-  };
-
-  /// Get the OperandType as a "const char *".
-  static const char *operandTypeString(OperandType OT);
-
-  /// Retrieve the array describing the types of operands according to the enum
-  /// above. This is indexed by opcode.
-  static ArrayRef<OperandType[MaxOperands]> getOperandTypes();
 };
 
 } // end namespace dwarf

llvm/lib/DebugInfo/DWARF/DWARFCFIPrinter.cpp

@@ -25,7 +25,7 @@ using namespace llvm;
 using namespace dwarf;
 
 void CFIPrinter::print(const CFIProgram &P, raw_ostream &OS,
-                       DIDumpOptions DumpOpts, unsigned IndentLevel,
+                       DIDumpOptions &DumpOpts, unsigned IndentLevel,
                        std::optional<uint64_t> Address) {
   for (const auto &Instr : P) {
     uint8_t Opcode = Instr.Opcode;
@@ -37,7 +37,7 @@ void CFIPrinter::print(const CFIProgram &P, raw_ostream &OS,
   }
 }
 
-static void printRegister(raw_ostream &OS, DIDumpOptions DumpOpts,
+static void printRegister(raw_ostream &OS, DIDumpOptions &DumpOpts,
                           unsigned RegNum) {
   if (DumpOpts.GetNameForDWARFReg) {
     auto RegName = DumpOpts.GetNameForDWARFReg(RegNum, DumpOpts.IsEH);
@@ -50,7 +50,7 @@ static void printRegister(raw_ostream &OS, DIDumpOptions DumpOpts,
 }
 
 /// Print \p Opcode's operand number \p OperandIdx which has value \p Operand.
-void CFIPrinter::printOperand(raw_ostream &OS, DIDumpOptions DumpOpts,
+void CFIPrinter::printOperand(raw_ostream &OS, DIDumpOptions &DumpOpts,
                               const CFIProgram &P,
                               const CFIProgram::Instruction &Instr,
                               unsigned OperandIdx, uint64_t Operand,
@@ -82,24 +82,24 @@ void CFIPrinter::printOperand(raw_ostream &OS, DIDumpOptions DumpOpts,
     OS << format(" %+" PRId64, int64_t(Operand));
     break;
   case CFIProgram::OT_FactoredCodeOffset: // Always Unsigned
-    if (P.CodeAlignmentFactor)
-      OS << format(" %" PRId64, Operand * P.CodeAlignmentFactor);
+    if (P.codeAlign())
+      OS << format(" %" PRId64, Operand * P.codeAlign());
     else
       OS << format(" %" PRId64 "*code_alignment_factor", Operand);
-    if (Address && P.CodeAlignmentFactor) {
-      *Address += Operand * P.CodeAlignmentFactor;
+    if (Address && P.codeAlign()) {
+      *Address += Operand * P.codeAlign();
       OS << format(" to 0x%" PRIx64, *Address);
     }
     break;
   case CFIProgram::OT_SignedFactDataOffset:
-    if (P.DataAlignmentFactor)
-      OS << format(" %" PRId64, int64_t(Operand) * P.DataAlignmentFactor);
+    if (P.dataAlign())
+      OS << format(" %" PRId64, int64_t(Operand) * P.dataAlign());
     else
       OS << format(" %" PRId64 "*data_alignment_factor", int64_t(Operand));
     break;
   case CFIProgram::OT_UnsignedFactDataOffset:
-    if (P.DataAlignmentFactor)
-      OS << format(" %" PRId64, Operand * P.DataAlignmentFactor);
+    if (P.dataAlign())
+      OS << format(" %" PRId64, Operand * P.dataAlign());
     else
       OS << format(" %" PRId64 "*data_alignment_factor", Operand);
     break;