New low-level mutation: NegateXORReplacement

Author: stanislaw

include/irm/Mutations/NegateXORReplacement.h

@@ -0,0 +1,31 @@
+//
+//  Copyright 2020 Mull Project
+//
+//  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,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//
+
+#pragma once
+
+#include "irm/IRMutation.h"
+
+namespace irm {
+
+class NegateXORReplacement : public IRMutation {
+public:
+  NegateXORReplacement();
+  bool canMutate(llvm::Instruction *instruction) override;
+  void mutate(llvm::Instruction *instruction) override;
+
+};
+
+} // namespace irm

include/irm/irm.h

@@ -21,6 +21,7 @@
 #include "irm/Mutations/CmpInstPredicateReplacement.h"
 #include "irm/Mutations/ConstantReplacement.h"
 #include "irm/Mutations/IntrinsicReplacement.h"
+#include "irm/Mutations/NegateXORReplacement.h"
 #include "irm/Mutations/StoreValueReplacement.h"
 #include "irm/Mutations/SwapBinaryOperands.h"
 #include "irm/Mutations/VoidCallRemoval.h"

lib/CMakeLists.txt

@@ -5,6 +5,7 @@ set (SOURCES
   ConstantReplacement.cpp
   ConstValueConstructor.cpp
   IntrinsicReplacement.cpp
+  NegateXORReplacement.cpp
   StoreValueReplacement.cpp
   SwapBinaryOperands.cpp
   VoidCallRemoval.cpp

lib/NegateXORReplacement.cpp

@@ -0,0 +1,52 @@
+//
+//  Copyright 2020 Mull Project
+//
+//  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,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//
+
+#include "irm/Mutations/NegateXORReplacement.h"
+#include <llvm/IR/InstrTypes.h>
+
+using namespace irm;
+
+NegateXORReplacement::NegateXORReplacement() {}
+
+bool NegateXORReplacement::canMutate(llvm::Instruction *instruction) {
+  assert(instruction);
+  if (instruction->getOpcode() != llvm::Instruction::Xor) {
+    return false;
+  }
+
+  return true;
+}
+
+void NegateXORReplacement::mutate(llvm::Instruction *instruction) {
+  assert(instruction);
+  assert(canMutate(instruction));
+
+  /// Negating XOR means: "x ^ y" -> "x ^ !y".
+  /// Our goal below is to add a NOT instruction to negate Y, however in LLVM,
+  /// adding a "NOT x" instruction is implemented as doing "XOR x, true" (see the
+  /// source code of llvm::BinaryOperator::CreateNot.
+  ///
+  /// Example:
+  /// entry:
+  /// %xor = xor i1 true, false
+  /// becomes:
+  /// entry:
+  /// %not = xor i1 false, true
+  /// %xor = xor i1 true, %not
+  auto rhs = instruction->getOperand(1);
+  auto notInstruction = llvm::BinaryOperator::CreateNot(rhs, "not", instruction);
+  instruction->setOperand(1, notInstruction);
+}

tests/CMakeLists.txt

@@ -5,6 +5,7 @@ set (SOURCES
   Mutations/CmpInstPredicateReplacementTests.cpp
   Mutations/ConstatnReplacementTests.cpp
   Mutations/InstrinsicReplacementTests.cpp
+  Mutations/NegateXORReplacementTests.cpp
   Mutations/StoreValueReplacementTests.cpp
   Mutations/SwapBinaryOperandsTests.cpp
 )

tests/Mutations/NegateXORReplacementTests.cpp

@@ -0,0 +1,73 @@
+//
+//  Copyright 2020 Mull Project
+//
+//  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,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//
+
+#include <gtest/gtest.h>
+#include <irm/irm.h>
+#include <llvm/IR/Module.h>
+#include "TestLLVMCompatibility.h"
+
+using namespace irm;
+
+TEST(NegateXORReplacement, canMutate) {
+  using Mutator = NegateXORReplacement;
+
+  llvm::LLVMContext context;
+  llvm::Module module("test", context);
+  auto type = llvm::FunctionType::get(llvm::Type::getVoidTy(context), false);
+  auto function = test_llvm_compat::internalFunction(type, "test", module);
+  auto basicBlock = llvm::BasicBlock::Create(context, "entry", function);
+
+  auto op1 = llvm::ConstantInt::get(llvm::IntegerType::get(context, 1), 1, false);
+  auto op2 = llvm::ConstantInt::get(llvm::IntegerType::get(context, 1), 0, false);
+  auto xorInstruction = llvm::BinaryOperator::CreateXor(op1, op2, "xor", basicBlock);
+
+  Mutator mutator;
+  ASSERT_TRUE(mutator.canMutate(xorInstruction));
+}
+
+TEST(NegateXORReplacement, mutate) {
+  using Mutator = NegateXORReplacement;
+
+  llvm::LLVMContext context;
+  llvm::Module module("test", context);
+
+  auto type = llvm::FunctionType::get(llvm::Type::getVoidTy(context), false);
+  auto function = test_llvm_compat::internalFunction(type, "test", module);
+  auto basicBlock = llvm::BasicBlock::Create(context, "entry", function);
+
+  auto op1 = llvm::ConstantInt::get(llvm::IntegerType::get(context, 1), 1, false);
+  auto op2 = llvm::ConstantInt::get(llvm::IntegerType::get(context, 1), 0, false);
+  auto xorInstruction = llvm::BinaryOperator::CreateXor(op1, op2, "xor", basicBlock);
+
+  Mutator mutator;
+  mutator.mutate(xorInstruction);
+
+  /// We expect to have 2 xor instructions instead of one. See the implementation
+  /// details of NegateXorReplacement.mutate().
+  /// Before:
+  /// entry:
+  /// %xor = xor i1 true, false
+  ///
+  /// After:
+  /// entry:
+  /// %not = xor i1 false, true
+  /// %xor = xor i1 true, %not
+  ASSERT_EQ(xorInstruction->getOpcode(), llvm::Instruction::Xor);
+  ASSERT_EQ(xorInstruction->getOperand(0), op1);
+  ASSERT_EQ(xorInstruction->getOperand(1), xorInstruction->getPrevNode());
+  ASSERT_EQ(xorInstruction->getPrevNode()->getOpcode(), llvm::Instruction::Xor);
+  ASSERT_EQ(xorInstruction->getPrevNode()->getOperand(0), op2);
+}