[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 *llvm::ConstantFoldInstruction(Instruction *I, const DataLayout &DL,
 
   if (const auto *LI = dyn_cast<LoadInst>(I)) {
     if (LI->isVolatile())
       return nullptr;
     return ConstantFoldLoadFromConstPtr(Ops[0], LI->getType(), DL);
   }
 
   if (auto *IVI = dyn_cast<InsertValueInst>(I))
-    return ConstantExpr::getInsertValue(Ops[0], Ops[1], IVI->getIndices());
+    return ConstantFoldInsertValueInstruction(Ops[0], Ops[1],
+                                              IVI->getIndices());
 
   if (auto *EVI = dyn_cast<ExtractValueInst>(I))
     return ConstantFoldExtractValueInstruction(Ops[0], EVI->getIndices());
 
   return ConstantFoldInstOperands(I, Ops, DL, TLI);
 }
 
 Constant *llvm::ConstantFoldConstant(const Constant *C, const DataLayout &DL,

llvm/lib/Analysis/InlineCost.cpp

bool CallAnalyzer::visitExtractValue(ExtractValueInst &I) {
 
   // SROA can't look through these, but they may be free.
   return Base::visitExtractValue(I);
 }
 
 bool CallAnalyzer::visitInsertValue(InsertValueInst &I) {
   // Constant folding for insert value is trivial.
   if (simplifyInstruction(I, [&](SmallVectorImpl<Constant *> &COps) {
-        return ConstantExpr::getInsertValue(/*AggregateOperand*/ COps[0],
-                                            /*InsertedValueOperand*/ COps[1],
-                                            I.getIndices());
+        return ConstantFoldInsertValueInstruction(
+            /*AggregateOperand*/ COps[0], /*InsertedValueOperand*/ COps[1],
       }))
     return true;
 
   // SROA can't look through these, but they may be free.
   return Base::visitInsertValue(I);
 }
 
 /// Try to simplify a call site.

llvm/lib/Transforms/Utils/Evaluator.cpp

while (true) {
     } else if (auto *EVI = dyn_cast<ExtractValueInst>(CurInst)) {
       InstResult = ConstantFoldExtractValueInstruction(
           getVal(EVI->getAggregateOperand()), EVI->getIndices());
       if (!InstResult)
         return false;
       LLVM_DEBUG(dbgs() << "Found an ExtractValueInst! Simplifying: "
                         << *InstResult << "\n");
     } else if (auto *IVI = dyn_cast<InsertValueInst>(CurInst)) {
-      InstResult = ConstantExpr::getInsertValue(
+      InstResult = ConstantFoldInsertValueInstruction(
           getVal(IVI->getAggregateOperand()),
           getVal(IVI->getInsertedValueOperand()), IVI->getIndices());
+      if (!InstResult)
+        return false;
       LLVM_DEBUG(dbgs() << "Found an InsertValueInst! Simplifying: "
                         << *InstResult << "\n");
     } else if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(CurInst)) {
       Constant *P = getVal(GEP->getOperand(0));
       SmallVector<Constant*, 8> GEPOps;
       for (Use &Op : llvm::drop_begin(GEP->operands()))
         GEPOps.push_back(getVal(Op));
       InstResult =