Add fast 64-bit integer ADD and SUB to the optimizing compiler.

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 17 matching lines @@
   const char* mnem;
   OperandOrder op_order_;
 };
 
 
 static ByteMnemonic two_operands_instr[] = {
   {0x01, "add", OPER_REG_OP_ORDER},
   {0x03, "add", REG_OPER_OP_ORDER},
   {0x09, "or", OPER_REG_OP_ORDER},
   {0x0B, "or", REG_OPER_OP_ORDER},
+  {0x11, "adc", OPER_REG_OP_ORDER},
   {0x13, "adc", REG_OPER_OP_ORDER},
+  {0x19, "sbb", OPER_REG_OP_ORDER},
   {0x1B, "sbb", REG_OPER_OP_ORDER},
   {0x21, "and", OPER_REG_OP_ORDER},
   {0x23, "and", REG_OPER_OP_ORDER},
   {0x29, "sub", OPER_REG_OP_ORDER},
   {0x2B, "sub", REG_OPER_OP_ORDER},
   {0x31, "xor", OPER_REG_OP_ORDER},
   {0x33, "xor", REG_OPER_OP_ORDER},
   {0x39, "cmp", OPER_REG_OP_ORDER},
   {0x3B, "cmp", REG_OPER_OP_ORDER},
   {0x85, "test", REG_OPER_OP_ORDER},
@@ skipping 247 matching lines @@
   int PrintOperands(const char* mnem, OperandOrder op_order, uint8_t* data);
   int PrintImmediateOp(uint8_t* data);
 
   // Handle special encodings.
   int JumpShort(uint8_t* data);
   int JumpConditional(uint8_t* data, const char* comment);
   int JumpConditionalShort(uint8_t* data, const char* comment);
   int SetCC(uint8_t* data);
   int CMov(uint8_t* data);
   int D1D3C1Instruction(uint8_t* data);
+  uint8_t* F3Instruction(uint8_t* data);
   int F7Instruction(uint8_t* data);
   int FPUInstruction(uint8_t* data);
   int BitwisePDInstruction(uint8_t* data);
   int Packed660F38Instruction(uint8_t* data);
   int DecodeEnter(uint8_t* data);
   void CheckPrintStop(uint8_t* data);
 
   // Disassembler helper functions.
   static void GetModRm(uint8_t data, int* mod, int* regop, int* rm) {
     *mod = (data >> 6) & 3;
@@ skipping 485 matching lines @@
     } else {
       Print("cl");
     }
   } else {
     UNIMPLEMENTED();
   }
   return num_bytes;
 }
 
 
+uint8_t* X86Decoder::F3Instruction(uint8_t* data) {
+  if (*(data+1) == 0x0F) {
+    uint8_t b2 = *(data+2);
+    switch (b2) {
+      case 0x2C: {
+        data += 3;
+        data += PrintOperands("cvttss2si", REG_OPER_OP_ORDER, data);
+        break;
+      }
+      case 0x2A: {
+        data += 3;
+        int mod, regop, rm;
+        GetModRm(*data, &mod, &regop, &rm);
+        Print("cvtsi2ss ");
+        PrintXmmRegister(regop);
+        Print(",");
+        data += PrintRightOperand(data);
+        break;
+      }
+      case 0x2D: {
+        data += 3;
+        int mod, regop, rm;
+        GetModRm(*data, &mod, &regop, &rm);
+        Print("cvtss2si ");
+        PrintCPURegister(regop);
+        Print(",");
+        data += PrintRightXmmOperand(data);
+        break;
+      }
+      case 0x11: {
+        // movss xmm <- address
+        Print("movss ");
+        data += 3;
+        int mod, regop, rm;
+        GetModRm(*data, &mod, &regop, &rm);
+        data += PrintRightXmmOperand(data);
+        Print(",");
+        PrintXmmRegister(regop);
+        break;
+      }
+      case 0x10: {
+        // movss address <- xmm
+        data += 3;
+        int mod, regop, rm;
+        GetModRm(*data, &mod, &regop, &rm);
+        Print("movss ");
+        PrintXmmRegister(regop);
+        Print(",");
+        data += PrintRightOperand(data);
+        break;
+      }
+      case 0x51:  // Fall through.
+      case 0x58:  // Fall through.
+      case 0x59:  // Fall through.
+      case 0x5A:  // Fall through.
+      case 0x5C:  // Fall through.
+      case 0x5E:  // Fall through.
+      case 0xE6: {
+        // divss xmm, xmm
+        data += 3;
+        int mod, regop, rm;
+        GetModRm(*data, &mod, &regop, &rm);
+        const char* mnem = "?? 0xF3";
+        switch (b2) {
+          case 0x51: mnem = "sqrtss"; break;
+          case 0x58: mnem = "addss"; break;
+          case 0x59: mnem = "mulss"; break;
+          case 0x5A: mnem = "cvtss2sd"; break;
+          case 0x5C: mnem = "subss"; break;
+          case 0x5E: mnem = "divss"; break;
+          case 0xE6: mnem = "cvtdq2pd"; break;
+          default: UNIMPLEMENTED();
+        }
+        Print(mnem);
+        Print(" ");
+        PrintXmmRegister(regop);
+        Print(",");
+        data += PrintRightXmmOperand(data);
+        break;
+      }
+      case 0x7E: {
+        data += 3;
+        int mod, regop, rm;
+        GetModRm(*data, &mod, &regop, &rm);
+        Print("movq ");
+        PrintXmmRegister(regop);
+        Print(",");
+        data += PrintRightOperand(data);
+        break;
+      }
+      default:
+        UNIMPLEMENTED();
+    }
+  }
+  return data;
+}
+
+
 // Returns number of bytes used, including *data.
 int X86Decoder::F7Instruction(uint8_t* data) {
   ASSERT(*data == 0xF7);
   uint8_t modrm = *(data+1);
   int mod, regop, rm;
   GetModRm(modrm, &mod, &regop, &rm);
   if (mod == 3 && regop != 0) {
     const char* mnem = NULL;
     switch (regop) {
       case 2: mnem = "not"; break;
@@ skipping 544 matching lines @@
             data++;
           } else if (*data == 0X7E) {
             data++;
             int mod, regop, rm;
             GetModRm(*data, &mod, &regop, &rm);
             Print("movd ");
             PrintCPURegister(rm);
             Print(",");
             PrintXmmRegister(regop);
             data++;
+          } else if (*data == 0xD6) {
+            data++;
+            int mod, regop, rm;
+            GetModRm(*data, &mod, &regop, &rm);
+            Print("movq ");
+            data += PrintRightOperand(data);
+            Print(",");
+            PrintXmmRegister(regop);
           } else if (*data == 0x57 || *data == 0x56 || *data == 0x54) {
             data += BitwisePDInstruction(data);
           } else if (*data == 0x1F &&
                      *(data+1) == 0x44 &&
                      *(data+2) == 0x00 &&
                      *(data+3) == 0x00) {
             data += 4;
             Print("nop");
           } else if (*data == 0x50) {
             Print("movmskpd ");
@@ skipping 81 matching lines @@
       case 0xDE:  // fall through
       case 0xDF:
         data += FPUInstruction(data);
         break;
 
       case 0xEB:
         data += JumpShort(data);
         break;
 
       case 0xF3:
-        if (*(data+1) == 0x0F) {
-          uint8_t b2 = *(data+2);
-          switch (b2) {
-            case 0x2C: {
-              data += 3;
-              data += PrintOperands("cvttss2si", REG_OPER_OP_ORDER, data);
-              break;
-            }
-            case 0x2A: {
-              data += 3;
-              int mod, regop, rm;
-              GetModRm(*data, &mod, &regop, &rm);
-              Print("cvtsi2ss ");
-              PrintXmmRegister(regop);
-              Print(",");
-              data += PrintRightOperand(data);
-              break;
-            }
-            case 0x2D: {
-              data += 3;
-              int mod, regop, rm;
-              GetModRm(*data, &mod, &regop, &rm);
-              Print("cvtss2si ");
-              PrintCPURegister(regop);
-              Print(",");
-              data += PrintRightXmmOperand(data);
-              break;
-            }
-            case 0x11: {
-              // movss xmm <- address
-              Print("movss ");
-              data += 3;
-              int mod, regop, rm;
-              GetModRm(*data, &mod, &regop, &rm);
-              data += PrintRightXmmOperand(data);
-              Print(",");
-              PrintXmmRegister(regop);
-              break;
-            }
-            case 0x10: {
-              // movss address <- xmm
-              data += 3;
-              int mod, regop, rm;
-              GetModRm(*data, &mod, &regop, &rm);
-              Print("movss ");
-              PrintXmmRegister(regop);
-              Print(",");
-              data += PrintRightOperand(data);
-              break;
-            }
-            case 0x51:  // Fall through.
-            case 0x58:  // Fall through.
-            case 0x59:  // Fall through.
-            case 0x5A:  // Fall through.
-            case 0x5C:  // Fall through.
-            case 0x5E:  // Fall through.
-            case 0xE6: {
-              // divss xmm, xmm
-              data += 3;
-              int mod, regop, rm;
-              GetModRm(*data, &mod, &regop, &rm);
-              const char* mnem = "?? 0xF3";
-              switch (b2) {
-                case 0x51: mnem = "sqrtss"; break;
-                case 0x58: mnem = "addss"; break;
-                case 0x59: mnem = "mulss"; break;
-                case 0x5A: mnem = "cvtss2sd"; break;
-                case 0x5C: mnem = "subss"; break;
-                case 0x5E: mnem = "divss"; break;
-                case 0xE6: mnem = "cvtdq2pd"; break;
-                default: UNIMPLEMENTED();
-              }
-              Print(mnem);
-              Print(" ");
-              PrintXmmRegister(regop);
-              Print(",");
-              data += PrintRightXmmOperand(data);
-              break;
-            }
-            default:
-              UNIMPLEMENTED();
-          }
-        }
+        data = F3Instruction(data);
         break;
       case 0xF2: {
         if (*(data+1) == 0x0F) {
           uint8_t b2 = *(data+2);
           if (b2 == 0x11) {
             Print("movsd ");
             data += 3;
             int mod, regop, rm;
             GetModRm(*data, &mod, &regop, &rm);
             data += PrintRightXmmOperand(data);
@@ skipping 116 matching lines @@
                                   human_buffer,
                                   sizeof(human_buffer),
                                   pc);
     pc += instruction_length;
   }
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32