[Hexagon] Use InstSimplify instead of ConstantProp

[aeubanks]

Summary

This is the last remaining use of ConstantProp, migrate it to InstSimplify in the goal of removing ConstantProp.

[aeubanks]

InstSimplify instead of InstCombine

[aeubanks]

There are 10 failures under llvm/test/CodeGen/Hexagon, and I don't have enough domain knowledge to fix them, was wondering if this even made sense at all.

[kparzysz]

These failures seem to be caused by optimizing the code "too much", and simply removing the parts that the tests were looking for.

Could you add a debug flag in HexagonTargetMachine.cpp, and add the simplification pass conditionally, similarly to how line 322 does it? The pass would be added by default, but these failing tests could exclude it (see the -hexagon-initial-cfg-cleanup=0 in some of the failing tests, that's the exact same problem caused by some other change in optimization passes).

[aeubanks]

Add -hexagon-instsimplify option, add -hexagon-instsimplify=0 to some tests

[aeubanks]

In D85047#2189085, @kparzysz wrote:

These failures seem to be caused by optimizing the code "too much", and simply removing the parts that the tests were looking for.

Could you add a debug flag in HexagonTargetMachine.cpp, and add the simplification pass conditionally, similarly to how line 322 does it? The pass would be added by default, but these failing tests could exclude it (see the -hexagon-initial-cfg-cleanup=0 in some of the failing tests, that's the exact same problem caused by some other change in optimization passes).

Ah I see, thanks! Done.

llvm/include/llvm/Transforms/Scalar.h

 Pass *createLoopSimplifyCFGPass();
 
 //===----------------------------------------------------------------------===//
 //
 // WarnMissedTransformations - This pass emits warnings for leftover forced
 // transformations.
 //
 Pass *createWarnMissedTransformationsPass();
+
+//===----------------------------------------------------------------------===//
+//
+// This pass does instruction simplification on each
+// instruction in a function.
+//
+FunctionPass *createInstSimplifyLegacyPass();
 } // End llvm namespace
 
 #endif

llvm/include/llvm/Transforms/Scalar/InstSimplifyPass.h

 /// restricted transform at a pass granularity. However, for a much more
 /// powerful and comprehensive peephole optimization engine, see the
 /// `instcombine` pass instead.
 class InstSimplifyPass : public PassInfoMixin<InstSimplifyPass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 };
 
-/// Create a legacy pass that does instruction simplification on each
-/// instruction in a function.
-FunctionPass *createInstSimplifyLegacyPass();
-
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_UTILS_INSTSIMPLIFYPASS_H

llvm/lib/Target/Hexagon/HexagonTargetMachine.cpp

TargetPassConfig *HexagonTargetMachine::createPassConfig(PassManagerBase &PM) {
   return new HexagonPassConfig(*this, PM);
 }
 
 void HexagonPassConfig::addIRPasses() {
   TargetPassConfig::addIRPasses();
   bool NoOpt = (getOptLevel() == CodeGenOpt::None);
 
   if (!NoOpt) {
-    addPass(createConstantPropagationPass());
+    addPass(createInstSimplifyLegacyPass());
     addPass(createDeadCodeEliminationPass());
   }
 
   addPass(createAtomicExpandPass());
 
   if (!NoOpt) {
     if (EnableInitialCFGCleanup)
       addPass(createCFGSimplificationPass(SimplifyCFGOptions()

llvm/lib/Transforms/Scalar/InstSimplifyPass.cpp

 #include "llvm/Analysis/OptimizationRemarkEmitter.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Type.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/Pass.h"
+#include "llvm/Transforms/Scalar.h"
 #include "llvm/Transforms/Utils.h"
 #include "llvm/Transforms/Utils/Local.h"
 using namespace llvm;
 
 #define DEBUG_TYPE "instsimplify"
 
 STATISTIC(NumSimplified, "Number of redundant instructions removed");