[DebugInfo] Align comments in debug_loc section

[bjope]

Summary

This commit updates the BufferByteStreamer, used by DebugLocStream
to buffer bytes/comments to put in the debug_loc section, to
make sure that the Buffer and Comments vectors are synced.
Previously, when an SLEB128 or ULEB128 was emitted together with
a comment, the vectors could be out-of-sync if the LEB encoding
added several entries to the Buffer vectors, while we only added
a single entry to the Comments vector.

The goal with this is to get the comments in the debug_loc
section in the .s file correctly aligned.

Example (using ARM as target):
Instead of

.byte 144                     @ sub-register DW_OP_regx
.byte 128                     @ 256
.byte 2                       @ DW_OP_piece
.byte 147                     @ 8
.byte 8                       @ sub-register DW_OP_regx
.byte 144                     @ 257
.byte 129                     @ DW_OP_piece
.byte 2                       @ 8
.byte 147                     @
.byte 8                       @

we now get

.byte 144                     @ sub-register DW_OP_regx
.byte 128                     @ 256
.byte 2                       @
.byte 147                     @ DW_OP_piece
.byte 8                       @ 8
.byte 144                     @ sub-register DW_OP_regx
.byte 129                     @ 257
.byte 2                       @
.byte 147                     @ DW_OP_piece
.byte 8                       @ 8

[aprantl]

Looks good, thanks!

llvm/trunk/include/llvm/Support/LEB128.h

 
 #ifndef LLVM_SUPPORT_LEB128_H
 #define LLVM_SUPPORT_LEB128_H
 
 #include "llvm/Support/raw_ostream.h"
 
 namespace llvm {
 
-/// Utility function to encode a SLEB128 value to an output stream.
-inline void encodeSLEB128(int64_t Value, raw_ostream &OS,
+/// Utility function to encode a SLEB128 value to an output stream. Returns
+/// the length in bytes of the encoded value.
+inline unsigned encodeSLEB128(int64_t Value, raw_ostream &OS,
                               unsigned PadTo = 0) {
   bool More;
   unsigned Count = 0;
   do {
     uint8_t Byte = Value & 0x7f;
     // NOTE: this assumes that this signed shift is an arithmetic right shift.
     Value >>= 7;
     More = !((((Value == 0 ) && ((Byte & 0x40) == 0)) ||
               ((Value == -1) && ((Byte & 0x40) != 0))));
     Count++;
     if (More || Count < PadTo)
       Byte |= 0x80; // Mark this byte to show that more bytes will follow.
     OS << char(Byte);
   } while (More);
 
   // Pad with 0x80 and emit a terminating byte at the end.
   if (Count < PadTo) {
     uint8_t PadValue = Value < 0 ? 0x7f : 0x00;
     for (; Count < PadTo - 1; ++Count)
       OS << char(PadValue | 0x80);
     OS << char(PadValue);
+    Count++;
   }
+  return Count;
 }
 
 /// Utility function to encode a SLEB128 value to a buffer. Returns
 /// the length in bytes of the encoded value.
 inline unsigned encodeSLEB128(int64_t Value, uint8_t *p, unsigned PadTo = 0) {
   uint8_t *orig_p = p;
   unsigned Count = 0;
   bool More;
if (Count < PadTo) {
     uint8_t PadValue = Value < 0 ? 0x7f : 0x00;
     for (; Count < PadTo - 1; ++Count)
       *p++ = (PadValue | 0x80);
     *p++ = PadValue;
   }
   return (unsigned)(p - orig_p);
 }
 
-/// Utility function to encode a ULEB128 value to an output stream.
-inline void encodeULEB128(uint64_t Value, raw_ostream &OS,
+/// Utility function to encode a ULEB128 value to an output stream. Returns
+/// the length in bytes of the encoded value.
+inline unsigned encodeULEB128(uint64_t Value, raw_ostream &OS,
                               unsigned PadTo = 0) {
   unsigned Count = 0;
   do {
     uint8_t Byte = Value & 0x7f;
     Value >>= 7;
     Count++;
     if (Value != 0 || Count < PadTo)
       Byte |= 0x80; // Mark this byte to show that more bytes will follow.
     OS << char(Byte);
   } while (Value != 0);
 
   // Pad with 0x80 and emit a null byte at the end.
   if (Count < PadTo) {
     for (; Count < PadTo - 1; ++Count)
       OS << '\x80';
     OS << '\x00';
     Count++;
   }
+  return Count;
 }
 
 /// Utility function to encode a ULEB128 value to a buffer. Returns
 /// the length in bytes of the encoded value.
 inline unsigned encodeULEB128(uint64_t Value, uint8_t *p,
                               unsigned PadTo = 0) {
   uint8_t *orig_p = p;
   unsigned Count = 0;

llvm/trunk/lib/CodeGen/AsmPrinter/ByteStreamer.h

public:
   : Buffer(Buffer), Comments(Comments), GenerateComments(GenerateComments) {}
   void EmitInt8(uint8_t Byte, const Twine &Comment) override {
     Buffer.push_back(Byte);
     if (GenerateComments)
       Comments.push_back(Comment.str());
   }
   void EmitSLEB128(uint64_t DWord, const Twine &Comment) override {
     raw_svector_ostream OSE(Buffer);
-    encodeSLEB128(DWord, OSE);
-    if (GenerateComments)
+    unsigned Length = encodeSLEB128(DWord, OSE);
+    if (GenerateComments) {
       Comments.push_back(Comment.str());
+      // Add some empty comments to keep the Buffer and Comments vectors aligned
+      // with each other.
+      for (size_t i = 1; i < Length; ++i)
+        Comments.push_back("");
+
+    }
   }
   void EmitULEB128(uint64_t DWord, const Twine &Comment) override {
     raw_svector_ostream OSE(Buffer);
-    encodeULEB128(DWord, OSE);
-    if (GenerateComments)
+    unsigned Length = encodeULEB128(DWord, OSE);
+    if (GenerateComments) {
       Comments.push_back(Comment.str());
+      // Add some empty comments to keep the Buffer and Comments vectors aligned
+      // with each other.
+      for (size_t i = 1; i < Length; ++i)
+        Comments.push_back("");
+
+    }
   }
 };
 
 }
 
 #endif

llvm/trunk/test/CodeGen/ARM/debug-info-qreg.ll

 ; RUN: llc < %s - | FileCheck %s
 target datalayout = "e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:32-f32:32:32-f64:32:32-v64:32:64-v128:32:128-a0:0:32-n32"
 target triple = "thumbv7-apple-macosx10.6.7"
 
 ;CHECK: sub-register DW_OP_regx
 ;CHECK-NEXT: 256
+;CHECK-NEXT: @
 ;CHECK-NEXT: DW_OP_piece
 ;CHECK-NEXT: 8
 ;CHECK-NEXT: sub-register DW_OP_regx
 ;CHECK-NEXT: 257
+;CHECK-NEXT: @
 ;CHECK-NEXT: DW_OP_piece
 ;CHECK-NEXT: 8
 
 @.str = external constant [13 x i8]
 
 declare <4 x float> @test0001(float) nounwind readnone ssp
 
 define i32 @main(i32 %argc, i8** nocapture %argv) nounwind ssp !dbg !10 {

llvm/trunk/test/DebugInfo/X86/dw_op_minus.ll

 ; RCX is clobbered in call @Capture, but there is a spilled copy.
 ; *(RSP + 8) - 400
 ; CHECK:      .short  7                       # Loc expr size
 ; CHECK-NEXT: .byte 119                     # DW_OP_breg7
 ; CHECK-NEXT: .byte 8                       # 8
 ; CHECK-NEXT: .byte 6                       # DW_OP_deref
 ; CHECK-NEXT: .byte 16                      # DW_OP_constu
 ; CHECK-NEXT: .byte 144                     # 400
-; CHECK-NEXT: .byte 3                       # DW_OP_minus
-; CHECK-NEXT: .byte 28
+; CHECK-NEXT: .byte 3                       #
+; CHECK-NEXT: .byte 28                      # DW_OP_minus