GCC 4.6 warnings cleanup

x86_decode.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "x86_decode.h"
 
 namespace playground {
 
 #if defined(__x86_64__) || defined(__i386__)
 unsigned short next_inst(const char **ip, bool is64bit, bool *has_prefix,
@@ skipping 152 matching lines @@
   }
   unsigned char type;
   unsigned short insn = byte;
   unsigned int idx = 0;
   if (byte == 0x0F) {
     byte = *insn_ptr++;
     insn = (insn << 8) | byte;
     idx  = 256;
   }
   type = opcode_types[idx + byte];
-  bool found_mod_rm = false;

[Markus (顧孟勤), 2011/09/16 16:07:32]

While currently unused, these statements actually help document important parts
of the code, and they might be helpful in future versions of the code.

I'd prefer if we could leave them in the code.

Can we do something to make gcc not warn about them?

   bool found_group = false;
-  bool found_sib = false;
   unsigned char mod_rm = 0;
   unsigned char sib = 0;
   if (type & GROUP) {
-    found_mod_rm = true;
     found_group = true;
     mod_rm = *insn_ptr;
     if (mod_rm_ptr) {
       *mod_rm_ptr = (char *)insn_ptr;
     }
     unsigned char group = (type & GROUP_MASK) + ((mod_rm >> 3) & 0x7);
     if ((type & GROUP_MASK) == 40 && (mod_rm >> 6) == 3) {
       group += 8;
     }
     type = group_table[group];
@@ skipping 12 matching lines @@
     //      ptr < insn_ptr; ) {
     //   std::cerr << std::hex << std::uppercase << std::setw(2) <<
     //       std::setfill('0') << (unsigned int)*ptr++ << ' ';
     // }
     // std::cerr << "]" << std::endl;
   } else {
     if (is64bit && (type & STACK)) {
       operand_width = 8;
     }
     if (type & MOD_RM) {
-      found_mod_rm = true;
       if (mod_rm_ptr) {
         *mod_rm_ptr = (char *)insn_ptr;
       }
       mod_rm = *insn_ptr++;
       int mod = (mod_rm >> 6) & 0x3;
       int rm  = 8*(rex & REX_B) + (mod_rm & 0x7);
       if (mod != 3) {
         if (address_width == 2) {
           switch (mod) {
             case 0:
               if (rm != 6 /* SI */) {
                 break;
               }
               // fall through
             case 2:
               insn_ptr++;
               // fall through
             case 1:
               insn_ptr++;
               break;
           }
         } else {
           if ((rm & 0x7) == 4) {
-            found_sib = true;
             if (sib_ptr) {
               *sib_ptr = (char *)insn_ptr;
             }
             sib = *insn_ptr++;
             if (!mod && (sib & 0x7) == 5 /* BP */) {
               insn_ptr += 4;
             }
           }
           switch (mod) {
             case 0:
@@ skipping 54 matching lines @@
   }
   if (is_group) {
     *is_group = found_group;
   }
   *ip = reinterpret_cast<const char *>(insn_ptr);
   return insn;
 }
 #endif
 
 } // namespace