6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-08-17 21:29:20 +00:00
Code Issues Projects Releases Wiki Activity

Implement correct constant folding of bitcast. This implements

Browse Source 
Transforms/ConstProp/bitcast.ll and fixes
SingleSource/Regression/C/2003-10-12-GlobalVarInitializers


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@32438 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2006-12-11 18:30:27 +00:00
parent 4ed4ac34c3
commit 14f440aae7
1 changed files with 33 additions and 15 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
lib/VMCore/ConstantFold.cpp
View File

@ -828,10 +828,6 @@ Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V,
const Type *DestTy) {
const Type *SrcTy = V->getType();
// Handle some simple cases
if (SrcTy == DestTy)
return (Constant*)V; // no-op cast
if (isa<UndefValue>(V))
return UndefValue::get(DestTy);
@ -901,6 +897,8 @@ Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V,
return ConstantIntegral::get(DestTy, CI->getZExtValue());
return 0;
case Instruction::BitCast:
if (SrcTy == DestTy) return (Constant*)V; // no-op cast
// Check to see if we are casting a pointer to an aggregate to a pointer to
// the first element. If so, return the appropriate GEP instruction.
if (const PointerType *PTy = dyn_cast<PointerType>(V->getType()))
@ -960,18 +958,38 @@ Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V,
}
}
// Handle sign conversion for integer no-op casts. We need to cast the
// value to the correct signedness before we try to cast it to the
// destination type. Be careful to do this only for integer types.
if (isa<ConstantIntegral>(V) && SrcTy->isInteger()) {
if (SrcTy->isSigned())
V = ConstantInt::get(SrcTy->getUnsignedVersion(),
cast<ConstantIntegral>(V)->getZExtValue());
else
V = ConstantInt::get(SrcTy->getSignedVersion(),
cast<ConstantIntegral>(V)->getSExtValue());
// Finally, implement bitcast folding now. The code below doesn't handle
// bitcast right.
if (isa<ConstantPointerNull>(V)) // ptr->ptr cast.
return ConstantPointerNull::get(cast<PointerType>(DestTy));
// Handle integral constant input.
if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
// Integral -> Integral, must be changing sign.
if (DestTy->isIntegral())
return ConstantInt::get(DestTy, CI->getZExtValue());
if (DestTy->isFloatingPoint()) {
if (DestTy == Type::FloatTy)
return ConstantFP::get(DestTy, BitsToFloat(CI->getZExtValue()));
assert(DestTy == Type::DoubleTy && "Unknown FP type!");
return ConstantFP::get(DestTy, BitsToDouble(CI->getZExtValue()));
}
// Otherwise, can't fold this (packed?)
return 0;
}
break;
// Handle ConstantFP input.
if (const ConstantFP *FP = dyn_cast<ConstantFP>(V)) {
// FP -> Integral.
if (DestTy->isIntegral()) {
if (DestTy == Type::FloatTy)
return ConstantInt::get(DestTy, FloatToBits(FP->getValue()));
assert(DestTy == Type::DoubleTy && "Unknown FP type!");
return ConstantInt::get(DestTy, DoubleToBits(FP->getValue()));
}
}
return 0;
default:
assert(!"Invalid CE CastInst opcode");
break;