Experiment for updating the tcmalloc chromium branch to r144 (gperftools 2.0).

third_party/tcmalloc/chromium/src/windows/mini_disassembler.cc

 /* Copyright (c) 2007, Google Inc.
  * 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
@@ skipping 82 matching lines @@
   // the instruction gives us the full length of the instruction in bytes.
   instruction_bytes += operand_bytes_ + (current_byte - start_byte);
 
   // Return the instruction type, which was set by ProcessOpcode().
   return instruction_type_;
 }
 
 void MiniDisassembler::Initialize() {
   operand_is_32_bits_ = operand_default_is_32_bits_;
   address_is_32_bits_ = address_default_is_32_bits_;
+#ifdef _M_X64
+  operand_default_support_64_bits_ = true;
+#else
+  operand_default_support_64_bits_ = false;
+#endif
+  operand_is_64_bits_ = false;
   operand_bytes_ = 0;
   have_modrm_ = false;
   should_decode_modrm_ = false;
   instruction_type_ = IT_UNKNOWN;
   got_f2_prefix_ = false;
   got_f3_prefix_ = false;
   got_66_prefix_ = false;
 }
 
 InstructionType MiniDisassembler::ProcessPrefixes(unsigned char* start_byte,
                                                   unsigned int& size) {
   InstructionType instruction_type = IT_GENERIC;
   const Opcode& opcode = s_ia32_opcode_map_[0].table_[*start_byte];
 
   switch (opcode.type_) {
     case IT_PREFIX_ADDRESS:
       address_is_32_bits_ = !address_default_is_32_bits_;
       goto nochangeoperand;
     case IT_PREFIX_OPERAND:
       operand_is_32_bits_ = !operand_default_is_32_bits_;
       nochangeoperand:
     case IT_PREFIX:
 
       if (0xF2 == (*start_byte))
         got_f2_prefix_ = true;
       else if (0xF3 == (*start_byte))
         got_f3_prefix_ = true;
       else if (0x66 == (*start_byte))
         got_66_prefix_ = true;
+      else if (operand_default_support_64_bits_ && (*start_byte) & 0x48)
+        operand_is_64_bits_ = true;
 
       instruction_type = opcode.type_;
       size ++;
       // we got a prefix, so add one and check next byte
       ProcessPrefixes(start_byte + 1, size);
     default:
       break;   // not a prefix byte
   }
 
   return instruction_type;
@@ skipping 165 matching lines @@
         case OT_PD: // Unaligned packed double-precision floating point value
           operand_bytes_ += OS_DOUBLE_PRECISION_FLOATING;
           break;
         case OT_SS:
           // Scalar element of a 128-bit packed single-precision
           // floating data.
           // We simply return enItUnknown since we don't have to support
           // floating point
           succeeded = false;
           break;
-        case OT_V: // Word or doubleword, depending on operand-size attribute.
-          if (operand_is_32_bits_)
+        case OT_V: // Word, doubleword or quadword, depending on operand-size 
+                   // attribute.
+          if (operand_is_64_bits_ && flag_operand & AM_I &&
+              flag_operand & IOS_64)
+            operand_bytes_ += OS_QUAD_WORD;
+          else if (operand_is_32_bits_)
             operand_bytes_ += OS_DOUBLE_WORD;
           else
             operand_bytes_ += OS_WORD;
           break;
         case OT_W: // Word, regardless of operand-size attribute.
           operand_bytes_ += OS_WORD;
           break;
 
         // Can safely ignore these.
         case OT_A: // Two one-word operands in memory or two double-word
@@ skipping 81 matching lines @@
     default:
       break;
     }
   }
 
   size++;
   return true;
 }
 
 };  // namespace sidestep