[InstSimplify] Don't call the heavy ConstantFoldInstruction for loads. Use the lighter ConstantFoldLoadFromConstPtr

[craig.topper]

Summary

Load instructions go through the default case of SimplifyInstruction and use the heavy ConstantFoldInstruction which tries to recursively constant fold any constantexpr operands. I believe this is harder than we try for other instructions in InstSimplify. We usually use some entry point like ConstantFoldBinaryOpOperands or ConstantFoldCompareInstOperands which bypass this logic.

This patch calls directly to ConstantFoldLoadFromConstPtr if the load has a constant pointer and isn't volatile.

On one benchmark cpp file I ran through callgrind, this showed instructions executed in SimplifyInstruction reduce by almost half.

[craig.topper]

This seems to increase compile time on some tests. Abandoning while i figure out why.

lib/Analysis/InstructionSimplify.cpp

 }
 
 /// See if we can compute a simplified version of this instruction.
 /// If not, this returns null.
 
 Value *llvm::SimplifyInstruction(Instruction *I, const SimplifyQuery &SQ,
                                  OptimizationRemarkEmitter *ORE) {
   const SimplifyQuery Q = SQ.CxtI ? SQ : SQ.getWithInstruction(I);
-  Value *Result;
+  Value *Result = nullptr;
 
   switch (I->getOpcode()) {
   default:
     Result = ConstantFoldInstruction(I, Q.DL, Q.TLI);
     break;
   case Instruction::FAdd:
     Result = SimplifyFAddInst(I->getOperand(0), I->getOperand(1),
                               I->getFastMathFlags(), Q);
case Instruction::Call: {
     break;
   }
 #define HANDLE_CAST_INST(num, opc, clas) case Instruction::opc:
 #include "llvm/IR/Instruction.def"
 #undef HANDLE_CAST_INST
     Result =
         SimplifyCastInst(I->getOpcode(), I->getOperand(0), I->getType(), Q);
     break;
+  case Instruction::Load: {
+    auto *LI = cast<LoadInst>(I);
+    if (!LI->isVolatile())
+      if (auto *C = dyn_cast<Constant>(LI->getOperand(0)))
+        Result = ConstantFoldLoadFromConstPtr(C, LI->getType(), Q.DL);
+    break;
+  }
   case Instruction::Alloca:
     // No simplifications for Alloca and it can't be constant folded.
-    Result = nullptr;
     break;
   }
 
   // In general, it is possible for computeKnownBits to determine all bits in a
   // value even when the operands are not all constants.
   if (!Result && I->getType()->isIntOrIntVectorTy()) {
     KnownBits Known = computeKnownBits(I, Q.DL, /*Depth*/ 0, Q.AC, I, Q.DT, ORE);
     if (Known.isConstant())