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

Rename APFloat::convertToAPInt to bitcastToAPInt to

Browse Source 
make it clearer what the function does.  No functional
change.



git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@57325 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Dale Johannesen 2008-10-09 18:53:47 +00:00
parent a6bf66d0d6
commit 7111b02c73
15 changed files with 51 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
include/llvm/ADT/APFloat.h
View File

@ -129,7 +129,7 @@ namespace llvm {
static const fltSemantics IEEEquad; static const fltSemantics IEEEquad;
static const fltSemantics PPCDoubleDouble; static const fltSemantics PPCDoubleDouble;
static const fltSemantics x87DoubleExtended; static const fltSemantics x87DoubleExtended;
/* And this psuedo, used to construct APFloats that cannot /* And this pseudo, used to construct APFloats that cannot
conflict with anything real. */ conflict with anything real. */
static const fltSemantics Bogus; static const fltSemantics Bogus;
@ -226,7 +226,7 @@ namespace llvm {
opStatus convertFromZeroExtendedInteger(const integerPart *, unsigned int, opStatus convertFromZeroExtendedInteger(const integerPart *, unsigned int,
bool, roundingMode); bool, roundingMode);
opStatus convertFromString(const char *, roundingMode); opStatus convertFromString(const char *, roundingMode);
APInt convertToAPInt() const; APInt bitcastToAPInt() const;
double convertToDouble() const; double convertToDouble() const;
float convertToFloat() const; float convertToFloat() const;
@ -239,6 +239,9 @@ namespace llvm {
compare unordered, 0==-0). */ compare unordered, 0==-0). */
cmpResult compare(const APFloat &) const; cmpResult compare(const APFloat &) const;
/* Bitwise comparison for equality (QNaNs compare equal, 0!=-0). */
bool bitwiseIsEqual(const APFloat &) const;
/* Write out a hexadecimal representation of the floating point /* Write out a hexadecimal representation of the floating point
value to DST, which must be of sufficient size, in the C99 form value to DST, which must be of sufficient size, in the C99 form
[-]0xh.hhhhp[+-]d. Return the number of characters written, [-]0xh.hhhhp[+-]d. Return the number of characters written,
@ -246,9 +249,6 @@ namespace llvm {
unsigned int convertToHexString(char *dst, unsigned int hexDigits, unsigned int convertToHexString(char *dst, unsigned int hexDigits,
bool upperCase, roundingMode) const; bool upperCase, roundingMode) const;
/* Bitwise comparison for equality (QNaNs compare equal, 0!=-0). */
bool bitwiseIsEqual(const APFloat &) const;
/* Simple queries. */ /* Simple queries. */
fltCategory getCategory() const { return category; } fltCategory getCategory() const { return category; }
const fltSemantics &getSemantics() const { return *semantics; } const fltSemantics &getSemantics() const { return *semantics; }

6
lib/Bitcode/Writer/BitcodeWriter.cpp
View File

@ -542,15 +542,15 @@ static void WriteConstants(unsigned FirstVal, unsigned LastVal,
Code = bitc::CST_CODE_FLOAT; Code = bitc::CST_CODE_FLOAT;
const Type *Ty = CFP->getType(); const Type *Ty = CFP->getType();
if (Ty == Type::FloatTy || Ty == Type::DoubleTy) { if (Ty == Type::FloatTy || Ty == Type::DoubleTy) {
Record.push_back(CFP->getValueAPF().convertToAPInt().getZExtValue()); Record.push_back(CFP->getValueAPF().bitcastToAPInt().getZExtValue());
} else if (Ty == Type::X86_FP80Ty) { } else if (Ty == Type::X86_FP80Ty) {
// api needed to prevent premature destruction // api needed to prevent premature destruction
APInt api = CFP->getValueAPF().convertToAPInt(); APInt api = CFP->getValueAPF().bitcastToAPInt();
const uint64_t *p = api.getRawData(); const uint64_t *p = api.getRawData();
Record.push_back(p[0]); Record.push_back(p[0]);
Record.push_back((uint16_t)p[1]); Record.push_back((uint16_t)p[1]);
} else if (Ty == Type::FP128Ty || Ty == Type::PPC_FP128Ty) { } else if (Ty == Type::FP128Ty || Ty == Type::PPC_FP128Ty) {
APInt api = CFP->getValueAPF().convertToAPInt(); APInt api = CFP->getValueAPF().bitcastToAPInt();
const uint64_t *p = api.getRawData(); const uint64_t *p = api.getRawData();
Record.push_back(p[0]); Record.push_back(p[0]);
Record.push_back(p[1]); Record.push_back(p[1]);

2
lib/Bitcode/Writer/SerializeAPFloat.cpp
View File

@ -17,5 +17,5 @@
using namespace llvm; using namespace llvm;
void APFloat::Emit(Serializer& S) const { void APFloat::Emit(Serializer& S) const {
S.Emit(convertToAPInt()); S.Emit(bitcastToAPInt());
} }

8
lib/CodeGen/AsmPrinter/AsmPrinter.cpp
View File

@ -969,7 +969,7 @@ void AsmPrinter::EmitGlobalConstant(const Constant *CV) {
// precision... // precision...
if (CFP->getType() == Type::DoubleTy) { if (CFP->getType() == Type::DoubleTy) {
double Val = CFP->getValueAPF().convertToDouble(); // for comment only double Val = CFP->getValueAPF().convertToDouble(); // for comment only
uint64_t i = CFP->getValueAPF().convertToAPInt().getZExtValue(); uint64_t i = CFP->getValueAPF().bitcastToAPInt().getZExtValue();
if (TAI->getData64bitsDirective()) if (TAI->getData64bitsDirective())
O << TAI->getData64bitsDirective() << i << '\t' O << TAI->getData64bitsDirective() << i << '\t'
<< TAI->getCommentString() << " double value: " << Val << '\n'; << TAI->getCommentString() << " double value: " << Val << '\n';
@ -992,13 +992,13 @@ void AsmPrinter::EmitGlobalConstant(const Constant *CV) {
} else if (CFP->getType() == Type::FloatTy) { } else if (CFP->getType() == Type::FloatTy) {
float Val = CFP->getValueAPF().convertToFloat(); // for comment only float Val = CFP->getValueAPF().convertToFloat(); // for comment only
O << TAI->getData32bitsDirective() O << TAI->getData32bitsDirective()
<< CFP->getValueAPF().convertToAPInt().getZExtValue() << CFP->getValueAPF().bitcastToAPInt().getZExtValue()
<< '\t' << TAI->getCommentString() << " float " << Val << '\n'; << '\t' << TAI->getCommentString() << " float " << Val << '\n';
return; return;
} else if (CFP->getType() == Type::X86_FP80Ty) { } else if (CFP->getType() == Type::X86_FP80Ty) {
// all long double variants are printed as hex // all long double variants are printed as hex
// api needed to prevent premature destruction // api needed to prevent premature destruction
APInt api = CFP->getValueAPF().convertToAPInt(); APInt api = CFP->getValueAPF().bitcastToAPInt();
const uint64_t *p = api.getRawData(); const uint64_t *p = api.getRawData();
APFloat DoubleVal = CFP->getValueAPF(); APFloat DoubleVal = CFP->getValueAPF();
DoubleVal.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven); DoubleVal.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven);
@ -1042,7 +1042,7 @@ void AsmPrinter::EmitGlobalConstant(const Constant *CV) {
} else if (CFP->getType() == Type::PPC_FP128Ty) { } else if (CFP->getType() == Type::PPC_FP128Ty) {
// all long double variants are printed as hex // all long double variants are printed as hex
// api needed to prevent premature destruction // api needed to prevent premature destruction
APInt api = CFP->getValueAPF().convertToAPInt(); APInt api = CFP->getValueAPF().bitcastToAPInt();
const uint64_t *p = api.getRawData(); const uint64_t *p = api.getRawData();
if (TD->isBigEndian()) { if (TD->isBigEndian()) {
O << TAI->getData32bitsDirective() << uint32_t(p[0] >> 32) O << TAI->getData32bitsDirective() << uint32_t(p[0] >> 32)

4
lib/CodeGen/MachOWriter.cpp
View File

@ -878,7 +878,7 @@ void MachOWriter::InitMem(const Constant *C, void *Addr, intptr_t Offset,
break; break;
} }
case Type::FloatTyID: { case Type::FloatTyID: {
uint32_t val = cast<ConstantFP>(PC)->getValueAPF().convertToAPInt(). uint32_t val = cast<ConstantFP>(PC)->getValueAPF().bitcastToAPInt().
getZExtValue(); getZExtValue();
if (TD->isBigEndian()) if (TD->isBigEndian())
val = ByteSwap_32(val); val = ByteSwap_32(val);
@ -889,7 +889,7 @@ void MachOWriter::InitMem(const Constant *C, void *Addr, intptr_t Offset,
break; break;
} }
case Type::DoubleTyID: { case Type::DoubleTyID: {
uint64_t val = cast<ConstantFP>(PC)->getValueAPF().convertToAPInt(). uint64_t val = cast<ConstantFP>(PC)->getValueAPF().bitcastToAPInt().
getZExtValue(); getZExtValue();
if (TD->isBigEndian()) if (TD->isBigEndian())
val = ByteSwap_64(val); val = ByteSwap_64(val);

6
lib/CodeGen/SelectionDAG/DAGCombiner.cpp
View File

@ -4630,7 +4630,7 @@ SDValue DAGCombiner::visitSTORE(SDNode *N) {
if ((!AfterLegalize && !ST->isVolatile()) || if ((!AfterLegalize && !ST->isVolatile()) ||
TLI.isOperationLegal(ISD::STORE, MVT::i32)) { TLI.isOperationLegal(ISD::STORE, MVT::i32)) {
Tmp = DAG.getConstant((uint32_t)CFP->getValueAPF(). Tmp = DAG.getConstant((uint32_t)CFP->getValueAPF().
convertToAPInt().getZExtValue(), MVT::i32); bitcastToAPInt().getZExtValue(), MVT::i32);
return DAG.getStore(Chain, Tmp, Ptr, ST->getSrcValue(), return DAG.getStore(Chain, Tmp, Ptr, ST->getSrcValue(),
ST->getSrcValueOffset(), ST->isVolatile(), ST->getSrcValueOffset(), ST->isVolatile(),
ST->getAlignment()); ST->getAlignment());
@ -4639,7 +4639,7 @@ SDValue DAGCombiner::visitSTORE(SDNode *N) {
case MVT::f64: case MVT::f64:
if ((!AfterLegalize && !ST->isVolatile()) || if ((!AfterLegalize && !ST->isVolatile()) ||
TLI.isOperationLegal(ISD::STORE, MVT::i64)) { TLI.isOperationLegal(ISD::STORE, MVT::i64)) {
Tmp = DAG.getConstant(CFP->getValueAPF().convertToAPInt(). Tmp = DAG.getConstant(CFP->getValueAPF().bitcastToAPInt().
getZExtValue(), MVT::i64); getZExtValue(), MVT::i64);
return DAG.getStore(Chain, Tmp, Ptr, ST->getSrcValue(), return DAG.getStore(Chain, Tmp, Ptr, ST->getSrcValue(),
ST->getSrcValueOffset(), ST->isVolatile(), ST->getSrcValueOffset(), ST->isVolatile(),
@ -4649,7 +4649,7 @@ SDValue DAGCombiner::visitSTORE(SDNode *N) {
// Many FP stores are not made apparent until after legalize, e.g. for // Many FP stores are not made apparent until after legalize, e.g. for
// argument passing. Since this is so common, custom legalize the // argument passing. Since this is so common, custom legalize the
// 64-bit integer store into two 32-bit stores. // 64-bit integer store into two 32-bit stores.
uint64_t Val = CFP->getValueAPF().convertToAPInt().getZExtValue(); uint64_t Val = CFP->getValueAPF().bitcastToAPInt().getZExtValue();
SDValue Lo = DAG.getConstant(Val & 0xFFFFFFFF, MVT::i32); SDValue Lo = DAG.getConstant(Val & 0xFFFFFFFF, MVT::i32);
SDValue Hi = DAG.getConstant(Val >> 32, MVT::i32); SDValue Hi = DAG.getConstant(Val >> 32, MVT::i32);
if (TLI.isBigEndian()) std::swap(Lo, Hi); if (TLI.isBigEndian()) std::swap(Lo, Hi);

10
lib/CodeGen/SelectionDAG/LegalizeDAG.cpp
View File

@ -445,7 +445,7 @@ static SDValue ExpandConstantFP(ConstantFPSDNode *CFP, bool UseCP,
if (!UseCP) { if (!UseCP) {
if (VT!=MVT::f64 && VT!=MVT::f32) if (VT!=MVT::f64 && VT!=MVT::f32)
assert(0 && "Invalid type expansion"); assert(0 && "Invalid type expansion");
return DAG.getConstant(LLVMC->getValueAPF().convertToAPInt(), return DAG.getConstant(LLVMC->getValueAPF().bitcastToAPInt(),
(VT == MVT::f64) ? MVT::i64 : MVT::i32); (VT == MVT::f64) ? MVT::i64 : MVT::i32);
} }
@ -2357,7 +2357,7 @@ SDValue SelectionDAGLegalize::LegalizeOp(SDValue Op) {
if (CFP->getValueType(0) == MVT::f32 && if (CFP->getValueType(0) == MVT::f32 &&
getTypeAction(MVT::i32) == Legal) { getTypeAction(MVT::i32) == Legal) {
Tmp3 = DAG.getConstant(CFP->getValueAPF(). Tmp3 = DAG.getConstant(CFP->getValueAPF().
convertToAPInt().zextOrTrunc(32), bitcastToAPInt().zextOrTrunc(32),
MVT::i32); MVT::i32);
Result = DAG.getStore(Tmp1, Tmp3, Tmp2, ST->getSrcValue(), Result = DAG.getStore(Tmp1, Tmp3, Tmp2, ST->getSrcValue(),
SVOffset, isVolatile, Alignment); SVOffset, isVolatile, Alignment);
@ -2365,7 +2365,7 @@ SDValue SelectionDAGLegalize::LegalizeOp(SDValue Op) {
} else if (CFP->getValueType(0) == MVT::f64) { } else if (CFP->getValueType(0) == MVT::f64) {
// If this target supports 64-bit registers, do a single 64-bit store. // If this target supports 64-bit registers, do a single 64-bit store.
if (getTypeAction(MVT::i64) == Legal) { if (getTypeAction(MVT::i64) == Legal) {
Tmp3 = DAG.getConstant(CFP->getValueAPF().convertToAPInt(). Tmp3 = DAG.getConstant(CFP->getValueAPF().bitcastToAPInt().
zextOrTrunc(64), MVT::i64); zextOrTrunc(64), MVT::i64);
Result = DAG.getStore(Tmp1, Tmp3, Tmp2, ST->getSrcValue(), Result = DAG.getStore(Tmp1, Tmp3, Tmp2, ST->getSrcValue(),
SVOffset, isVolatile, Alignment); SVOffset, isVolatile, Alignment);
@ -2374,7 +2374,7 @@ SDValue SelectionDAGLegalize::LegalizeOp(SDValue Op) {
// Otherwise, if the target supports 32-bit registers, use 2 32-bit // Otherwise, if the target supports 32-bit registers, use 2 32-bit
// stores. If the target supports neither 32- nor 64-bits, this // stores. If the target supports neither 32- nor 64-bits, this
// xform is certainly not worth it. // xform is certainly not worth it.
const APInt &IntVal =CFP->getValueAPF().convertToAPInt(); const APInt &IntVal =CFP->getValueAPF().bitcastToAPInt();
SDValue Lo = DAG.getConstant(APInt(IntVal).trunc(32), MVT::i32); SDValue Lo = DAG.getConstant(APInt(IntVal).trunc(32), MVT::i32);
SDValue Hi = DAG.getConstant(IntVal.lshr(32).trunc(32), MVT::i32); SDValue Hi = DAG.getConstant(IntVal.lshr(32).trunc(32), MVT::i32);
if (TLI.isBigEndian()) std::swap(Lo, Hi); if (TLI.isBigEndian()) std::swap(Lo, Hi);
@ -5912,7 +5912,7 @@ void SelectionDAGLegalize::ExpandOp(SDValue Op, SDValue &Lo, SDValue &Hi){
case ISD::ConstantFP: { case ISD::ConstantFP: {
ConstantFPSDNode *CFP = cast<ConstantFPSDNode>(Node); ConstantFPSDNode *CFP = cast<ConstantFPSDNode>(Node);
if (CFP->getValueType(0) == MVT::ppcf128) { if (CFP->getValueType(0) == MVT::ppcf128) {
APInt api = CFP->getValueAPF().convertToAPInt(); APInt api = CFP->getValueAPF().bitcastToAPInt();
Lo = DAG.getConstantFP(APFloat(APInt(64, 1, &api.getRawData()[1])), Lo = DAG.getConstantFP(APFloat(APInt(64, 1, &api.getRawData()[1])),
MVT::f64); MVT::f64);
Hi = DAG.getConstantFP(APFloat(APInt(64, 1, &api.getRawData()[0])), Hi = DAG.getConstantFP(APFloat(APInt(64, 1, &api.getRawData()[0])),

4
lib/CodeGen/SelectionDAG/LegalizeFloatTypes.cpp
View File

@ -93,7 +93,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_BUILD_PAIR(SDNode *N) {
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_ConstantFP(ConstantFPSDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_ConstantFP(ConstantFPSDNode *N) {
return DAG.getConstant(N->getValueAPF().convertToAPInt(), return DAG.getConstant(N->getValueAPF().bitcastToAPInt(),
TLI.getTypeToTransformTo(N->getValueType(0))); TLI.getTypeToTransformTo(N->getValueType(0)));
} }
@ -586,7 +586,7 @@ void DAGTypeLegalizer::ExpandFloatRes_ConstantFP(SDNode *N, SDValue &Lo,
MVT NVT = TLI.getTypeToTransformTo(N->getValueType(0)); MVT NVT = TLI.getTypeToTransformTo(N->getValueType(0));
assert(NVT.getSizeInBits() == integerPartWidth && assert(NVT.getSizeInBits() == integerPartWidth &&
"Do not know how to expand this float constant!"); "Do not know how to expand this float constant!");
APInt C = cast<ConstantFPSDNode>(N)->getValueAPF().convertToAPInt(); APInt C = cast<ConstantFPSDNode>(N)->getValueAPF().bitcastToAPInt();
Lo = DAG.getConstantFP(APFloat(APInt(integerPartWidth, 1, Lo = DAG.getConstantFP(APFloat(APInt(integerPartWidth, 1,
&C.getRawData()[1])), NVT); &C.getRawData()[1])), NVT);
Hi = DAG.getConstantFP(APFloat(APInt(integerPartWidth, 1, Hi = DAG.getConstantFP(APFloat(APInt(integerPartWidth, 1,

16
lib/ExecutionEngine/ExecutionEngine.cpp
View File

@ -467,7 +467,7 @@ GenericValue ExecutionEngine::getConstantValue(const Constant *C) {
(void)apf.convertFromAPInt(GV.IntVal, (void)apf.convertFromAPInt(GV.IntVal,
false, false,
APFloat::rmNearestTiesToEven); APFloat::rmNearestTiesToEven);
GV.IntVal = apf.convertToAPInt(); GV.IntVal = apf.bitcastToAPInt();
} }
return GV; return GV;
} }
@ -483,7 +483,7 @@ GenericValue ExecutionEngine::getConstantValue(const Constant *C) {
(void)apf.convertFromAPInt(GV.IntVal, (void)apf.convertFromAPInt(GV.IntVal,
true, true,
APFloat::rmNearestTiesToEven); APFloat::rmNearestTiesToEven);
GV.IntVal = apf.convertToAPInt(); GV.IntVal = apf.bitcastToAPInt();
} }
return GV; return GV;
} }
@ -614,23 +614,23 @@ GenericValue ExecutionEngine::getConstantValue(const Constant *C) {
default: assert(0 && "Invalid long double opcode"); abort(); default: assert(0 && "Invalid long double opcode"); abort();
case Instruction::Add: case Instruction::Add:
apfLHS.add(APFloat(RHS.IntVal), APFloat::rmNearestTiesToEven); apfLHS.add(APFloat(RHS.IntVal), APFloat::rmNearestTiesToEven);
GV.IntVal = apfLHS.convertToAPInt(); GV.IntVal = apfLHS.bitcastToAPInt();
break; break;
case Instruction::Sub: case Instruction::Sub:
apfLHS.subtract(APFloat(RHS.IntVal), APFloat::rmNearestTiesToEven); apfLHS.subtract(APFloat(RHS.IntVal), APFloat::rmNearestTiesToEven);
GV.IntVal = apfLHS.convertToAPInt(); GV.IntVal = apfLHS.bitcastToAPInt();
break; break;
case Instruction::Mul: case Instruction::Mul:
apfLHS.multiply(APFloat(RHS.IntVal), APFloat::rmNearestTiesToEven); apfLHS.multiply(APFloat(RHS.IntVal), APFloat::rmNearestTiesToEven);
GV.IntVal = apfLHS.convertToAPInt(); GV.IntVal = apfLHS.bitcastToAPInt();
break; break;
case Instruction::FDiv: case Instruction::FDiv:
apfLHS.divide(APFloat(RHS.IntVal), APFloat::rmNearestTiesToEven); apfLHS.divide(APFloat(RHS.IntVal), APFloat::rmNearestTiesToEven);
GV.IntVal = apfLHS.convertToAPInt(); GV.IntVal = apfLHS.bitcastToAPInt();
break; break;
case Instruction::FRem: case Instruction::FRem:
apfLHS.mod(APFloat(RHS.IntVal), APFloat::rmNearestTiesToEven); apfLHS.mod(APFloat(RHS.IntVal), APFloat::rmNearestTiesToEven);
GV.IntVal = apfLHS.convertToAPInt(); GV.IntVal = apfLHS.bitcastToAPInt();
break; break;
} }
} }
@ -656,7 +656,7 @@ GenericValue ExecutionEngine::getConstantValue(const Constant *C) {
case Type::X86_FP80TyID: case Type::X86_FP80TyID:
case Type::FP128TyID: case Type::FP128TyID:
case Type::PPC_FP128TyID: case Type::PPC_FP128TyID:
Result.IntVal = cast <ConstantFP>(C)->getValueAPF().convertToAPInt(); Result.IntVal = cast <ConstantFP>(C)->getValueAPF().bitcastToAPInt();
break; break;
case Type::IntegerTyID: case Type::IntegerTyID:
Result.IntVal = cast<ConstantInt>(C)->getValue(); Result.IntVal = cast<ConstantInt>(C)->getValue();

8
lib/Support/APFloat.cpp
View File

@ -695,7 +695,7 @@ APFloat::~APFloat()
// Profile - This method 'profiles' an APFloat for use with FoldingSet. // Profile - This method 'profiles' an APFloat for use with FoldingSet.
void APFloat::Profile(FoldingSetNodeID& ID) const { void APFloat::Profile(FoldingSetNodeID& ID) const {
ID.Add(convertToAPInt()); ID.Add(bitcastToAPInt());
} }
unsigned int unsigned int
@ -2617,7 +2617,7 @@ APFloat::convertFloatAPFloatToAPInt() const
// and treating the result as a normal integer is unlikely to be useful. // and treating the result as a normal integer is unlikely to be useful.
APInt APInt
APFloat::convertToAPInt() const APFloat::bitcastToAPInt() const
{ {
if (semantics == (const llvm::fltSemantics*)&IEEEsingle) if (semantics == (const llvm::fltSemantics*)&IEEEsingle)
return convertFloatAPFloatToAPInt(); return convertFloatAPFloatToAPInt();
@ -2637,7 +2637,7 @@ float
APFloat::convertToFloat() const APFloat::convertToFloat() const
{ {
assert(semantics == (const llvm::fltSemantics*)&IEEEsingle); assert(semantics == (const llvm::fltSemantics*)&IEEEsingle);
APInt api = convertToAPInt(); APInt api = bitcastToAPInt();
return api.bitsToFloat(); return api.bitsToFloat();
} }
@ -2645,7 +2645,7 @@ double
APFloat::convertToDouble() const APFloat::convertToDouble() const
{ {
assert(semantics == (const llvm::fltSemantics*)&IEEEdouble); assert(semantics == (const llvm::fltSemantics*)&IEEEdouble);
APInt api = convertToAPInt(); APInt api = bitcastToAPInt();
return api.bitsToDouble(); return api.bitsToDouble();
} }

8
lib/Target/CBackend/CBackend.cpp
View File

@ -2028,20 +2028,20 @@ void CWriter::printFloatingPointConstants(Function &F) {
if (FPC->getType() == Type::DoubleTy) { if (FPC->getType() == Type::DoubleTy) {
double Val = FPC->getValueAPF().convertToDouble(); double Val = FPC->getValueAPF().convertToDouble();
uint64_t i = FPC->getValueAPF().convertToAPInt().getZExtValue(); uint64_t i = FPC->getValueAPF().bitcastToAPInt().getZExtValue();
Out << "static const ConstantDoubleTy FPConstant" << FPCounter++ Out << "static const ConstantDoubleTy FPConstant" << FPCounter++
<< " = 0x" << utohexstr(i) << " = 0x" << utohexstr(i)
<< "ULL; /* " << Val << " */\n"; << "ULL; /* " << Val << " */\n";
} else if (FPC->getType() == Type::FloatTy) { } else if (FPC->getType() == Type::FloatTy) {
float Val = FPC->getValueAPF().convertToFloat(); float Val = FPC->getValueAPF().convertToFloat();
uint32_t i = (uint32_t)FPC->getValueAPF().convertToAPInt(). uint32_t i = (uint32_t)FPC->getValueAPF().bitcastToAPInt().
getZExtValue(); getZExtValue();
Out << "static const ConstantFloatTy FPConstant" << FPCounter++ Out << "static const ConstantFloatTy FPConstant" << FPCounter++
<< " = 0x" << utohexstr(i) << " = 0x" << utohexstr(i)
<< "U; /* " << Val << " */\n"; << "U; /* " << Val << " */\n";
} else if (FPC->getType() == Type::X86_FP80Ty) { } else if (FPC->getType() == Type::X86_FP80Ty) {
// api needed to prevent premature destruction // api needed to prevent premature destruction
APInt api = FPC->getValueAPF().convertToAPInt(); APInt api = FPC->getValueAPF().bitcastToAPInt();
const uint64_t *p = api.getRawData(); const uint64_t *p = api.getRawData();
Out << "static const ConstantFP80Ty FPConstant" << FPCounter++ Out << "static const ConstantFP80Ty FPConstant" << FPCounter++
<< " = { 0x" << " = { 0x"
@ -2049,7 +2049,7 @@ void CWriter::printFloatingPointConstants(Function &F) {
<< "ULL, 0x" << utohexstr((uint16_t)(p[0] >> 48)) << ",{0,0,0}" << "ULL, 0x" << utohexstr((uint16_t)(p[0] >> 48)) << ",{0,0,0}"
<< "}; /* Long double constant */\n"; << "}; /* Long double constant */\n";
} else if (FPC->getType() == Type::PPC_FP128Ty) { } else if (FPC->getType() == Type::PPC_FP128Ty) {
APInt api = FPC->getValueAPF().convertToAPInt(); APInt api = FPC->getValueAPF().bitcastToAPInt();
const uint64_t *p = api.getRawData(); const uint64_t *p = api.getRawData();
Out << "static const ConstantFP128Ty FPConstant" << FPCounter++ Out << "static const ConstantFP128Ty FPConstant" << FPCounter++
<< " = { 0x" << " = { 0x"

5
lib/Target/CppBackend/CPPBackend.cpp
View File

@ -254,11 +254,12 @@ namespace {
Out << StrVal << "f"; Out << StrVal << "f";
} else if (CFP->getType() == Type::DoubleTy) } else if (CFP->getType() == Type::DoubleTy)
Out << "BitsToDouble(0x" Out << "BitsToDouble(0x"
<< utohexstr(CFP->getValueAPF().convertToAPInt().getZExtValue()) << utohexstr(CFP->getValueAPF().bitcastToAPInt().getZExtValue())
<< "ULL) /* " << StrVal << " */"; << "ULL) /* " << StrVal << " */";
else else
Out << "BitsToFloat(0x" Out << "BitsToFloat(0x"
<< utohexstr((uint32_t)CFP->getValueAPF().convertToAPInt().getZExtValue()) << utohexstr((uint32_t)CFP->getValueAPF().
bitcastToAPInt().getZExtValue())
<< "U) /* " << StrVal << " */"; << "U) /* " << StrVal << " */";
Out << ")"; Out << ")";
#if HAVE_PRINTF_A #if HAVE_PRINTF_A

8
lib/Target/MSIL/MSILWriter.cpp
View File

@ -432,10 +432,10 @@ void MSILWriter::printConstLoad(const Constant* C) {
uint64_t X; uint64_t X;
unsigned Size; unsigned Size;
if (FP->getType()->getTypeID()==Type::FloatTyID) { if (FP->getType()->getTypeID()==Type::FloatTyID) {
X = (uint32_t)FP->getValueAPF().convertToAPInt().getZExtValue(); X = (uint32_t)FP->getValueAPF().bitcastToAPInt().getZExtValue();
Size = 4; Size = 4;
} else { } else {
X = FP->getValueAPF().convertToAPInt().getZExtValue(); X = FP->getValueAPF().bitcastToAPInt().getZExtValue();
Size = 8; Size = 8;
} }
Out << "\tldc.r" << Size << "\t( " << utohexstr(X) << ')'; Out << "\tldc.r" << Size << "\t( " << utohexstr(X) << ')';
@ -1477,10 +1477,10 @@ void MSILWriter::printStaticConstant(const Constant* C, uint64_t& Offset) {
const ConstantFP* FP = cast<ConstantFP>(C); const ConstantFP* FP = cast<ConstantFP>(C);
if (Ty->getTypeID() == Type::FloatTyID) if (Ty->getTypeID() == Type::FloatTyID)
Out << "int32 (" << Out << "int32 (" <<
(uint32_t)FP->getValueAPF().convertToAPInt().getZExtValue() << ')'; (uint32_t)FP->getValueAPF().bitcastToAPInt().getZExtValue() << ')';
else else
Out << "int64 (" << Out << "int64 (" <<
FP->getValueAPF().convertToAPInt().getZExtValue() << ')'; FP->getValueAPF().bitcastToAPInt().getZExtValue() << ')';
break; break;
} }
case Type::ArrayTyID: case Type::ArrayTyID:

2
lib/VMCore/AsmWriter.cpp
View File

@ -738,7 +738,7 @@ static void WriteConstantInt(raw_ostream &Out, const Constant *CV,
else else
assert(0 && "Unsupported floating point type"); assert(0 && "Unsupported floating point type");
// api needed to prevent premature destruction // api needed to prevent premature destruction
APInt api = CFP->getValueAPF().convertToAPInt(); APInt api = CFP->getValueAPF().bitcastToAPInt();
const uint64_t* p = api.getRawData(); const uint64_t* p = api.getRawData();
uint64_t word = *p; uint64_t word = *p;
int shiftcount=60; int shiftcount=60;

4
lib/VMCore/ConstantFold.cpp
View File

@ -160,10 +160,10 @@ static Constant *FoldBitCast(Constant *V, const Type *DestTy) {
if (const ConstantFP *FP = dyn_cast<ConstantFP>(V)) { if (const ConstantFP *FP = dyn_cast<ConstantFP>(V)) {
// FP -> Integral. // FP -> Integral.
if (DestTy == Type::Int32Ty) { if (DestTy == Type::Int32Ty) {
return ConstantInt::get(FP->getValueAPF().convertToAPInt()); return ConstantInt::get(FP->getValueAPF().bitcastToAPInt());
} else { } else {
assert(DestTy == Type::Int64Ty && "only support f32/f64 for now!"); assert(DestTy == Type::Int64Ty && "only support f32/f64 for now!");
return ConstantInt::get(FP->getValueAPF().convertToAPInt()); return ConstantInt::get(FP->getValueAPF().bitcastToAPInt());
} }
} }
return 0; return 0;