Refactor rel32 searching process for x64 to make it more similar to x86.

courgette/rel32_finder_unittest.cc

 // Copyright 2015 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 "courgette/rel32_finder_win32_x86.h"
-
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <sstream>
 #include <string>
 
 #include "base/macros.h"
 #include "courgette/base_test_unittest.h"
 #include "courgette/image_utils.h"
+#include "courgette/rel32_finder_x64.h"
+#include "courgette/rel32_finder_x86.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace courgette {
 
 namespace {
 
-// Helper class to load and execute a Rel32FinderWin32X86 test case.
-class Rel32FinderWin32X86TestCase {
+// Helper class to load and execute a Rel32Finder test case.
+class Rel32FinderTestCase {
  public:
-  Rel32FinderWin32X86TestCase(const std::string& test_data)
+  Rel32FinderTestCase(const std::string& test_data)
       : text_start_rva_(0),
         text_end_rva_(0),
         relocs_start_rva_(0),
         relocs_end_rva_(0),
         image_end_rva_(0) {
     LoadTestFromString(test_data);
   }
 
+  template <class Finder>

[huangs, 2016/05/30 05:48:34]

Pretty cool use of template.  :)  In this instance though, the template
propagated to Rel32FinderTest::RunTest() and that's odd.

I think it would be cleaner to go "low tech": Use member variable

std::scoped_ptr<Rel32Finder> finder_;

Then add new config in each .txt test file to specify type, e.g.:

# Processor type
x86

Then in LoadTestFromString(), get this string  with ReadNonEmptyLine(), compare
and instantiate |finder_| accordingly.

[etiennep, 2016/05/30 17:07:30]

Done.

   void RunTestBasic(std::string name) {
-    Rel32FinderWin32X86_Basic finder(relocs_start_rva_, relocs_end_rva_);
+    Finder finder = CreateFinder<Finder>();
     ASSERT_FALSE(text_data_.empty());
     finder.Find(&text_data_[0], &text_data_[0] + text_data_.size(),
-        text_start_rva_, text_end_rva_, abs32_locations_);
+                text_start_rva_, text_end_rva_, abs32_locations_);
     std::vector<RVA> rel32_locations;
     finder.SwapRel32Locations(&rel32_locations);
     EXPECT_EQ(expected_rel32_locations_, rel32_locations)
         << "From test case " << name << " (addresses are in hex)";
   }
 
+  template <class Finder>
+  Finder CreateFinder();
+
+  template <>
+  Rel32FinderX86 CreateFinder<Rel32FinderX86>() {
+    return Rel32FinderX86(relocs_start_rva_, relocs_end_rva_);
+  }
+  template <>
+  Rel32FinderX64 CreateFinder<Rel32FinderX64>() {
+    return Rel32FinderX64(relocs_start_rva_, relocs_end_rva_, image_end_rva_);
+  }
+
  private:
   RVA text_start_rva_;
   RVA text_end_rva_;
   RVA relocs_start_rva_;
   RVA relocs_end_rva_;
   RVA image_end_rva_;
   std::vector<uint8_t> text_data_;
   std::vector<RVA> abs32_locations_;
   std::vector<RVA> expected_rel32_locations_;
 
@@ skipping 20 matching lines @@
   // Scans |iss| for the next non-empty line, and reads (hex) uint32_t into |v|.
   // Returns true iff successful.
   bool ReadHexUInt32(std::istringstream& iss, uint32_t* v) {
     std::string line;
     if (!ReadNonEmptyLine(iss, &line))
       return false;
     return sscanf(line.c_str(), "%X", v) == 1;
   }
 
   // Initializes the test case by parsing the multi-line string |test_data|
-  // to extract Rel32FinderWin32X86 parameters, and read expected values.
+  // to extract Rel32Finder parameters, and read expected values.
   void LoadTestFromString(const std::string& test_data) {
     // The first lines (ignoring empty ones) specify RVA bounds.
     std::istringstream iss(test_data);
     ASSERT_TRUE(ReadHexUInt32(iss, &text_start_rva_));
     ASSERT_TRUE(ReadHexUInt32(iss, &text_end_rva_));
     ASSERT_TRUE(ReadHexUInt32(iss, &relocs_start_rva_));
     ASSERT_TRUE(ReadHexUInt32(iss, &relocs_end_rva_));
     ASSERT_TRUE(ReadHexUInt32(iss, &image_end_rva_));
 
     std::string line;
     // The Program section specifies instruction bytes. We require lines to be
     // formatted in "DUMPBIN /DISASM" style, i.e.,
     // "00401003: E8 00 00 00 00     call        00401008"
     //            ^  ^  ^  ^  ^  ^
     // We extract up to 6 bytes per line. The remaining are ignored.
     const int kBytesBegin = 12;
     const int kBytesEnd = 17;
     ReadNonEmptyLine(iss, &line);
     ASSERT_EQ("Program:", line);
     while (ReadNonEmptyLine(iss, &line) && line != "Abs32:") {
       std::string toks = line.substr(kBytesBegin, kBytesEnd);
       uint32_t vals[6];
       int num_read = sscanf(toks.c_str(), "%X %X %X %X %X %X", &vals[0],
-          &vals[1], &vals[2], &vals[3], &vals[4], &vals[5]);
+                            &vals[1], &vals[2], &vals[3], &vals[4], &vals[5]);
       for (int i = 0; i < num_read; ++i)
         text_data_.push_back(static_cast<uint8_t>(vals[i] & 0xFF));
     }
     ASSERT_FALSE(text_data_.empty());
 
     // The Abs32 section specifies hex RVAs, one per line.
     ASSERT_EQ("Abs32:", line);
     while (ReadNonEmptyLine(iss, &line) && line != "Expected:") {
       RVA abs32_location;
       ASSERT_EQ(1, sscanf(line.c_str(), "%X", &abs32_location));
       abs32_locations_.push_back(abs32_location);
     }
 
     // The Expected section specifies hex Rel32 RVAs, one per line.
     ASSERT_EQ("Expected:", line);
     while (ReadNonEmptyLine(iss, &line)) {
       RVA rel32_location;
       ASSERT_EQ(1, sscanf(line.c_str(), "%X", &rel32_location));
       expected_rel32_locations_.push_back(rel32_location);
     }
   }
 };
 
-class Rel32FinderWin32X86Test : public BaseTest {
+class Rel32FinderTest : public BaseTest {
  public:
+  template <class Finder>
   void RunTest(const char* test_case_file) {
-    Rel32FinderWin32X86TestCase test_case(FileContents(test_case_file));
-    test_case.RunTestBasic(test_case_file);
+    Rel32FinderTestCase test_case(FileContents(test_case_file));
+    test_case.RunTestBasic<Finder>(test_case_file);
   }
 };
 
-TEST_F(Rel32FinderWin32X86Test, TestBasic) {
-  RunTest("rel32_win32_x86_01.txt");
-  RunTest("rel32_win32_x86_02.txt");
-  RunTest("rel32_win32_x86_03.txt");
-  RunTest("rel32_win32_x86_04.txt");
+TEST_F(Rel32FinderTest, TestBasic) {
+  RunTest<Rel32FinderX86>("rel32_x86_01.txt");
+  RunTest<Rel32FinderX86>("rel32_x86_02.txt");
+  RunTest<Rel32FinderX86>("rel32_x86_03.txt");
+  RunTest<Rel32FinderX86>("rel32_x86_04.txt");
+
+  RunTest<Rel32FinderX64>("rel32_x64_01.txt");
+  RunTest<Rel32FinderX64>("rel32_x64_02.txt");
+  RunTest<Rel32FinderX64>("rel32_x64_03.txt");
 }

[huangs, 2016/05/30 05:48:34]

Curious why there's no rel32_x64_04.txt?

[etiennep, 2016/05/30 17:07:30]

I don't think testing false positive is relevant.

 
 }  // namespace
 
 }  // namespace courgette