Sign extend correctly in disassembler

runtime/vm/disassembler_x64.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/disassembler.h"
 
 #include "vm/globals.h"  // Needed here to get TARGET_ARCH_IA32.
 #if defined(TARGET_ARCH_X64)
 #include "platform/utils.h"
 #include "vm/allocation.h"
@@ skipping 339 matching lines @@
   int PrintOperands(const char* mnem, OperandType op_order, uint8_t* data);
 
   typedef const char* (DisassemblerX64::*RegisterNameMapping)(int reg) const;
 
   int PrintRightOperandHelper(uint8_t* modrmp,
                               RegisterNameMapping register_name);
   int PrintRightOperand(uint8_t* modrmp);
   int PrintRightByteOperand(uint8_t* modrmp);
   int PrintRightXMMOperand(uint8_t* modrmp);
   void PrintDisp(int disp, const char* after);
-  int PrintImmediate(uint8_t* data, OperandSize size);
-  void PrintImmediateValue(int64_t value);
+  int PrintImmediate(uint8_t* data, OperandSize size, bool sign_extend = false);
+  void PrintImmediateValue(int64_t value, bool signed_value = false);
   int PrintImmediateOp(uint8_t* data);
   const char* TwoByteMnemonic(uint8_t opcode);
   int TwoByteOpcodeInstruction(uint8_t* data);
 
   int F6F7Instruction(uint8_t* data);
   int ShiftInstruction(uint8_t* data);
   int JumpShort(uint8_t* data);
   int JumpConditional(uint8_t* data);
   int JumpConditionalShort(uint8_t* data);
   int SetCC(uint8_t* data);
@@ skipping 113 matching lines @@
       Print("%s", (this->*register_name)(rm));
       return 1;
     default:
       UnimplementedInstruction();
       return 1;
   }
   UNREACHABLE();
 }
 
 
-int DisassemblerX64::PrintImmediate(uint8_t* data, OperandSize size) {
+int DisassemblerX64::PrintImmediate(uint8_t* data,
+                                    OperandSize size,
+                                    bool sign_extend) {
   int64_t value;
   int count;
   switch (size) {
     case BYTE_SIZE:
-      value = *data;
+      if (sign_extend) {
+        value = *reinterpret_cast<int8_t*>(data);
+      } else {
+        value = *data;
+      }
       count = 1;
       break;
     case WORD_SIZE:
-      value = *reinterpret_cast<int16_t*>(data);
+      if (sign_extend) {
+        value = *reinterpret_cast<int16_t*>(data);
+      } else {
+        value = *reinterpret_cast<uint16_t*>(data);
+      }
       count = 2;
       break;
     case DOUBLEWORD_SIZE:
-      value = *reinterpret_cast<uint32_t*>(data);
-      count = 4;
-      break;
     case QUADWORD_SIZE:
-      value = *reinterpret_cast<int32_t*>(data);
+      if (sign_extend) {
+        value = *reinterpret_cast<int32_t*>(data);
+      } else {
+        value = *reinterpret_cast<uint32_t*>(data);
+      }
       count = 4;
       break;
     default:
       UNREACHABLE();
       value = 0;  // Initialize variables on all paths to satisfy the compiler.
       count = 0;
   }
-  PrintImmediateValue(value);
+  PrintImmediateValue(value, sign_extend);
   return count;
 }
 
-void DisassemblerX64::PrintImmediateValue(int64_t value) {
+void DisassemblerX64::PrintImmediateValue(int64_t value, bool signed_value) {
   if ((value >= 0) && (value <= 9)) {

[sra1, 2017/03/15 17:09:54]

It is nice that 1 prints as "1" and not "0x1"
Perhaps do the same for -1, i.e. "-1" and not "-0x1".

I'd like to see cleaner single digit numbers in x86 too.

     Print("%" Pd64 "", value);
   } else {
-    Print("%#" Px64 "", value);
+    if (value < 0 && signed_value) {
+      Print("-%#" Px64 "", -value);
+    } else {
+      Print("%#" Px64 "", value);
+    }
   }
 }
 
 void DisassemblerX64::PrintDisp(int disp, const char* after) {
   if (-disp > 0) {
     Print("-%#x", -disp);
   } else {
     Print("+%#x", disp);
   }
   if (after != NULL) Print("%s", after);
@@ skipping 33 matching lines @@
     case 7:
       mnem = "cmp";
       break;
     default:
       UnimplementedInstruction();
   }
   Print("%s%c ", mnem, operand_size_code());
   int count = PrintRightOperand(data + 1);
   Print(",");
   OperandSize immediate_size = byte_size_immediate ? BYTE_SIZE : operand_size();
-  count += PrintImmediate(data + 1 + count, immediate_size);
+  count +=
+      PrintImmediate(data + 1 + count, immediate_size, byte_size_immediate);
   return 1 + count;
 }
 
 
 // Returns number of bytes used, including *data.
 int DisassemblerX64::F6F7Instruction(uint8_t* data) {
   ASSERT(*data == 0xF7 || *data == 0xF6);
   uint8_t modrm = *(data + 1);
   int mod, regop, rm;
   get_modrm(modrm, &mod, &regop, &rm);
@@ skipping 1367 matching lines @@
       *object = NULL;
     }
   }
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64