- case Instruction::Cast: {
- // We only need to handle a few cases here. Almost all casts will
- // automatically fold, just the ones involving pointers won't.
- //
- Constant *Op = CE->getOperand(0);
- GenericValue GV = getConstantValue(Op);
-
- // Handle cast of pointer to pointer...
- if (Op->getType()->getTypeID() == C->getType()->getTypeID())
- return GV;
-
- // Handle a cast of pointer to any integral type...
- if (isa<PointerType>(Op->getType()) && C->getType()->isIntegral())
- return GV;
-
- // Handle cast of integer to a pointer...
- if (isa<PointerType>(C->getType()) && Op->getType()->isIntegral())
- switch (Op->getType()->getTypeID()) {
- case Type::BoolTyID: return PTOGV((void*)(uintptr_t)GV.BoolVal);
- case Type::SByteTyID: return PTOGV((void*)( intptr_t)GV.SByteVal);
- case Type::UByteTyID: return PTOGV((void*)(uintptr_t)GV.UByteVal);
- case Type::ShortTyID: return PTOGV((void*)( intptr_t)GV.ShortVal);
- case Type::UShortTyID: return PTOGV((void*)(uintptr_t)GV.UShortVal);
- case Type::IntTyID: return PTOGV((void*)( intptr_t)GV.IntVal);
- case Type::UIntTyID: return PTOGV((void*)(uintptr_t)GV.UIntVal);
- case Type::LongTyID: return PTOGV((void*)( intptr_t)GV.LongVal);
- case Type::ULongTyID: return PTOGV((void*)(uintptr_t)GV.ULongVal);
- default: assert(0 && "Unknown integral type!");
- }
- break;
+ case Instruction::Trunc: {
+ GenericValue GV = getConstantValue(Op0);
+ uint32_t BitWidth = cast<IntegerType>(CE->getType())->getBitWidth();
+ GV.IntVal = GV.IntVal.trunc(BitWidth);
+ return GV;
+ }
+ case Instruction::ZExt: {
+ GenericValue GV = getConstantValue(Op0);
+ uint32_t BitWidth = cast<IntegerType>(CE->getType())->getBitWidth();
+ GV.IntVal = GV.IntVal.zext(BitWidth);
+ return GV;
+ }
+ case Instruction::SExt: {
+ GenericValue GV = getConstantValue(Op0);
+ uint32_t BitWidth = cast<IntegerType>(CE->getType())->getBitWidth();
+ GV.IntVal = GV.IntVal.sext(BitWidth);
+ return GV;
+ }
+ case Instruction::FPTrunc: {
+ // FIXME long double
+ GenericValue GV = getConstantValue(Op0);
+ GV.FloatVal = float(GV.DoubleVal);
+ return GV;
+ }
+ case Instruction::FPExt:{
+ // FIXME long double
+ GenericValue GV = getConstantValue(Op0);
+ GV.DoubleVal = double(GV.FloatVal);
+ return GV;
+ }
+ case Instruction::UIToFP: {
+ GenericValue GV = getConstantValue(Op0);
+ if (CE->getType() == Type::FloatTy)
+ GV.FloatVal = float(GV.IntVal.roundToDouble());
+ else if (CE->getType() == Type::DoubleTy)
+ GV.DoubleVal = GV.IntVal.roundToDouble();
+ else if (CE->getType() == Type::X86_FP80Ty) {
+ const uint64_t zero[] = {0, 0};
+ APFloat apf = APFloat(APInt(80, 2, zero));
+ (void)apf.convertFromAPInt(GV.IntVal,
+ false,
+ APFloat::rmNearestTiesToEven);
+ GV.IntVal = apf.bitcastToAPInt();
+ }
+ return GV;
+ }
+ case Instruction::SIToFP: {
+ GenericValue GV = getConstantValue(Op0);
+ if (CE->getType() == Type::FloatTy)
+ GV.FloatVal = float(GV.IntVal.signedRoundToDouble());
+ else if (CE->getType() == Type::DoubleTy)
+ GV.DoubleVal = GV.IntVal.signedRoundToDouble();
+ else if (CE->getType() == Type::X86_FP80Ty) {
+ const uint64_t zero[] = { 0, 0};
+ APFloat apf = APFloat(APInt(80, 2, zero));
+ (void)apf.convertFromAPInt(GV.IntVal,
+ true,
+ APFloat::rmNearestTiesToEven);
+ GV.IntVal = apf.bitcastToAPInt();
+ }
+ return GV;
+ }
+ case Instruction::FPToUI: // double->APInt conversion handles sign
+ case Instruction::FPToSI: {
+ GenericValue GV = getConstantValue(Op0);
+ uint32_t BitWidth = cast<IntegerType>(CE->getType())->getBitWidth();
+ if (Op0->getType() == Type::FloatTy)
+ GV.IntVal = APIntOps::RoundFloatToAPInt(GV.FloatVal, BitWidth);
+ else if (Op0->getType() == Type::DoubleTy)
+ GV.IntVal = APIntOps::RoundDoubleToAPInt(GV.DoubleVal, BitWidth);
+ else if (Op0->getType() == Type::X86_FP80Ty) {
+ APFloat apf = APFloat(GV.IntVal);
+ uint64_t v;
+ bool ignored;
+ (void)apf.convertToInteger(&v, BitWidth,
+ CE->getOpcode()==Instruction::FPToSI,
+ APFloat::rmTowardZero, &ignored);
+ GV.IntVal = v; // endian?
+ }
+ return GV;
+ }
+ case Instruction::PtrToInt: {
+ GenericValue GV = getConstantValue(Op0);
+ uint32_t PtrWidth = TD->getPointerSizeInBits();
+ GV.IntVal = APInt(PtrWidth, uintptr_t(GV.PointerVal));
+ return GV;
+ }
+ case Instruction::IntToPtr: {
+ GenericValue GV = getConstantValue(Op0);
+ uint32_t PtrWidth = TD->getPointerSizeInBits();
+ if (PtrWidth != GV.IntVal.getBitWidth())
+ GV.IntVal = GV.IntVal.zextOrTrunc(PtrWidth);
+ assert(GV.IntVal.getBitWidth() <= 64 && "Bad pointer width");
+ GV.PointerVal = PointerTy(uintptr_t(GV.IntVal.getZExtValue()));
+ return GV;
+ }
+ case Instruction::BitCast: {
+ GenericValue GV = getConstantValue(Op0);
+ const Type* DestTy = CE->getType();
+ switch (Op0->getType()->getTypeID()) {
+ default: llvm_unreachable("Invalid bitcast operand");
+ case Type::IntegerTyID:
+ assert(DestTy->isFloatingPoint() && "invalid bitcast");
+ if (DestTy == Type::FloatTy)
+ GV.FloatVal = GV.IntVal.bitsToFloat();
+ else if (DestTy == Type::DoubleTy)
+ GV.DoubleVal = GV.IntVal.bitsToDouble();
+ break;
+ case Type::FloatTyID:
+ assert(DestTy == Type::Int32Ty && "Invalid bitcast");
+ GV.IntVal.floatToBits(GV.FloatVal);
+ break;
+ case Type::DoubleTyID:
+ assert(DestTy == Type::Int64Ty && "Invalid bitcast");
+ GV.IntVal.doubleToBits(GV.DoubleVal);
+ break;
+ case Type::PointerTyID:
+ assert(isa<PointerType>(DestTy) && "Invalid bitcast");
+ break; // getConstantValue(Op0) above already converted it
+ }
+ return GV;