[ConstExpr] Don't create insertvalue expressions

[nikic]

Summary

In preparation for the removal in D128719, this stops creating insertvalue constant expressions as part (well, unless it's directly used in LLVM IR).

[nikic]

Rebase

[reames]

LGTM

clang/lib/CodeGen/ItaniumCXXABI.cpp

ItaniumCXXABI::EmitMemberPointerConversion(const CastExpr *E,
 
   llvm::Constant *srcAdj = src->getAggregateElement(1);
   llvm::Constant *dstAdj;
   if (isDerivedToBase)
     dstAdj = llvm::ConstantExpr::getNSWSub(srcAdj, adj);
   else
     dstAdj = llvm::ConstantExpr::getNSWAdd(srcAdj, adj);
 
-  return llvm::ConstantExpr::getInsertValue(src, dstAdj, 1);
+  llvm::Constant *res = ConstantFoldInsertValueInstruction(src, dstAdj, 1);
+  assert(res != nullptr && "Folding must succeed");
+  return res;
 }
 
 llvm::Constant *
 ItaniumCXXABI::EmitNullMemberPointer(const MemberPointerType *MPT) {
   // Itanium C++ ABI 2.3:
   //   A NULL pointer is represented as -1.
   if (MPT->isMemberDataPointer())
     return llvm::ConstantInt::get(CGM.PtrDiffTy, -1ULL, /*isSigned=*/true);

llvm/include/llvm/Analysis/TargetFolder.h

Value *FoldExtractValue(Value *Agg,
     return nullptr;
   };
 
   Value *FoldInsertValue(Value *Agg, Value *Val,
                          ArrayRef<unsigned> IdxList) const override {
     auto *CAgg = dyn_cast<Constant>(Agg);
     auto *CVal = dyn_cast<Constant>(Val);
     if (CAgg && CVal)
-      return Fold(ConstantExpr::getInsertValue(CAgg, CVal, IdxList));
+      return ConstantFoldInsertValueInstruction(CAgg, CVal, IdxList);
     return nullptr;
   }
 
   Value *FoldExtractElement(Value *Vec, Value *Idx) const override {
     auto *CVec = dyn_cast<Constant>(Vec);
     auto *CIdx = dyn_cast<Constant>(Idx);
     if (CVec && CIdx)
       return Fold(ConstantExpr::getExtractElement(CVec, CIdx));

llvm/include/llvm/IR/ConstantFolder.h

Value *FoldExtractValue(Value *Agg,
     return nullptr;
   };
 
   Value *FoldInsertValue(Value *Agg, Value *Val,
                          ArrayRef<unsigned> IdxList) const override {
     auto *CAgg = dyn_cast<Constant>(Agg);
     auto *CVal = dyn_cast<Constant>(Val);
     if (CAgg && CVal)
-      return ConstantExpr::getInsertValue(CAgg, CVal, IdxList);
+      return ConstantFoldInsertValueInstruction(CAgg, CVal, IdxList);
     return nullptr;
   }
 
   Value *FoldExtractElement(Value *Vec, Value *Idx) const override {
     auto *CVec = dyn_cast<Constant>(Vec);
     auto *CIdx = dyn_cast<Constant>(Idx);
     if (CVec && CIdx)
       return ConstantExpr::getExtractElement(CVec, CIdx);

llvm/lib/Analysis/ConstantFolding.cpp

Constant *ConstantFoldInstOperandsImpl(const Value *InstOrCE, unsigned Opcode,
   case Instruction::ExtractElement:
     return ConstantExpr::getExtractElement(Ops[0], Ops[1]);
   case Instruction::ExtractValue:
     return ConstantFoldExtractValueInstruction(
         Ops[0], cast<ExtractValueInst>(InstOrCE)->getIndices());
   case Instruction::InsertElement:
     return ConstantExpr::getInsertElement(Ops[0], Ops[1], Ops[2]);
   case Instruction::InsertValue:
-    return ConstantExpr::getInsertValue(
+    return ConstantFoldInsertValueInstruction(
         Ops[0], Ops[1], cast<InsertValueInst>(InstOrCE)->getIndices());
   case Instruction::ShuffleVector:
     return ConstantExpr::getShuffleVector(
         Ops[0], Ops[1], cast<ShuffleVectorInst>(InstOrCE)->getShuffleMask());
   case Instruction::Load: {
     const auto *LI = dyn_cast<LoadInst>(InstOrCE);
     if (LI->isVolatile())
       return nullptr;