move sleb printing out of asmprinter into dwarf printer, make clients

handle the comment better, MCize the non-.sleb case.



git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@94244 91177308-0d34-0410-b5e6-96231b3b80d8

include/llvm/CodeGen/AsmPrinter.h

@@ -252,10 +252,6 @@ namespace llvm {
     /// representing an unsigned leb128 value.
     void PrintULEB128(unsigned Value) const;
 
-    /// PrintSLEB128 - Print a series of hexidecimal values(separated by commas)
-    /// representing a signed leb128 value.
-    void PrintSLEB128(int Value) const;
-
     //===------------------------------------------------------------------===//
     // Emission and print routines
     //
@@ -263,16 +259,11 @@ namespace llvm {
     /// EOL - Print a newline character to asm stream.  If a comment is present
     /// then it will be printed first.  Comments should not contain '\n'.
     void EOL(const Twine &Comment) const;
-    void EOL(const Twine &Comment, unsigned Encoding) const;
 
     /// EmitULEB128Bytes - Emit an assembler byte data directive to compose an
     /// unsigned leb128 value.
     void EmitULEB128Bytes(unsigned Value) const;
     
-    /// EmitSLEB128Bytes - print an assembler byte data directive to compose a
-    /// signed leb128 value.
-    void EmitSLEB128Bytes(int Value) const;
-    
     /// EmitInt8 - Emit a byte directive and value.
     ///
     void EmitInt8(int Value) const;

lib/CodeGen/AsmPrinter/AsmPrinter.cpp

@@ -672,22 +672,6 @@ void AsmPrinter::PrintULEB128(unsigned Value) const {
   } while (Value);
 }
 
-/// PrintSLEB128 - Print a series of hexadecimal values (separated by commas)
-/// representing a signed leb128 value.
-void AsmPrinter::PrintSLEB128(int Value) const {
-  int Sign = Value >> (8 * sizeof(Value) - 1);
-  bool IsMore;
-
-  do {
-    unsigned char Byte = static_cast<unsigned char>(Value & 0x7f);
-    Value >>= 7;
-    IsMore = Value != Sign || ((Byte ^ Sign) & 0x40) != 0;
-    if (IsMore) Byte |= 0x80;
-    O << "0x";
-    O.write_hex(Byte);
-    if (IsMore) O << ", ";
-  } while (IsMore);
-}
 
 //===--------------------------------------------------------------------===//
 // Emission and print routines
@@ -707,26 +691,13 @@ void AsmPrinter::EOL(const Twine &Comment) const {
 /// unsigned leb128 value.
 void AsmPrinter::EmitULEB128Bytes(unsigned Value) const {
   if (MAI->hasLEB128()) {
-    O << "\t.uleb128\t"
-      << Value;
+    O << "\t.uleb128\t" << Value;
   } else {
     O << MAI->getData8bitsDirective();
     PrintULEB128(Value);
   }
 }
 
-/// EmitSLEB128Bytes - print an assembler byte data directive to compose a
-/// signed leb128 value.
-void AsmPrinter::EmitSLEB128Bytes(int Value) const {
-  if (MAI->hasLEB128()) {
-    O << "\t.sleb128\t"
-      << Value;
-  } else {
-    O << MAI->getData8bitsDirective();
-    PrintSLEB128(Value);
-  }
-}
-
 /// EmitInt8 - Emit a byte directive and value.
 ///
 void AsmPrinter::EmitInt8(int Value) const {

lib/CodeGen/AsmPrinter/DIE.cpp

@@ -200,7 +200,7 @@ void DIEInteger::EmitValue(DwarfPrinter *D, unsigned Form) const {
   case dwarf::DW_FORM_ref8:  // Fall thru
   case dwarf::DW_FORM_data8: Size = 8; break;
   case dwarf::DW_FORM_udata: Asm->EmitULEB128Bytes(Integer); return;
-  case dwarf::DW_FORM_sdata: Asm->EmitSLEB128Bytes(Integer); return;
+  case dwarf::DW_FORM_sdata: D->EmitSLEB128(Integer, ""); return;
   default: llvm_unreachable("DIE Value form not supported yet");
   }
   Asm->OutStreamer.EmitIntValue(Integer, Size, 0/*addrspace*/);

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

@@ -2624,7 +2624,7 @@ void DwarfDebug::emitDebugLines() {
           // ... otherwise use long hand.
           Asm->EmitInt8(dwarf::DW_LNS_advance_line);
           Asm->EOL("DW_LNS_advance_line");
-          Asm->EmitSLEB128Bytes(Offset); Asm->EOL("Line Offset");
+          EmitSLEB128(Offset, "Line Offset");
           Asm->EmitInt8(dwarf::DW_LNS_copy); Asm->EOL("DW_LNS_copy");
         }
       } else {
@@ -2675,8 +2675,7 @@ void DwarfDebug::emitCommonDebugFrame() {
   Asm->EOL("CIE Augmentation");
   Asm->EmitULEB128Bytes(1);
   Asm->EOL("CIE Code Alignment Factor");
-  Asm->EmitSLEB128Bytes(stackGrowth);
-  Asm->EOL("CIE Data Alignment Factor");
+  EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
   Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
   Asm->EOL("CIE RA Column");
 

lib/CodeGen/AsmPrinter/DwarfException.cpp

@@ -177,8 +177,7 @@ void DwarfException::EmitCIE(const Function *PersonalityFn, unsigned Index) {
   // Round out reader.
   Asm->EmitULEB128Bytes(1);
   Asm->EOL("CIE Code Alignment Factor");
-  Asm->EmitSLEB128Bytes(stackGrowth);
-  Asm->EOL("CIE Data Alignment Factor");
+  EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
   Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), true));
   Asm->EOL("CIE Return Address Column");
 
@@ -894,17 +893,13 @@ void DwarfException::EmitExceptionTable() {
     //
     //   Used by the runtime to match the type of the thrown exception to the
     //   type of the catch clauses or the types in the exception specification.
-
-    Asm->EmitSLEB128Bytes(Action.ValueForTypeID);
-    Asm->EOL("TypeInfo index");
+    EmitSLEB128(Action.ValueForTypeID, "TypeInfo index");
 
     // Action Record
     //
     //   Self-relative signed displacement in bytes of the next action record,
     //   or 0 if there is no next action record.
-
-    Asm->EmitSLEB128Bytes(Action.NextAction);
-    Asm->EOL("Next action");
+    EmitSLEB128(Action.NextAction, "Next action");
   }
 
   // Emit the Catch TypeInfos.

lib/CodeGen/AsmPrinter/DwarfPrinter.cpp

@@ -85,6 +85,36 @@ void DwarfPrinter::EmitEncodingByte(unsigned Val, const char *Desc) {
   Asm->OutStreamer.EmitIntValue(Val, 1, 0/*addrspace*/);
 }
 
+/// PrintSLEB128 - Print a series of hexadecimal values (separated by commas)
+/// representing a signed leb128 value.
+static void PrintSLEB128(MCStreamer &O, int Value) {
+  int Sign = Value >> (8 * sizeof(Value) - 1);
+  bool IsMore;
+  
+  do {
+    unsigned char Byte = static_cast<unsigned char>(Value & 0x7f);
+    Value >>= 7;
+    IsMore = Value != Sign || ((Byte ^ Sign) & 0x40) != 0;
+    if (IsMore) Byte |= 0x80;
+    
+    O.EmitIntValue(Byte, 1, /*addrspace*/0);
+  } while (IsMore);
+}
+
+/// EmitSLEB128 - print the specified signed leb128 value.
+void DwarfPrinter::EmitSLEB128(int Value, const char *Desc) const {
+  if (Asm->VerboseAsm && Desc)
+    Asm->OutStreamer.AddComment(Desc);
+    
+  if (MAI->hasLEB128()) {
+    O << "\t.sleb128\t" << Value;
+    Asm->OutStreamer.AddBlankLine();
+  } else {
+    PrintSLEB128(Asm->OutStreamer, Value);
+  }
+}
+
+
 
 /// PrintLabelName - Print label name in form used by Dwarf writer.
 ///
@@ -267,8 +297,7 @@ void DwarfPrinter::EmitFrameMoves(const char *BaseLabel, unsigned BaseLabelID,
         Asm->EOL("DW_CFA_offset_extended_sf");
         Asm->EmitULEB128Bytes(Reg);
         Asm->EOL("Reg");
-        Asm->EmitSLEB128Bytes(Offset);
-        Asm->EOL("Offset");
+        EmitSLEB128(Offset, "Offset");
       } else if (Reg < 64) {
         Asm->EmitInt8(dwarf::DW_CFA_offset + Reg);
         Asm->EOL("DW_CFA_offset + Reg (" + Twine(Reg) + ")");

lib/CodeGen/AsmPrinter/DwarfPrinter.h

@@ -87,11 +87,14 @@ public:
 
   /// EmitEncodingByte - Emit a .byte 42 directive that corresponds to an
   /// encoding.  If verbose assembly output is enabled, we output comments
-  /// describing the encoding.  Desc is an optional string saying what the
-  /// encoding is specifying (e.g. "LSDA").
-  void EmitEncodingByte(unsigned Val, const char *Desc = 0);
+  /// describing the encoding.  Desc is a string saying what the encoding is
+  /// specifying (e.g. "LSDA").
+  void EmitEncodingByte(unsigned Val, const char *Desc);
+  
+  /// EmitSLEB128 - print the specified signed leb128 value.
+  void EmitSLEB128(int Value, const char *Desc) const;
+  
   
-
   /// PrintLabelName - Print label name in form used by Dwarf writer.
   ///
   void PrintLabelName(const DWLabel &Label) const {