SSE Assembler and Disassembler support

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 219 matching lines @@
     case 0x31: return "rdtsc";
     case 0xBE: return "movsx_b";
     case 0xBF: return "movsx_w";
     case 0xB6: return "movzx_b";
     case 0xB7: return "movzx_w";
     case 0xAF: return "imul";
     case 0xA5: return "shld";
     case 0xAD: return "shrd";
     case 0xAB: return "bts";
     case 0xB1: return "cmpxchg";
+    case 0x50: return "movmskps";
+    case 0x51: return "sqrtps";
+    case 0x52: return "rqstps";
+    case 0x53: return "rcpps";
+    case 0x54: return "andps";
+    case 0x56: return "orps";
     case 0x57: return "xorps";
+    case 0x58: return "addps";
+    case 0x59: return "mulps";
+    case 0x5C: return "subps";
+    case 0x5D: return "minps";
+    case 0x5E: return "divps";
+    case 0x5F: return "maxps";
     case 0x28: return "movaps";
+    case 0x10: return "movups";
+    case 0x11: return "movups";
     default: return NULL;
   }
 }
 
 
 // The implementation of x86 decoding based on the above tables.
 class X86Decoder : public ValueObject {
  public:
   X86Decoder(char* buffer, intptr_t buffer_size)
       : buffer_(buffer),
@@ skipping 27 matching lines @@
   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 PrintXmmComparison(int comparison);
   void PrintAddress(uword addr);
 
   typedef void (X86Decoder::*RegisterNamePrinter)(int reg);
 
   int PrintRightOperandHelper(uint8_t* modrmp,
                               RegisterNamePrinter register_printer);
   int PrintRightOperand(uint8_t* modrmp);
   int PrintRightXmmOperand(uint8_t* modrmp);
   int PrintRightByteOperand(uint8_t* modrmp);
   int PrintOperands(const char* mnem, OperandOrder op_order, uint8_t* data);
@@ skipping 89 matching lines @@
   UNIMPLEMENTED();
 }
 
 
 void X86Decoder::PrintXmmRegister(int reg) {
   ASSERT(0 <= reg);
   ASSERT(reg < kMaxXmmRegisters);
   Print(xmm_regs[reg]);
 }
 
+void X86Decoder::PrintXmmComparison(int comparison) {
+  ASSERT(0 <= comparison);
+  ASSERT(comparison < 8);
+  static const char* comparisons[8] = {
+    "eq", "lt", "le", "unordered", "not eq", "not lt", "not le", "ordered"
+  };
+  Print(comparisons[comparison]);
+}
+
 
 static const char* ObjectToCStringNoGC(const Object& obj) {
   if (obj.IsSmi() ||
       obj.IsMint() ||
       obj.IsDouble() ||
       obj.IsString() ||
       obj.IsNull() ||
       obj.IsBool() ||
       obj.IsClass() ||
       obj.IsFunction() ||
@@ skipping 922 matching lines @@
             }
           } else if (f0byte == 0x28) {
             // movaps
             Print(f0mnem);
             int mod, regop, rm;
             GetModRm(*data, &mod, &regop, &rm);
             Print(" ");
             PrintXmmRegister(regop);
             Print(",");
             data += PrintRightXmmOperand(data);
+          } else if (f0byte == 0x11) {
+            Print("movups ");
+            int mod, regop, rm;
+            GetModRm(*data, &mod, &regop, &rm);
+            data += PrintRightXmmOperand(data);
+            Print(",");
+            PrintXmmRegister(regop);
+          } else if (f0byte == 0x10) {
+            int mod, regop, rm;
+            GetModRm(*data, &mod, &regop, &rm);
+            Print("movups ");
+            PrintXmmRegister(regop);
+            Print(",");
+            data += PrintRightOperand(data);
+          } else if (f0byte == 0x51 || f0byte == 0x52 || f0byte == 0x53 ||
+                     f0byte == 0x54 || f0byte == 0x56 || f0byte == 0x58 ||
+                     f0byte == 0x59 || f0byte == 0x5C || f0byte == 0x5D ||
+                     f0byte == 0x5E || f0byte == 0x5F) {
+            int mod, regop, rm;
+            GetModRm(*data, &mod, &regop, &rm);
+            Print(f0mnem);
+            Print(" ");
+            PrintXmmRegister(regop);
+            Print(",");
+            data += PrintRightXmmOperand(data);
+          } else if (f0byte == 0x50) {
+            Print("movmskpd ");
+            int mod, regop, rm;
+            GetModRm(*data, &mod, &regop, &rm);
+            PrintCPURegister(regop);
+            Print(",");
+            data += PrintRightXmmOperand(data);
+          } else if (f0byte == 0xC2 || f0byte == 0xC6) {
+            if (f0byte == 0xC2)
+              Print("cmpps ");
+            else
+              Print("shufps ");
+            int mod, regop, rm;
+            GetModRm(*data, &mod, &regop, &rm);
+            Print(" ");
+            PrintXmmRegister(regop);
+            Print(",");
+            data += PrintRightXmmOperand(data);
+            int comparison = *data;
+            Print(" [");
+            PrintHex(comparison);
+            Print("]");
+            data++;
           } else {
             UNIMPLEMENTED();
           }
         }
       }
         break;
 
       case 0x8F:
       { data++;
         int mod, regop, rm;
@@ skipping 370 matching lines @@
                                   human_buffer,
                                   sizeof(human_buffer),
                                   pc);
     pc += instruction_length;
   }
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32