[llvm] 238a59c - [InstCombine] Remove varargs cast transform (NFC)
Nikita Popov via llvm-commits
llvm-commits at lists.llvm.org
Wed Apr 5 07:36:29 PDT 2023
Author: Nikita Popov
Date: 2023-04-05T16:36:21+02:00
New Revision: 238a59c3f1fcc2af2cc88f4385d81e4522f54b86
URL: https://github.com/llvm/llvm-project/commit/238a59c3f1fcc2af2cc88f4385d81e4522f54b86
DIFF: https://github.com/llvm/llvm-project/commit/238a59c3f1fcc2af2cc88f4385d81e4522f54b86.diff
LOG: [InstCombine] Remove varargs cast transform (NFC)
This is no longer relevant with opaque pointers.
Also drop the CastInst::isLosslessCast() method, which was only
used here.
Added:
Modified:
llvm/include/llvm/IR/InstrTypes.h
llvm/lib/IR/Instructions.cpp
llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp
Removed:
################################################################################
diff --git a/llvm/include/llvm/IR/InstrTypes.h b/llvm/include/llvm/IR/InstrTypes.h
index f8c1df90d1139..980a46073d493 100644
--- a/llvm/include/llvm/IR/InstrTypes.h
+++ b/llvm/include/llvm/IR/InstrTypes.h
@@ -628,13 +628,6 @@ class CastInst : public UnaryInstruction {
/// Determine if this is an integer-only cast.
bool isIntegerCast() const;
- /// A lossless cast is one that does not alter the basic value. It implies
- /// a no-op cast but is more stringent, preventing things like int->float,
- /// long->double, or int->ptr.
- /// @returns true iff the cast is lossless.
- /// Determine if this is a lossless cast.
- bool isLosslessCast() const;
-
/// A no-op cast is one that can be effected without changing any bits.
/// It implies that the source and destination types are the same size. The
/// DataLayout argument is to determine the pointer size when examining casts
diff --git a/llvm/lib/IR/Instructions.cpp b/llvm/lib/IR/Instructions.cpp
index 96301ad6933ad..c72fdc8ba75e3 100644
--- a/llvm/lib/IR/Instructions.cpp
+++ b/llvm/lib/IR/Instructions.cpp
@@ -3167,23 +3167,6 @@ bool CastInst::isIntegerCast() const {
}
}
-bool CastInst::isLosslessCast() const {
- // Only BitCast can be lossless, exit fast if we're not BitCast
- if (getOpcode() != Instruction::BitCast)
- return false;
-
- // Identity cast is always lossless
- Type *SrcTy = getOperand(0)->getType();
- Type *DstTy = getType();
- if (SrcTy == DstTy)
- return true;
-
- // Pointer to pointer is always lossless.
- if (SrcTy->isPointerTy())
- return DstTy->isPointerTy();
- return false; // Other types have no identity values
-}
-
/// This function determines if the CastInst does not require any bits to be
/// changed in order to effect the cast. Essentially, it identifies cases where
/// no code gen is necessary for the cast, hence the name no-op cast. For
diff --git a/llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp b/llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp
index 519fab256bbcd..71700506624c5 100644
--- a/llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp
+++ b/llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp
@@ -3126,49 +3126,6 @@ Instruction *InstCombinerImpl::visitCallBrInst(CallBrInst &CBI) {
return visitCallBase(CBI);
}
-/// If this cast does not affect the value passed through the varargs area, we
-/// can eliminate the use of the cast.
-static bool isSafeToEliminateVarargsCast(const CallBase &Call,
- const DataLayout &DL,
- const CastInst *const CI,
- const int ix) {
- if (!CI->isLosslessCast())
- return false;
-
- // If this is a GC intrinsic, avoid munging types. We need types for
- // statepoint reconstruction in SelectionDAG.
- // TODO: This is probably something which should be expanded to all
- // intrinsics since the entire point of intrinsics is that
- // they are understandable by the optimizer.
- if (isa<GCStatepointInst>(Call) || isa<GCRelocateInst>(Call) ||
- isa<GCResultInst>(Call))
- return false;
-
- // Opaque pointers are compatible with any byval types.
- PointerType *SrcTy = cast<PointerType>(CI->getOperand(0)->getType());
- if (SrcTy->isOpaque())
- return true;
-
- // The size of ByVal or InAlloca arguments is derived from the type, so we
- // can't change to a type with a
diff erent size. If the size were
- // passed explicitly we could avoid this check.
- if (!Call.isPassPointeeByValueArgument(ix))
- return true;
-
- // The transform currently only handles type replacement for byval, not other
- // type-carrying attributes.
- if (!Call.isByValArgument(ix))
- return false;
-
- Type *SrcElemTy = SrcTy->getNonOpaquePointerElementType();
- Type *DstElemTy = Call.getParamByValType(ix);
- if (!SrcElemTy->isSized() || !DstElemTy->isSized())
- return false;
- if (DL.getTypeAllocSize(SrcElemTy) != DL.getTypeAllocSize(DstElemTy))
- return false;
- return true;
-}
-
Instruction *InstCombinerImpl::tryOptimizeCall(CallInst *CI) {
if (!CI->getCalledFunction()) return nullptr;
@@ -3417,32 +3374,6 @@ Instruction *InstCombinerImpl::visitCallBase(CallBase &Call) {
if (IntrinsicInst *II = findInitTrampoline(Callee))
return transformCallThroughTrampoline(Call, *II);
- // TODO: Drop this transform once opaque pointer transition is done.
- FunctionType *FTy = Call.getFunctionType();
- if (FTy->isVarArg()) {
- int ix = FTy->getNumParams();
- // See if we can optimize any arguments passed through the varargs area of
- // the call.
- for (auto I = Call.arg_begin() + FTy->getNumParams(), E = Call.arg_end();
- I != E; ++I, ++ix) {
- CastInst *CI = dyn_cast<CastInst>(*I);
- if (CI && isSafeToEliminateVarargsCast(Call, DL, CI, ix)) {
- replaceUse(*I, CI->getOperand(0));
-
- // Update the byval type to match the pointer type.
- // Not necessary for opaque pointers.
- PointerType *NewTy = cast<PointerType>(CI->getOperand(0)->getType());
- if (!NewTy->isOpaque() && Call.isByValArgument(ix)) {
- Call.removeParamAttr(ix, Attribute::ByVal);
- Call.addParamAttr(ix, Attribute::getWithByValType(
- Call.getContext(),
- NewTy->getNonOpaquePointerElementType()));
- }
- Changed = true;
- }
- }
- }
-
if (isa<InlineAsm>(Callee) && !Call.doesNotThrow()) {
InlineAsm *IA = cast<InlineAsm>(Callee);
if (!IA->canThrow()) {
More information about the llvm-commits
mailing list