6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-11-23 16:19:52 +00:00
Code Issues Projects Releases Wiki Activity

inline and remove the rest of commonIntCastTransforms.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@93091 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner
2010-01-10 01:00:46 +00:00
parent 75215c9e39
commit d84dfa43f2
2 changed files with 18 additions and 18 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
lib/Transforms/InstCombine/InstCombine.h
View File

@@ -150,7 +150,6 @@ public:
Instruction *FoldShiftByConstant(Value *Op0, ConstantInt *Op1, Instruction *FoldShiftByConstant(Value *Op0, ConstantInt *Op1,
BinaryOperator &I); BinaryOperator &I);
Instruction *commonCastTransforms(CastInst &CI); Instruction *commonCastTransforms(CastInst &CI);
Instruction *commonIntCastTransforms(CastInst &CI);
Instruction *commonPointerCastTransforms(CastInst &CI); Instruction *commonPointerCastTransforms(CastInst &CI);
Instruction *visitTrunc(TruncInst &CI); Instruction *visitTrunc(TruncInst &CI);
Instruction *visitZExt(ZExtInst &CI); Instruction *visitZExt(ZExtInst &CI);

35
lib/Transforms/InstCombine/InstCombineCasts.cpp
View File

@@ -302,19 +302,6 @@ Instruction *InstCombiner::commonCastTransforms(CastInst &CI) {
return 0; return 0;
} }
/// commonIntCastTransforms - This function implements the common transforms
/// for trunc, zext, and sext.
Instruction *InstCombiner::commonIntCastTransforms(CastInst &CI) {
if (Instruction *Result = commonCastTransforms(CI))
return Result;
// See if we can simplify any instructions used by the LHS whose sole
// purpose is to compute bits we don't care about.
if (SimplifyDemandedInstructionBits(CI))
return &CI;
return 0;
}
/// CanEvaluateTruncated - Return true if we can evaluate the specified /// CanEvaluateTruncated - Return true if we can evaluate the specified
/// expression tree as type Ty instead of its larger type, and arrive with the /// expression tree as type Ty instead of its larger type, and arrive with the
/// same value. This is used by code that tries to eliminate truncates. /// same value. This is used by code that tries to eliminate truncates.
@@ -420,9 +407,14 @@ static bool CanEvaluateTruncated(Value *V, const Type *Ty) {
} }
Instruction *InstCombiner::visitTrunc(TruncInst &CI) { Instruction *InstCombiner::visitTrunc(TruncInst &CI) {
if (Instruction *Result = commonIntCastTransforms(CI)) if (Instruction *Result = commonCastTransforms(CI))
return Result; return Result;
// See if we can simplify any instructions used by the input whose sole
// purpose is to compute bits we don't care about.
if (SimplifyDemandedInstructionBits(CI))
return &CI;
Value *Src = CI.getOperand(0); Value *Src = CI.getOperand(0);
const Type *DestTy = CI.getType(), *SrcTy = Src->getType(); const Type *DestTy = CI.getType(), *SrcTy = Src->getType();
@@ -690,11 +682,15 @@ static int CanEvaluateZExtd(Value *V, const Type *Ty,unsigned &NumCastsRemoved,
Instruction *InstCombiner::visitZExt(ZExtInst &CI) { Instruction *InstCombiner::visitZExt(ZExtInst &CI) {
// If one of the common conversion will work, do it. // If one of the common conversion will work, do it.
if (Instruction *Result = commonIntCastTransforms(CI)) if (Instruction *Result = commonCastTransforms(CI))
return Result; return Result;
Value *Src = CI.getOperand(0); // See if we can simplify any instructions used by the input whose sole
// purpose is to compute bits we don't care about.
if (SimplifyDemandedInstructionBits(CI))
return &CI;
Value *Src = CI.getOperand(0);
const Type *SrcTy = Src->getType(), *DestTy = CI.getType(); const Type *SrcTy = Src->getType(), *DestTy = CI.getType();
// Attempt to extend the entire input expression tree to the destination // Attempt to extend the entire input expression tree to the destination
@@ -941,9 +937,14 @@ static unsigned CanEvaluateSExtd(Value *V, const Type *Ty,
} }
Instruction *InstCombiner::visitSExt(SExtInst &CI) { Instruction *InstCombiner::visitSExt(SExtInst &CI) {
if (Instruction *I = commonIntCastTransforms(CI)) if (Instruction *I = commonCastTransforms(CI))
return I; return I;
// See if we can simplify any instructions used by the input whose sole
// purpose is to compute bits we don't care about.
if (SimplifyDemandedInstructionBits(CI))
return &CI;
Value *Src = CI.getOperand(0); Value *Src = CI.getOperand(0);
const Type *SrcTy = Src->getType(), *DestTy = CI.getType(); const Type *SrcTy = Src->getType(), *DestTy = CI.getType();