[SyzyASAN] Add support for LODS instruction.

syzygy/instrument/transforms/asan_transform_unittest.cc

 // Copyright 2012 Google Inc. All Rights Reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 151 matching lines @@
     for (int access_size = 1; access_size <= 8; access_size *= 2) {
       std::string name =
           base::StringPrintf("asan_check_%d_byte_write_access", access_size);
       AddHookRef(name, AsanBasicBlockTransform::kWriteAccess, access_size, 0,
                  true);
       name += "_no_flags";
       AddHookRef(name, AsanBasicBlockTransform::kWriteAccess, access_size, 0,
                  false);
     }
 
-    const _InstructionType strings[] = { I_CMPS, I_MOVS, I_STOS };
+    const _InstructionType strings[] = {I_CMPS, I_LODS, I_MOVS, I_STOS};
     int strings_length = arraysize(strings);
 
     for (int access_size = 1; access_size <= 4; access_size *= 2) {
       for (int inst = 0; inst < strings_length; ++inst) {
         uint16_t opcode = strings[inst];
         const char* opcode_str =
             reinterpret_cast<const char*>(GET_MNEMONIC_NAME(opcode));
         std::string name =
             base::StringPrintf("asan_check_repz_%d_byte_%s_access",
                                access_size, opcode_str);
@@ skipping 596 matching lines @@
       { AsanBasicBlockTransform::kWriteAccess, 4, 0, true };
   ASSERT_TRUE(iter_inst->references().begin()->second.block()
       == hooks_check_access_[check_4_byte_write_key]);
   ASSERT_TRUE((iter_inst++)->representation().opcode == I_CALL);
   ASSERT_TRUE((iter_inst++)->representation().opcode == I_MOV);
 
   ASSERT_TRUE(iter_inst == basic_block_->instructions().end());
 }
 
 TEST_F(AsanTransformTest, InstrumentableStringInstructions) {
+  static const uint8_t lodsd[1] = {0xAD};
+  static const uint8_t lodsw[2] = {0x66, 0xAD};
+  static const uint8_t lodsb[1] = {0xAC};
+
   static const uint8_t movsd[1] = {0xA5};
   static const uint8_t movsw[2] = {0x66, 0xA5};
   static const uint8_t movsb[1] = {0xA4};
 
   static const uint8_t cmpsd[1] = {0xA7};
   static const uint8_t cmpsw[2] = {0x66, 0xA7};
   static const uint8_t cmpsb[1] = {0xA6};
 
   static const uint8_t stosd[1] = {0xAB};
   static const uint8_t stosw[2] = {0x66, 0xAB};
   static const uint8_t stosb[1] = {0xAA};
 
+  EXPECT_TRUE(AddInstructionFromBuffer(lodsd, sizeof(lodsd)));
+  EXPECT_TRUE(AddInstructionFromBuffer(lodsw, sizeof(lodsw)));
+  EXPECT_TRUE(AddInstructionFromBuffer(lodsb, sizeof(lodsb)));
   EXPECT_TRUE(AddInstructionFromBuffer(movsd, sizeof(movsd)));
   EXPECT_TRUE(AddInstructionFromBuffer(movsw, sizeof(movsw)));
   EXPECT_TRUE(AddInstructionFromBuffer(movsb, sizeof(movsb)));
   EXPECT_TRUE(AddInstructionFromBuffer(cmpsd, sizeof(cmpsd)));
   EXPECT_TRUE(AddInstructionFromBuffer(cmpsw, sizeof(cmpsw)));
   EXPECT_TRUE(AddInstructionFromBuffer(cmpsb, sizeof(cmpsb)));
   EXPECT_TRUE(AddInstructionFromBuffer(stosd, sizeof(stosd)));
   EXPECT_TRUE(AddInstructionFromBuffer(stosw, sizeof(stosw)));
   EXPECT_TRUE(AddInstructionFromBuffer(stosb, sizeof(stosb)));
 
@@ skipping 14 matching lines @@
   EXPECT_TRUE(bb_transform.instrumentation_happened());
 
   // Each instrumentable instructions implies 1 new instructions.
   uint32_t expected_basic_block_size = count_instructions + basic_block_size;
 
   // Validate basic block size.
   ASSERT_EQ(basic_block_->instructions().size(), expected_basic_block_size);
 }
 
 TEST_F(AsanTransformTest, InstrumentableRepzStringInstructions) {
+  static const uint8_t lodsd[2] = {0xF3, 0xAD};
+  static const uint8_t lodsw[3] = {0xF3, 0x66, 0xAD};
+  static const uint8_t lodsb[2] = {0xF3, 0xAC};
+
   static const uint8_t movsd[2] = {0xF3, 0xA5};
   static const uint8_t movsw[3] = {0xF3, 0x66, 0xA5};
   static const uint8_t movsb[2] = {0xF3, 0xA4};
 
   static const uint8_t cmpsd[2] = {0xF3, 0xA7};
   static const uint8_t cmpsw[3] = {0xF3, 0x66, 0xA7};
   static const uint8_t cmpsb[2] = {0xF3, 0xA6};
 
   static const uint8_t stosd[2] = {0xF3, 0xAB};
   static const uint8_t stosw[3] = {0xF3, 0x66, 0xAB};
   static const uint8_t stosb[2] = {0xF3, 0xAA};
 
+  EXPECT_TRUE(AddInstructionFromBuffer(lodsd, sizeof(lodsd)));
+  EXPECT_TRUE(AddInstructionFromBuffer(lodsw, sizeof(lodsw)));
+  EXPECT_TRUE(AddInstructionFromBuffer(lodsb, sizeof(lodsb)));
   EXPECT_TRUE(AddInstructionFromBuffer(movsd, sizeof(movsd)));
   EXPECT_TRUE(AddInstructionFromBuffer(movsw, sizeof(movsw)));
   EXPECT_TRUE(AddInstructionFromBuffer(movsb, sizeof(movsb)));
   EXPECT_TRUE(AddInstructionFromBuffer(cmpsd, sizeof(cmpsd)));
   EXPECT_TRUE(AddInstructionFromBuffer(cmpsw, sizeof(cmpsw)));
   EXPECT_TRUE(AddInstructionFromBuffer(cmpsb, sizeof(cmpsb)));
   EXPECT_TRUE(AddInstructionFromBuffer(stosd, sizeof(stosd)));
   EXPECT_TRUE(AddInstructionFromBuffer(stosw, sizeof(stosw)));
   EXPECT_TRUE(AddInstructionFromBuffer(stosb, sizeof(stosb)));
 
@@ skipping 324 matching lines @@
   expected.insert("asan_check_32_byte_read_access_no_flags");
   expected.insert("asan_check_1_byte_write_access_no_flags");
   expected.insert("asan_check_2_byte_write_access_no_flags");
   expected.insert("asan_check_4_byte_write_access_no_flags");
   expected.insert("asan_check_8_byte_write_access_no_flags");
   expected.insert("asan_check_10_byte_write_access_no_flags");
   expected.insert("asan_check_16_byte_write_access_no_flags");
   expected.insert("asan_check_32_byte_write_access_no_flags");
 
   expected.insert("asan_check_repz_4_byte_cmps_access");
+  expected.insert("asan_check_repz_4_byte_lods_access");
   expected.insert("asan_check_repz_4_byte_movs_access");
   expected.insert("asan_check_repz_4_byte_stos_access");
   expected.insert("asan_check_repz_2_byte_cmps_access");
+  expected.insert("asan_check_repz_2_byte_lods_access");
   expected.insert("asan_check_repz_2_byte_movs_access");
   expected.insert("asan_check_repz_2_byte_stos_access");
   expected.insert("asan_check_repz_1_byte_cmps_access");
+  expected.insert("asan_check_repz_1_byte_lods_access");
   expected.insert("asan_check_repz_1_byte_movs_access");
   expected.insert("asan_check_repz_1_byte_stos_access");
 
   expected.insert("asan_check_4_byte_cmps_access");
+  expected.insert("asan_check_4_byte_lods_access");
   expected.insert("asan_check_4_byte_movs_access");
   expected.insert("asan_check_4_byte_stos_access");
   expected.insert("asan_check_2_byte_cmps_access");
+  expected.insert("asan_check_2_byte_lods_access");
   expected.insert("asan_check_2_byte_movs_access");
   expected.insert("asan_check_2_byte_stos_access");
   expected.insert("asan_check_1_byte_cmps_access");
+  expected.insert("asan_check_1_byte_lods_access");
   expected.insert("asan_check_1_byte_movs_access");
   expected.insert("asan_check_1_byte_stos_access");
 
   // We expect all of the instrumentation functions to have been added.
   Intersect(imports, expected, &results);
   if (!hot_patching) {
     EXPECT_EQ(expected, results);
   } else {
     // These should not be present in hot patching mode.
     EXPECT_TRUE(results.empty());
@@ skipping 127 matching lines @@
   expected.insert("_asan_check_32_byte_read_access_no_flags");
   expected.insert("_asan_check_1_byte_write_access_no_flags");
   expected.insert("_asan_check_2_byte_write_access_no_flags");
   expected.insert("_asan_check_4_byte_write_access_no_flags");
   expected.insert("_asan_check_8_byte_write_access_no_flags");
   expected.insert("_asan_check_10_byte_write_access_no_flags");
   expected.insert("_asan_check_16_byte_write_access_no_flags");
   expected.insert("_asan_check_32_byte_write_access_no_flags");
 
   expected.insert("_asan_check_repz_4_byte_cmps_access");
+  expected.insert("_asan_check_repz_4_byte_lods_access");
   expected.insert("_asan_check_repz_4_byte_movs_access");
   expected.insert("_asan_check_repz_4_byte_stos_access");
   expected.insert("_asan_check_repz_2_byte_cmps_access");
+  expected.insert("_asan_check_repz_2_byte_lods_access");
   expected.insert("_asan_check_repz_2_byte_movs_access");
   expected.insert("_asan_check_repz_2_byte_stos_access");
   expected.insert("_asan_check_repz_1_byte_cmps_access");
+  expected.insert("_asan_check_repz_1_byte_lods_access");
   expected.insert("_asan_check_repz_1_byte_movs_access");
   expected.insert("_asan_check_repz_1_byte_stos_access");
 
   expected.insert("_asan_check_4_byte_cmps_access");
+  expected.insert("_asan_check_4_byte_lods_access");
   expected.insert("_asan_check_4_byte_movs_access");
   expected.insert("_asan_check_4_byte_stos_access");
   expected.insert("_asan_check_2_byte_cmps_access");
+  expected.insert("_asan_check_2_byte_lods_access");
   expected.insert("_asan_check_2_byte_movs_access");
   expected.insert("_asan_check_2_byte_stos_access");
   expected.insert("_asan_check_1_byte_cmps_access");
+  expected.insert("_asan_check_1_byte_lods_access");
   expected.insert("_asan_check_1_byte_movs_access");
   expected.insert("_asan_check_1_byte_stos_access");
 
   StringSet results;
   Intersect(symbols, expected, &results);
   EXPECT_THAT(results, ContainerEq(expected));
 
   // Expect at least some of the Asan instrumentation symbols to be referenced.
   size_t instrumentation_references = 0;
   StringSet::const_iterator str_it = expected.begin();
@@ skipping 508 matching lines @@
 
     // We check |padding_before| to see if the block has been prepared for hot
     // patching.
     size_t expected_padding = hot_patched_set_.count(block) ? 5U : 0U;
     EXPECT_EQ(expected_padding, block->padding_before());
   }
 }
 
 }  // namespace transforms
 }  // namespace instrument