Fixed a bug in isNegate intrinsified code, fixed negation for doubles (handling of negative zeros...

runtime/vm/disassembler_ia32.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_IA32)
 #include "platform/utils.h"
 #include "vm/allocation.h"
@@ skipping 255 matching lines @@
     esp = 4,
     ebp = 5,
     esi = 6,
     edi = 7
   };
 
   // Bottleneck functions to print into the out_buffer.
   void PrintInt(int value);
   void PrintHex(int value);
   void Print(const char* str);
+  const char* GetBranchPrefix(uint8_t** data);
+
+  bool DecodeInstructionType(const InstructionDesc& idesc,
+                             const char* branch_hint,
+                             uint8_t** data);
 
   // Printing of common values.
   void PrintCPURegister(int reg);
   void PrintCPUByteRegister(int reg);
   void PrintXmmRegister(int reg);
   void PrintAddress(uword addr);
 
   typedef void (X86Decoder::*RegisterNamePrinter)(int reg);
 
   int PrintRightOperandHelper(uint8_t* modrmp,
@@ skipping 663 matching lines @@
 void X86Decoder::CheckPrintStop(uint8_t* data) {
   // Recognize stop pattern.
   if (*reinterpret_cast<uint8_t*>(data + 5) == 0xCC) {
     Print("  STOP:'");
     const char* text = *reinterpret_cast<const char **>(data + 1);
     Print(text);
     Print("'");
   }
 }
 
+const char* X86Decoder::GetBranchPrefix(uint8_t** data) {
+  // We use these two prefixes only with branch prediction
+  switch (**data) {
+    case 0x3E:  // ds
+      (*data)++;
+      return "predicted taken";
+    case 0x2E:  // cs
+      (*data)++;
+      return "predicted not taken";
+    case 0xF0:  // lock
+      Print("lock ");
+      (*data)++;
+      return NULL;
+    default:  // Ignore all other instructions.
+      return NULL;
+  }
+}
+
+
+bool X86Decoder::DecodeInstructionType(const InstructionDesc& idesc,
+                                       const char* branch_hint,
+                                       uint8_t** data) {
+  switch (idesc.type) {
+    case ZERO_OPERANDS_INSTR:
+      Print(idesc.mnem);
+      (*data)++;
+      return true;
+
+    case TWO_OPERANDS_INSTR:
+      (*data)++;
+      (*data) += PrintOperands(idesc.mnem, idesc.op_order_, *data);
+      return true;
+
+    case JUMP_CONDITIONAL_SHORT_INSTR:
+      (*data) += JumpConditionalShort(*data, branch_hint);
+      return true;
+
+    case REGISTER_INSTR:
+      Print(idesc.mnem);
+      Print(" ");
+      PrintCPURegister(**data & 0x07);
+      (*data)++;
+      return true;
+
+    case MOVE_REG_INSTR: {
+      uword addr = *reinterpret_cast<uword*>(*data+1);
+      Print("mov ");
+      PrintCPURegister(**data & 0x07),
+      Print(",");
+      PrintAddress(addr);
+      (*data) += 5;
+      return true;
+    }
+
+    case CALL_JUMP_INSTR: {
+      uword addr = reinterpret_cast<uword>(data) +
+                   *reinterpret_cast<uword*>(*data+1) + 5;
+      Print(idesc.mnem);
+      Print(" ");
+      PrintAddress(addr);
+      (*data) += 5;
+      return true;
+    }
+
+    case SHORT_IMMEDIATE_INSTR: {
+      uword addr = *reinterpret_cast<uword*>(*data+1);
+      Print(idesc.mnem);
+      Print(" eax, ");
+      PrintAddress(addr);
+      (*data) += 5;
+      return true;
+    }
+
+    case NO_INSTR:
+      return false;
+
+    default:
+      UNIMPLEMENTED();  // This type is not implemented.
+      return false;
+  }
+}
+
 
 int X86Decoder::InstructionDecode(uword pc) {
   uint8_t* data = reinterpret_cast<uint8_t*>(pc);
   // Check for hints.
-  const char* branch_hint = NULL;
-  // We use these two prefixes only with branch prediction
-  switch (*data) {
-    case 0x3E:  // ds
-      branch_hint = "predicted taken";
-      data++;
-      break;
-    case 0x2E:  // cs
-      branch_hint = "predicted not taken";
-      data++;
-      break;
-    case 0xF0:  // lock
-      Print("lock ");
-      data++;
-      break;
-    default:  // Ignore all other instructions.
-      break;
-  }
-  bool processed = true;  // Will be set to false if the current instruction
+  const char* branch_hint = GetBranchPrefix(&data);
+  const InstructionDesc& idesc = instruction_table.Get(*data);
+  // Will be set to false if the current instruction
   // is not in 'instructions' table.
-  const InstructionDesc& idesc = instruction_table.Get(*data);
-  switch (idesc.type) {
-    case ZERO_OPERANDS_INSTR:
-      Print(idesc.mnem);
-      data++;
-      break;
-
-    case TWO_OPERANDS_INSTR:
-      data++;
-      data += PrintOperands(idesc.mnem, idesc.op_order_, data);
-      break;
-
-    case JUMP_CONDITIONAL_SHORT_INSTR:
-      data += JumpConditionalShort(data, branch_hint);
-      break;
-
-    case REGISTER_INSTR:
-      Print(idesc.mnem);
-      Print(" ");
-      PrintCPURegister(*data & 0x07);
-      data++;
-      break;
-
-    case MOVE_REG_INSTR: {
-      uword addr = *reinterpret_cast<uword*>(data+1);
-      Print("mov ");
-      PrintCPURegister(*data & 0x07),
-      Print(",");
-      PrintAddress(addr);
-      data += 5;
-      break;
-    }
-
-    case CALL_JUMP_INSTR: {
-      uword addr = reinterpret_cast<uword>(data) +
-                   *reinterpret_cast<uword*>(data+1) + 5;
-      Print(idesc.mnem);
-      Print(" ");
-      PrintAddress(addr);
-      data += 5;
-      break;
-    }
-
-    case SHORT_IMMEDIATE_INSTR: {
-      uword addr = *reinterpret_cast<uword*>(data+1);
-      Print(idesc.mnem);
-      Print(" eax, ");
-      PrintAddress(addr);
-      data += 5;
-      break;
-    }
-
-    case NO_INSTR:
-      processed = false;
-      break;
-
-    default:
-      UNIMPLEMENTED();  // This type is not implemented.
-  }
+  bool processed = DecodeInstructionType(idesc, branch_hint, &data);
   //----------------------------
   if (!processed) {
     switch (*data) {
       case 0xC2:
         Print("ret ");
         PrintHex(*reinterpret_cast<uint16_t*>(data+1));
         data += 3;
         break;
 
       case 0x69:  // fall through
@@ skipping 242 matching lines @@
             Print(" ");
             PrintXmmRegister(regop);
             Print(",");
             data += PrintRightXmmOperand(data);
           } else if (*data == 0x1F &&
                      *(data+1) == 0x44 &&
                      *(data+2) == 0x00 &&
                      *(data+3) == 0x00) {
             data += 4;
             Print("nop");
+          } else if (*data == 0x50) {
+            Print("movmskpd ");
+            data++;
+            int mod, regop, rm;
+            GetModRm(*data, &mod, &regop, &rm);
+            PrintCPURegister(regop);
+            Print(",");
+            data += PrintRightXmmOperand(data);
           } else {
             UNIMPLEMENTED();
           }
         } else if (*data == 0x90) {
           data++;
           Print("nop");
         } else {
           UNIMPLEMENTED();
         }
         break;
@@ skipping 261 matching lines @@
                                   human_buffer,
                                   sizeof(human_buffer),
                                   pc);
     pc += instruction_length;
   }
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32