[interpreter] Print bytecode offsets when dumping bytecode.

src/objects.cc

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/objects.h"
 
 #include <cmath>
 #include <iomanip>
 #include <sstream>
 
@@ skipping 14959 matching lines @@
       }
     }
     iterator.Advance();
   }
   return statement_position;
 }
 
 void BytecodeArray::Disassemble(std::ostream& os) {
   os << "Parameter count " << parameter_count() << "\n";
   os << "Frame size " << frame_size() << "\n";
-  Vector<char> buf = Vector<char>::New(50);
 
   const uint8_t* base_address = GetFirstBytecodeAddress();
   interpreter::SourcePositionTableIterator source_positions(
       source_position_table());
   interpreter::BytecodeArrayIterator iterator(handle(this));
   while (!iterator.done()) {
     if (!source_positions.done() &&
         iterator.current_offset() == source_positions.bytecode_offset()) {
       os << std::setw(5) << source_positions.source_position();
       os << (source_positions.is_statement() ? " S> " : " E> ");
       source_positions.Advance();
     } else {
       os << "         ";
     }
     const uint8_t* current_address = base_address + iterator.current_offset();
-    SNPrintF(buf, "%p", current_address);
-    os << buf.start() << " : ";
+    os << reinterpret_cast<const void*>(current_address) << " " << std::setw(4)
+       << iterator.current_offset() << " : ";

[rmcilroy, 2016/03/17 11:29:37]

It's difficult to tell what this looks like when run, but would it be clearer to
make the offset clearly differentated from the address, e.g., putting it in
square brackets both here and below?  Feel free to push back or choose a
different option if it looks better to you.

[Michael Starzinger, 2016/03/17 11:51:14]

I went with this formatting because it is the same that you get for disassembled
machine code (i.e. 4 spaces between address and offset). One alternative
proposal I was thinking about while implementing this was to prefix all offsets
with a certain character everywhere (e.g. the "@" character) so that it is clear
throughout the printout when an offset is printed. Your suggestion with using
square brackets sound like aiming in the same direction and would of course work
for me too.

But I am happy change it to any other format, anything is fine with me. Just let
me know on the example below how you'd like the output to look like. Here is how
the dump looks like at the moment:

$ ./out/ia32.debug/d8 --ignition -e "function f(a) { try { return a ? 1 : 2 }
finally { return 3 } } f(4)" --print-bytecode

[generating bytecode for function: f]
Parameter count 2
Frame size 12
         0x42484708    0 : 81                StackCheck 
         0x42484709    1 : 21 05 fe          Mov <context>, r2
   22 S> 0x4248470c    4 : 1f 08             Ldar a0
         0x4248470e    6 : 6f 06             JumpIfToBooleanFalse #6 (0x42484714
/ 12)
         0x42484710    8 : 01 01             LdaSmi8 #1
         0x42484712   10 : 63 04             Jump #4 (0x42484716 / 14)
         0x42484714   12 : 01 02             LdaSmi8 #2
         0x42484716   14 : 20 ff             Star r1
         0x42484718   16 : 00                LdaZero 
         0x42484719   17 : 20 00             Star r0
         0x4248471b   19 : 63 0e             Jump #14 (0x42484729 / 33)
         0x4248471d   21 : 01 ff             LdaSmi8 #-1
         0x4248471f   23 : 20 00             Star r0
         0x42484721   25 : 63 08             Jump #8 (0x42484729 / 33)
         0x42484723   27 : 20 ff             Star r1
         0x42484725   29 : 01 01             LdaSmi8 #1
         0x42484727   31 : 20 00             Star r0
         0x42484729   33 : 44 ab 00 00 00    CallRuntime [171], r0, #0
         0x4248472e   38 : 20 fe             Star r2
   51 S> 0x42484730   40 : 01 03             LdaSmi8 #3
   62 S> 0x42484732   42 : 84                Return 
         0x42484733   43 : 1f ff             Ldar r1
   62 S> 0x42484735   45 : 84                Return 
         0x42484736   46 : 1f ff             Ldar r1
         0x42484738   48 : 83                ReThrow 
         0x42484739   49 : 02                LdaUndefined 
   62 S> 0x4248473a   50 : 84                Return 
Handler Table (size = 24)
   from   to       hdlr
  (   4,  21)  ->    27 (prediction=0, data=2)

[rmcilroy, 2016/03/17 13:17:08]

@ symbols sound good to me, let's go with that.

[Michael Starzinger, 2016/04/08 13:49:29]

Done.

     interpreter::Bytecodes::Decode(os, current_address, parameter_count());
     if (interpreter::Bytecodes::IsJump(iterator.current_bytecode())) {
-      SNPrintF(buf, " (%p)", base_address + iterator.GetJumpTargetOffset());
-      os << buf.start();
+      const void* jump_target = base_address + iterator.GetJumpTargetOffset();
+      os << " (" << jump_target << " / " << iterator.GetJumpTargetOffset()
+         << ")";
     }
     os << std::endl;
     iterator.Advance();
   }
 
   if (constant_pool()->length() > 0) {
     os << "Constant pool (size = " << constant_pool()->length() << ")\n";
     constant_pool()->Print();
   }
 
@@ skipping 4716 matching lines @@
   if (cell->value() != *new_value) {
     cell->set_value(*new_value);
     Isolate* isolate = cell->GetIsolate();
     cell->dependent_code()->DeoptimizeDependentCodeGroup(
         isolate, DependentCode::kPropertyCellChangedGroup);
   }
 }
 
 }  // namespace internal
 }  // namespace v8