Import ConditionVariable class.

src/x64/disasm-x64.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 314 matching lines @@
 
   virtual ~DisassemblerX64() {
   }
 
   // Writes one disassembled instruction into 'buffer' (0-terminated).
   // Returns the length of the disassembled machine instruction in bytes.
   int InstructionDecode(v8::internal::Vector<char> buffer, byte* instruction);
 
  private:
   enum OperandSize {
-    BYTE_SIZE = 0,
-    WORD_SIZE = 1,
-    DOUBLEWORD_SIZE = 2,
-    QUADWORD_SIZE = 3
+    kByteSize = 0,
+    kWordSize = 1,

[Michael Starzinger, 2013/09/02 19:12:43]

nit: This makes it look like these are constants that actually specify the size
in bytes, which is not the case, as they are just enums. Can we instead call
them OPERAND_BYTE_SIZE, OPERAND_WORD_SIZE and so on?

[Benedikt Meurer, 2013/09/03 07:27:39]

Done.

+    kDoublewordSize = 2,
+    kQuadwordSize = 3
   };
 
   const NameConverter& converter_;
   v8::internal::EmbeddedVector<char, 128> tmp_buffer_;
   unsigned int tmp_buffer_pos_;
   bool abort_on_unimplemented_;
   // Prefixes parsed
   byte rex_;
   byte operand_size_;  // 0x66 or (if no group 3 prefix is present) 0x0.
   byte group_1_prefix_;  // 0xF2, 0xF3, or (if no group 1 prefix is present) 0.
@@ skipping 13 matching lines @@
   // Actual number of base register given the low bits and the rex.b state.
   int base_reg(int low_bits) { return low_bits | ((rex_ & 0x01) << 3); }
 
   bool rex_x() { return (rex_ & 0x02) != 0; }
 
   bool rex_r() { return (rex_ & 0x04) != 0; }
 
   bool rex_w() { return (rex_ & 0x08) != 0; }
 
   OperandSize operand_size() {
-    if (byte_size_operand_) return BYTE_SIZE;
-    if (rex_w()) return QUADWORD_SIZE;
-    if (operand_size_ != 0) return WORD_SIZE;
-    return DOUBLEWORD_SIZE;
+    if (byte_size_operand_) return kByteSize;
+    if (rex_w()) return kQuadwordSize;
+    if (operand_size_ != 0) return kWordSize;
+    return kDoublewordSize;
   }
 
   char operand_size_code() {
     return "bwlq"[operand_size()];
   }
 
   const char* NameOfCPURegister(int reg) const {
     return converter_.NameOfCPURegister(reg);
   }
 
@@ skipping 169 matching lines @@
       return 1;
   }
   UNREACHABLE();
 }
 
 
 int DisassemblerX64::PrintImmediate(byte* data, OperandSize size) {
   int64_t value;
   int count;
   switch (size) {
-    case BYTE_SIZE:
+    case kByteSize:
       value = *data;
       count = 1;
       break;
-    case WORD_SIZE:
+    case kWordSize:
       value = *reinterpret_cast<int16_t*>(data);
       count = 2;
       break;
-    case DOUBLEWORD_SIZE:
+    case kDoublewordSize:
       value = *reinterpret_cast<uint32_t*>(data);
       count = 4;
       break;
-    case QUADWORD_SIZE:
+    case kQuadwordSize:
       value = *reinterpret_cast<int32_t*>(data);
       count = 4;
       break;
     default:
       UNREACHABLE();
       value = 0;  // Initialize variables on all paths to satisfy the compiler.
       count = 0;
   }
   AppendToBuffer("%" V8_PTR_PREFIX "x", value);
   return count;
@@ skipping 87 matching lines @@
       break;
     case 7:
       mnem = "cmp";
       break;
     default:
       UnimplementedInstruction();
   }
   AppendToBuffer("%s%c ", mnem, operand_size_code());
   int count = PrintRightOperand(data + 1);
   AppendToBuffer(",0x");
-  OperandSize immediate_size = byte_size_immediate ? BYTE_SIZE : operand_size();
+  OperandSize immediate_size = byte_size_immediate ? kByteSize : operand_size();
   count += PrintImmediate(data + 1 + count, immediate_size);
   return 1 + count;
 }
 
 
 // Returns number of bytes used, including *data.
 int DisassemblerX64::F6F7Instruction(byte* data) {
   ASSERT(*data == 0xF7 || *data == 0xF6);
   byte modrm = *(data + 1);
   int mod, regop, rm;
@@ skipping 712 matching lines @@
       break;
     case PUSHPOP_INSTR:
       AppendToBuffer("%s %s",
                      idesc.mnem,
                      NameOfCPURegister(base_reg(current & 0x07)));
       data++;
       break;
     case MOVE_REG_INSTR: {
       byte* addr = NULL;
       switch (operand_size()) {
-        case WORD_SIZE:
+        case kWordSize:
           addr = reinterpret_cast<byte*>(*reinterpret_cast<int16_t*>(data + 1));
           data += 3;
           break;
-        case DOUBLEWORD_SIZE:
+        case kDoublewordSize:
           addr = reinterpret_cast<byte*>(*reinterpret_cast<int32_t*>(data + 1));
           data += 5;
           break;
-        case QUADWORD_SIZE:
+        case kQuadwordSize:
           addr = reinterpret_cast<byte*>(*reinterpret_cast<int64_t*>(data + 1));
           data += 9;
           break;
         default:
           UNREACHABLE();
       }
       AppendToBuffer("mov%c %s,%s",
                      operand_size_code(),
                      NameOfCPURegister(base_reg(current & 0x07)),
                      NameOfAddress(addr));
@@ skipping 184 matching lines @@
       case 0xBF: {
         // mov reg8,imm8 or mov reg32,imm32
         byte opcode = *data;
         data++;
         bool is_32bit = (opcode >= 0xB8);
         int reg = (opcode & 0x7) | (rex_b() ? 8 : 0);
         if (is_32bit) {
           AppendToBuffer("mov%c %s, ",
                          operand_size_code(),
                          NameOfCPURegister(reg));
-          data += PrintImmediate(data, DOUBLEWORD_SIZE);
+          data += PrintImmediate(data, kDoublewordSize);
         } else {
           AppendToBuffer("movb %s, ",
                          NameOfByteCPURegister(reg));
-          data += PrintImmediate(data, BYTE_SIZE);
+          data += PrintImmediate(data, kByteSize);
         }
         break;
       }
       case 0xFE: {
         data++;
         int mod, regop, rm;
         get_modrm(*data, &mod, &regop, &rm);
         if (regop == 1) {
           AppendToBuffer("decb ");
           data += PrintRightByteOperand(data);
         } else {
           UnimplementedInstruction();
         }
         break;
       }
       case 0x68:
         AppendToBuffer("push 0x%x", *reinterpret_cast<int32_t*>(data + 1));
         data += 5;
         break;
 
       case 0x6A:
         AppendToBuffer("push 0x%x", *reinterpret_cast<int8_t*>(data + 1));
         data += 2;
         break;
 
       case 0xA1:  // Fall through.
       case 0xA3:
         switch (operand_size()) {
-          case DOUBLEWORD_SIZE: {
+          case kDoublewordSize: {
             const char* memory_location = NameOfAddress(
                 reinterpret_cast<byte*>(
                     *reinterpret_cast<int32_t*>(data + 1)));
             if (*data == 0xA1) {  // Opcode 0xA1
               AppendToBuffer("movzxlq rax,(%s)", memory_location);
             } else {  // Opcode 0xA3
               AppendToBuffer("movzxlq (%s),rax", memory_location);
             }
             data += 5;
             break;
           }
-          case QUADWORD_SIZE: {
+          case kQuadwordSize: {
             // New x64 instruction mov rax,(imm_64).
             const char* memory_location = NameOfAddress(
                 *reinterpret_cast<byte**>(data + 1));
             if (*data == 0xA1) {  // Opcode 0xA1
               AppendToBuffer("movq rax,(%s)", memory_location);
             } else {  // Opcode 0xA3
               AppendToBuffer("movq (%s),rax", memory_location);
             }
             data += 9;
             break;
           }
           default:
             UnimplementedInstruction();
             data += 2;
         }
         break;
 
       case 0xA8:
         AppendToBuffer("test al,0x%x", *reinterpret_cast<uint8_t*>(data + 1));
         data += 2;
         break;
 
       case 0xA9: {
         int64_t value = 0;
         switch (operand_size()) {
-          case WORD_SIZE:
+          case kWordSize:
             value = *reinterpret_cast<uint16_t*>(data + 1);
             data += 3;
             break;
-          case DOUBLEWORD_SIZE:
+          case kDoublewordSize:
             value = *reinterpret_cast<uint32_t*>(data + 1);
             data += 5;
             break;
-          case QUADWORD_SIZE:
+          case kQuadwordSize:
             value = *reinterpret_cast<int32_t*>(data + 1);
             data += 5;
             break;
           default:
             UNREACHABLE();
         }
         AppendToBuffer("test%c rax,0x%" V8_PTR_PREFIX "x",
                        operand_size_code(),
                        value);
         break;
@@ skipping 161 matching lines @@
     for (int i = 6 - static_cast<int>(pc - prev_pc); i >= 0; i--) {
       fprintf(f, "  ");
     }
     fprintf(f, "  %s\n", buffer.start());
   }
 }
 
 }  // namespace disasm
 
 #endif  // V8_TARGET_ARCH_X64