llvm-reduce: Add reduction pass to simplify instructions

[aeubanks]

llvm/test/tools/llvm-reduce/simplify-instructions.ll

1

not necessary

llvm/tools/llvm-reduce/deltas/SimplifyInstructions.cpp

20–21

out of date comment (and the comment in the header too)

[arsenm]

llvm/test/tools/llvm-reduce/simplify-instructions.ll

1

What's not necessary?

[arsenm]

eea11e7369ca40c4c261a81e95e5ba5ee13fec20

llvm/test/tools/llvm-reduce/simplify-instructions.ll

+; RUN: llvm-reduce -abort-on-invalid-reduction -simplify-mir --delta-passes=simplify-instructions -mtriple=amdgcn-amd-amdhsa -mcpu=gfx900 --test FileCheck --test-arg --check-prefix=CHECK-INTERESTINGNESS --test-arg %s --test-arg --input-file %s -o %t 2> %t.log
+; RUN: FileCheck --check-prefix=RESULT %s < %t
+
+; CHECK-INTERESTINGNESS: ret
+
+; RESULT: %add4 = add i32 %arg0, %arg1
+; RESULT: ret i32 %add4
+
+define i32 @func(i32 %arg0, i32 %arg1) {
+entry:
+  %add0 = add i32 %arg0, 0
+  %add1 = add i32 %add0, 0
+  %add2 = add i32 %add1, 0
+  %add3 = add i32 %arg1, 0
+  %add4 = add i32 %add2, %add3
+  ret i32 %add4
+}

llvm/tools/llvm-reduce/CMakeLists.txt

add_llvm_tool(llvm-reduce
   deltas/ReduceOperands.cpp
   deltas/ReduceOperandsSkip.cpp
   deltas/ReduceOperandsToArgs.cpp
   deltas/ReduceInstructionsMIR.cpp
   deltas/ReduceInstructionFlagsMIR.cpp
   deltas/ReduceIRReferences.cpp
   deltas/ReduceVirtualRegisters.cpp
   deltas/ReduceRegisterUses.cpp
+  deltas/SimplifyInstructions.cpp
   llvm-reduce.cpp
 
   DEPENDS
   intrinsics_gen
   )

llvm/tools/llvm-reduce/DeltaManager.cpp

 #include "deltas/ReduceModuleData.h"
 #include "deltas/ReduceOperandBundles.h"
 #include "deltas/ReduceOperands.h"
 #include "deltas/ReduceOperandsSkip.h"
 #include "deltas/ReduceOperandsToArgs.h"
 #include "deltas/ReduceRegisterUses.h"
 #include "deltas/ReduceSpecialGlobals.h"
 #include "deltas/ReduceVirtualRegisters.h"
+#include "deltas/SimplifyInstructions.h"
 #include "llvm/Support/CommandLine.h"
 
 using namespace llvm;
 
 extern cl::OptionCategory LLVMReduceOptions;
 static cl::opt<std::string>
     DeltaPasses("delta-passes",
                 cl::desc("Delta passes to run, separated by commas. By "
                          "default, run all delta passes."),
                 cl::cat(LLVMReduceOptions));
 
 #define DELTA_PASSES                                                           \
   DELTA_PASS("special-globals", reduceSpecialGlobalsDeltaPass)                 \
   DELTA_PASS("aliases", reduceAliasesDeltaPass)                                \
   DELTA_PASS("function-bodies", reduceFunctionBodiesDeltaPass)                 \
   DELTA_PASS("functions", reduceFunctionsDeltaPass)                            \
   DELTA_PASS("basic-blocks", reduceBasicBlocksDeltaPass)                       \
   DELTA_PASS("global-values", reduceGlobalValuesDeltaPass)                     \
   DELTA_PASS("global-objects", reduceGlobalObjectsDeltaPass)                   \
   DELTA_PASS("global-initializers", reduceGlobalsInitializersDeltaPass)        \
   DELTA_PASS("global-variables", reduceGlobalsDeltaPass)                       \
   DELTA_PASS("metadata", reduceMetadataDeltaPass)                              \
   DELTA_PASS("arguments", reduceArgumentsDeltaPass)                            \
   DELTA_PASS("instructions", reduceInstructionsDeltaPass)                      \
+  DELTA_PASS("simplify-instructions", simplifyInstructionsDeltaPass)           \
   DELTA_PASS("operands-zero", reduceOperandsZeroDeltaPass)                     \
   DELTA_PASS("operands-one", reduceOperandsOneDeltaPass)                       \
   DELTA_PASS("operands-undef", reduceOperandsUndefDeltaPass)                   \
   DELTA_PASS("operands-to-args", reduceOperandsToArgsDeltaPass)                \
   DELTA_PASS("operands-skip", reduceOperandsSkipDeltaPass)                     \
   DELTA_PASS("operand-bundles", reduceOperandBundesDeltaPass)                  \
   DELTA_PASS("attributes", reduceAttributesDeltaPass)                          \
   DELTA_PASS("module-data", reduceModuleDataDeltaPass)

llvm/tools/llvm-reduce/deltas/SimplifyInstructions.h

+//===- SimplifyInstructions.h - Specialized Delta Pass ----------*- C++- *-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TOOLS_LLVM_REDUCE_DELTAS_SIMPLIFYINSTRUCTIONS_H
+#define LLVM_TOOLS_LLVM_REDUCE_DELTAS_SIMPLIFYINSTRUCTIONS_H
+
+#include "Delta.h"
+
+namespace llvm {
+void simplifyInstructionsDeltaPass(TestRunner &Test);
+} // namespace llvm
+
+#endif

llvm/tools/llvm-reduce/deltas/SimplifyInstructions.cpp

+//===- SimplifyInstructions.cpp - Specialized Delta Pass ------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements a function which calls the Generic Delta pass in order
+// to reduce uninteresting Instructions from defined functions.
+//
+//===----------------------------------------------------------------------===//
+
+#include "SimplifyInstructions.h"
+#include "llvm/Analysis/InstructionSimplify.h"
+#include "llvm/IR/Constants.h"
+
+using namespace llvm;
+
+/// Removes out-of-chunk arguments from functions, and modifies their calls
+/// accordingly. It also removes allocations of out-of-chunk arguments.
+static void extractInstrFromModule(Oracle &O, Module &Program) {
+  std::vector<Instruction *> InstsToDelete;
+
+  const DataLayout &DL = Program.getDataLayout();
+
+  std::vector<Instruction *> InstToDelete;
+  for (auto &F : Program) {
+    for (auto &BB : F) {
+      for (auto &Inst : BB) {
+        if (O.shouldKeep())
+          continue;
+
+        SimplifyQuery Q(DL, &Inst);
+        if (Value *Simplified = SimplifyInstruction(&Inst, Q)) {
+          Inst.replaceAllUsesWith(Simplified);
+          InstToDelete.push_back(&Inst);
+        }
+      }
+    }
+  }
+
+  for (Instruction *I : InstToDelete)
+    I->eraseFromParent();
+}
+
+void llvm::simplifyInstructionsDeltaPass(TestRunner &Test) {
+  outs() << "*** Simplifying Instructions...\n";
+  runDeltaPass(Test, extractInstrFromModule);
+}