libdisasm: Don't depend on sizeof(void)

src/third_party/libdisasm/x86_disasm.c

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "libdis.h"
 #include "ia32_insn.h"
 #include "ia32_invariant.h"
 #include "x86_operand_list.h"
 
 
@@ skipping 17 matching lines @@
         /* ensure we are all NULLed up */
         memset( insn, 0, sizeof(x86_insn_t) );
         insn->addr = buf_rva + offset;
         insn->offset = offset;
         /* default to invalid insn */
         insn->type = insn_invalid;
         insn->group = insn_none;
 
         if ( offset >= buf_len ) {
                 /* another caller screwup ;) */
-                x86_report_error(report_disasm_bounds, (void*)(long)buf_rva+offset);
+                x86_report_error(report_disasm_bounds, (void*)(long)(buf_rva+offset));

[brucedawson, 2016/01/08 21:19:11]

Too late for this change, but why are we casting to 'long' here? My guess is
that it is an attempt to convert from uint32_t to pointer-sized integer, but
'long' is not a reliable way to do this since 'long' is always 32-bit on VC++.
The cast to long should be removed or replaced with a cast to intptr_t or,
probably best of all, uintptr_t.

                 return 0;
         }
 
         len = buf_len - offset;
 
         /* copy enough bytes for disassembly into buffer : this
          * helps prevent buffer overruns at the end of a file */
         memset( bytes, 0, MAX_INSTRUCTION_SIZE );
         memcpy( bytes, &buf[offset], (len < MAX_INSTRUCTION_SIZE) ? len : 
                 MAX_INSTRUCTION_SIZE );
 
         /* actually do the disassembly */
         /* TODO: allow switching when more disassemblers are added */
         size = ia32_disasm_addr( bytes, len, insn);
 
         /* check and see if we had an invalid instruction */
         if (! size ) {
-                x86_report_error(report_invalid_insn, (void*)(long)buf_rva+offset );
+                x86_report_error(report_invalid_insn, (void*)(long)(buf_rva+offset));
                 return 0;
         }
 
         /* check if we overran the end of the buffer */
         if ( size > len ) {
-                x86_report_error( report_insn_bounds, (void*)(long)buf_rva + offset );
+                x86_report_error( report_insn_bounds, (void*)(long)(buf_rva + offset));
                 MAKE_INVALID( insn, bytes );
                 return 0;
         }
 
         /* fill bytes field of insn */
         memcpy( insn->bytes, bytes, size );
 
         return size;
 }
 
@@ skipping 128 matching lines @@
 
         return ia32_disasm_invariant(buf, buf_len, inv);
 }
 size_t x86_size_disasm( unsigned char *buf, unsigned int buf_len ) {
         if (! buf || ! buf_len  ) {
                 return(0);
         }
 
         return ia32_disasm_size(buf, buf_len);
 }