Replace libdisasm with capstone

src/processor/exploitability_win.cc

 // Copyright (c) 2010 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 26 matching lines @@
 #include <vector>
 
 #include "processor/exploitability_win.h"
 
 #include "common/scoped_ptr.h"
 #include "google_breakpad/common/minidump_exception_win32.h"
 #include "google_breakpad/processor/minidump.h"
 #include "processor/disassembler_x86.h"
 #include "processor/logging.h"
 
-#include "third_party/libdisasm/libdis.h"
+//#include "third_party/libdisasm/libdis.h"
 
 namespace google_breakpad {
 
 // The cutoff that we use to judge if and address is likely an offset
 // from various interesting addresses.
 static const uint64_t kProbableNullOffset = 4096;
 static const uint64_t kProbableStackOffset = 8192;
 
 // The various cutoffs for the different ratings.
 static const size_t kHighCutoff        = 100;
@@ skipping 159 matching lines @@
                                          available_memory,
                                          instruction_ptr);
             disassembler.NextInstruction();
             if (bad_read)
               disassembler.setBadRead();
             else
               disassembler.setBadWrite();
             if (disassembler.currentInstructionValid()) {
               // Check if the faulting instruction falls into one of
               // several interesting groups.
-              switch (disassembler.currentInstructionGroup()) {
-                case libdis::insn_controlflow:
-                  exploitability_weight += kLargeBump;
-                  break;
-                case libdis::insn_string:
-                  exploitability_weight += kHugeBump;
-                  break;
-                default:
-                  break;
+              if (disassembler.currentInstructionIsGroup(X86_GRP_JUMP) ||
+                  disassembler.currentInstructionIsGroup(X86_GRP_CALL)) {
+                exploitability_weight += kLargeBump;
+              } else if (disassembler.currentInstructionIsBlockData()) {
+                exploitability_weight += kHugeBump;
               }
               // Loop the disassembler through the code and check if it
               // IDed any interesting conditions in the near future.
               // Multiple flags may be set so treat each equally.
               while (disassembler.NextInstruction() &&
                      disassembler.currentInstructionValid() &&
                      !disassembler.endOfBlock())
                 continue;
               if (disassembler.flags() & DISX86_BAD_BRANCH_TARGET)
                 exploitability_weight += kLargeBump;
@@ skipping 28 matching lines @@
     return EXPLOITABLITY_MEDIUM;
   if (exploitability_weight >= kLowCutoff)
     return EXPLOITABILITY_LOW;
   if (exploitability_weight >= kInterestingCutoff)
     return EXPLOITABILITY_INTERESTING;
 
   return EXPLOITABILITY_NONE;
 }
 
 }  // namespace google_breakpad