Skip to content

Commit 2ccfe25

Browse files
tbaederrtbaederr
committed
apfloat
1 parent a17b132 commit 2ccfe25

File tree

3 files changed

+141
-87
lines changed

3 files changed

+141
-87
lines changed

‎clang/include/clang/AST/APNumericStorage.h‎

Lines changed: 5 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -24,6 +24,7 @@ class ASTContext;
2424
/// the APFloat/APInt values will never get freed. APNumericStorage uses
2525
/// ASTContext's allocator for memory allocation.
2626
class APNumericStorage {
27+
protected:
2728
union {
2829
uint64_t VAL; ///< Used to store the <= 64 bits integer value.
2930
uint64_t *pVal; ///< Used to store the >64 bits integer value.
@@ -59,7 +60,10 @@ class APIntStorage : private APNumericStorage {
5960
class APFloatStorage : private APNumericStorage {
6061
public:
6162
llvm::APFloat getValue(const llvm::fltSemantics &Semantics) const {
62-
return llvm::APFloat(Semantics, getIntValue());
63+
unsigned NumWords = llvm::APInt::getNumWords(BitWidth);
64+
if (NumWords > 1)
65+
return llvm::APFloat(Semantics, pVal, BitWidth);
66+
return llvm::APFloat(Semantics, &VAL, BitWidth);
6367
}
6468
void setValue(const ASTContext &C, const llvm::APFloat &Val) {
6569
setIntValue(C, Val.bitcastToAPInt());

‎llvm/include/llvm/ADT/APFloat.h‎

Lines changed: 36 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -460,6 +460,8 @@ class IEEEFloat final {
460460
LLVM_ABI IEEEFloat(const fltSemantics &, integerPart);
461461
LLVM_ABI IEEEFloat(const fltSemantics &, uninitializedTag);
462462
LLVM_ABI IEEEFloat(const fltSemantics &, const APInt &);
463+
LLVM_ABI IEEEFloat(const fltSemantics &, const uint64_t *Memory,
464+
unsigned BitWidth);
463465
LLVM_ABI explicit IEEEFloat(double d);
464466
LLVM_ABI explicit IEEEFloat(float f);
465467
LLVM_ABI IEEEFloat(const IEEEFloat &);
@@ -772,27 +774,36 @@ class IEEEFloat final {
772774
APInt convertFloat6E3M2FNAPFloatToAPInt() const;
773775
APInt convertFloat6E2M3FNAPFloatToAPInt() const;
774776
APInt convertFloat4E2M1FNAPFloatToAPInt() const;
775-
void initFromAPInt(const fltSemantics *Sem, const APInt &api);
777+
void initFromMemory(const fltSemantics *Sem, const uint64_t *Memory,
778+
unsigned BitWidth);
779+
void initFromAPInt(const fltSemantics *Sem, const APInt &api) {
780+
initFromMemory(Sem, api.getRawData(), api.getBitWidth());
781+
}
782+
776783
template <const fltSemantics &S> void initFromIEEEAPInt(const APInt &api);
777-
void initFromHalfAPInt(const APInt &api);
778-
void initFromBFloatAPInt(const APInt &api);
779-
void initFromFloatAPInt(const APInt &api);
780-
void initFromDoubleAPInt(const APInt &api);
781-
void initFromQuadrupleAPInt(const APInt &api);
782-
void initFromF80LongDoubleAPInt(const APInt &api);
783-
void initFromPPCDoubleDoubleLegacyAPInt(const APInt &api);
784-
void initFromFloat8E5M2APInt(const APInt &api);
785-
void initFromFloat8E5M2FNUZAPInt(const APInt &api);
786-
void initFromFloat8E4M3APInt(const APInt &api);
787-
void initFromFloat8E4M3FNAPInt(const APInt &api);
788-
void initFromFloat8E4M3FNUZAPInt(const APInt &api);
789-
void initFromFloat8E4M3B11FNUZAPInt(const APInt &api);
790-
void initFromFloat8E3M4APInt(const APInt &api);
791-
void initFromFloatTF32APInt(const APInt &api);
792-
void initFromFloat8E8M0FNUAPInt(const APInt &api);
793-
void initFromFloat6E3M2FNAPInt(const APInt &api);
794-
void initFromFloat6E2M3FNAPInt(const APInt &api);
795-
void initFromFloat4E2M1FNAPInt(const APInt &api);
784+
template <const fltSemantics &S>
785+
void initFromIEEEMemory(const uint64_t *Memory, unsigned BitWidth);
786+
void initFromHalfMemory(const uint64_t *Memory, unsigned BitWidth);
787+
void initFromBFloatMemory(const uint64_t *Memory, unsigned BitWidth);
788+
void initFromFloatMemory(const uint64_t *Memory, unsigned BitWidth);
789+
void initFromDoubleMemory(const uint64_t *Memory, unsigned BitWidth);
790+
void initFromQuadrupleMemory(const uint64_t *Memory, unsigned BitWidth);
791+
void initFromF80LongDoubleMemory(const uint64_t *Memory, unsigned BitWidth);
792+
void initFromPPCDoubleDoubleLegacyMemory(const uint64_t *Memory,
793+
unsigned BitWidth);
794+
void initFromFloat8E5M2Memory(const uint64_t *Memory, unsigned BitWidth);
795+
void initFromFloat8E5M2FNUZMemory(const uint64_t *Memory, unsigned BitWidth);
796+
void initFromFloat8E4M3Memory(const uint64_t *Memory, unsigned BitWidth);
797+
void initFromFloat8E4M3FNMemory(const uint64_t *Memory, unsigned BitWidth);
798+
void initFromFloat8E4M3FNUZMemory(const uint64_t *Memory, unsigned BitWidth);
799+
void initFromFloat8E4M3B11FNUZMemory(const uint64_t *Memory,
800+
unsigned BitWidth);
801+
void initFromFloat8E3M4Memory(const uint64_t *Memory, unsigned BitWidth);
802+
void initFromFloatTF32Memory(const uint64_t *Memory, unsigned BitWidth);
803+
void initFromFloat8E8M0FNUMemory(const uint64_t *Memory, unsigned BitWidth);
804+
void initFromFloat6E3M2FNMemory(const uint64_t *Memory, unsigned BitWidth);
805+
void initFromFloat6E2M3FNMemory(const uint64_t *Memory, unsigned BitWidth);
806+
void initFromFloat4E2M1FNMemory(const uint64_t *Memory, unsigned BitWidth);
796807

797808
void assign(const IEEEFloat &);
798809
void copySignificand(const IEEEFloat &);
@@ -863,6 +874,8 @@ class DoubleAPFloat final {
863874
LLVM_ABI DoubleAPFloat(const fltSemantics &S, uninitializedTag);
864875
LLVM_ABI DoubleAPFloat(const fltSemantics &S, integerPart);
865876
LLVM_ABI DoubleAPFloat(const fltSemantics &S, const APInt &I);
877+
LLVM_ABI DoubleAPFloat(const fltSemantics &S, const uint64_t *Memory,
878+
unsigned BitWidth);
866879
LLVM_ABI DoubleAPFloat(const fltSemantics &S, APFloat &&First,
867880
APFloat &&Second);
868881
LLVM_ABI DoubleAPFloat(const DoubleAPFloat &RHS);
@@ -1119,6 +1132,9 @@ class APFloat : public APFloatBase {
11191132
APFloat(const fltSemantics &Semantics, uninitializedTag)
11201133
: U(Semantics, uninitialized) {}
11211134
APFloat(const fltSemantics &Semantics, const APInt &I) : U(Semantics, I) {}
1135+
APFloat(const fltSemantics &Semantics, const uint64_t *Memory,
1136+
unsigned BitWidth)
1137+
: U(Semantics, Memory, BitWidth) {}
11221138
explicit APFloat(double d) : U(IEEEFloat(d), IEEEdouble()) {}
11231139
explicit APFloat(float f) : U(IEEEFloat(f), IEEEsingle()) {}
11241140
APFloat(const APFloat &RHS) = default;

‎llvm/lib/Support/APFloat.cpp‎

Lines changed: 100 additions & 66 deletions
Original file line numberDiff line numberDiff line change
@@ -3747,9 +3747,10 @@ float128 IEEEFloat::convertToQuad() const {
37473747
/// exponent!=0 nor all 1's, integer bit 0 ("unnormal")
37483748
/// exponent = 0, integer bit 1 ("pseudodenormal")
37493749
/// At the moment, the first three are treated as NaNs, the last one as Normal.
3750-
void IEEEFloat::initFromF80LongDoubleAPInt(const APInt &api) {
3751-
uint64_t i1 = api.getRawData()[0];
3752-
uint64_t i2 = api.getRawData()[1];
3750+
void IEEEFloat::initFromF80LongDoubleMemory(const uint64_t *Memory,
3751+
unsigned BitWidth) {
3752+
uint64_t i1 = Memory[0];
3753+
uint64_t i2 = Memory[1];
37533754
uint64_t myexponent = (i2 & 0x7fff);
37543755
uint64_t mysignificand = i1;
37553756
uint8_t myintegerbit = mysignificand >> 63;
@@ -3778,14 +3779,15 @@ void IEEEFloat::initFromF80LongDoubleAPInt(const APInt &api) {
37783779
}
37793780
}
37803781

3781-
void IEEEFloat::initFromPPCDoubleDoubleLegacyAPInt(const APInt &api) {
3782-
uint64_t i1 = api.getRawData()[0];
3783-
uint64_t i2 = api.getRawData()[1];
3782+
void IEEEFloat::initFromPPCDoubleDoubleLegacyMemory(const uint64_t *Memory,
3783+
unsigned BitWidth) {
3784+
uint64_t i1 = Memory[0];
3785+
uint64_t i2 = Memory[1];
37843786
opStatus fs;
37853787
bool losesInfo;
37863788

37873789
// Get the first double and convert to our format.
3788-
initFromDoubleAPInt(APInt(64, i1));
3790+
initFromDoubleMemory(&i1, 64);
37893791
fs = convert(APFloatBase::semPPCDoubleDoubleLegacy, rmNearestTiesToEven,
37903792
&losesInfo);
37913793
assert(fs == opOK && !losesInfo);
@@ -3808,9 +3810,10 @@ void IEEEFloat::initFromPPCDoubleDoubleLegacyAPInt(const APInt &api) {
38083810
// No encodings for {zero, infinities or denorms}.
38093811
// NaN is represented by all 1's.
38103812
// Bias is 127.
3811-
void IEEEFloat::initFromFloat8E8M0FNUAPInt(const APInt &api) {
3813+
void IEEEFloat::initFromFloat8E8M0FNUMemory(const uint64_t *Memory,
3814+
unsigned BitWidth) {
38123815
const uint64_t exponent_mask = 0xff;
3813-
uint64_t val = api.getRawData()[0];
3816+
uint64_t val = Memory[0];
38143817
uint64_t myexponent = (val & exponent_mask);
38153818

38163819
initialize(&APFloatBase::semFloat8E8M0FNU);
@@ -3836,9 +3839,11 @@ void IEEEFloat::initFromFloat8E8M0FNUAPInt(const APInt &api) {
38363839
category = fcNormal;
38373840
exponent = myexponent - 127; // 127 is bias
38383841
}
3842+
38393843
template <const fltSemantics &S>
3840-
void IEEEFloat::initFromIEEEAPInt(const APInt &api) {
3841-
assert(api.getBitWidth() == S.sizeInBits);
3844+
void IEEEFloat::initFromIEEEMemory(const uint64_t *Memory, unsigned BitWidth) {
3845+
assert(BitWidth == S.sizeInBits);
3846+
unsigned NumWords = llvm::APInt::getNumWords(BitWidth);
38423847
constexpr integerPart integer_bit = integerPart{1}
38433848
<< ((S.precision - 1) % integerPartWidth);
38443849
constexpr uint64_t significand_mask = integer_bit - 1;
@@ -3854,14 +3859,14 @@ void IEEEFloat::initFromIEEEAPInt(const APInt &api) {
38543859
// Copy the bits of the significand. We need to clear out the exponent and
38553860
// sign bit in the last word.
38563861
std::array<integerPart, stored_significand_parts> mysignificand;
3857-
std::copy_n(api.getRawData(), mysignificand.size(), mysignificand.begin());
3862+
std::copy_n(Memory, mysignificand.size(), mysignificand.begin());
38583863
if constexpr (significand_mask != 0) {
38593864
mysignificand[mysignificand.size() - 1] &= significand_mask;
38603865
}
38613866

38623867
// We assume the last word holds the sign bit, the exponent, and potentially
38633868
// some of the trailing significand field.
3864-
uint64_t last_word = api.getRawData()[api.getNumWords() - 1];
3869+
uint64_t last_word = Memory[NumWords - 1];
38653870
uint64_t myexponent =
38663871
(last_word >> (trailing_significand_bits % 64)) & exponent_mask;
38673872

@@ -3918,111 +3923,126 @@ void IEEEFloat::initFromIEEEAPInt(const APInt &api) {
39183923
significandParts()[mysignificand.size()-1] |= integer_bit; // integer bit
39193924
}
39203925

3921-
void IEEEFloat::initFromQuadrupleAPInt(const APInt &api) {
3922-
initFromIEEEAPInt<APFloatBase::semIEEEquad>(api);
3926+
void IEEEFloat::initFromQuadrupleMemory(const uint64_t *Memory,
3927+
unsigned BitWidth) {
3928+
initFromIEEEMemory<APFloatBase::semIEEEquad>(Memory, BitWidth);
39233929
}
39243930

3925-
void IEEEFloat::initFromDoubleAPInt(const APInt &api) {
3926-
initFromIEEEAPInt<APFloatBase::semIEEEdouble>(api);
3931+
void IEEEFloat::initFromDoubleMemory(const uint64_t *Memory,
3932+
unsigned BitWidth) {
3933+
initFromIEEEMemory<APFloatBase::semIEEEdouble>(Memory, BitWidth);
39273934
}
39283935

3929-
void IEEEFloat::initFromFloatAPInt(const APInt &api) {
3930-
initFromIEEEAPInt<APFloatBase::semIEEEsingle>(api);
3936+
void IEEEFloat::initFromFloatMemory(const uint64_t *Memory, unsigned BitWidth) {
3937+
initFromIEEEMemory<APFloatBase::semIEEEsingle>(Memory, BitWidth);
39313938
}
39323939

3933-
void IEEEFloat::initFromBFloatAPInt(const APInt &api) {
3934-
initFromIEEEAPInt<APFloatBase::semBFloat>(api);
3940+
void IEEEFloat::initFromBFloatMemory(const uint64_t *Memory,
3941+
unsigned BitWidth) {
3942+
initFromIEEEMemory<APFloatBase::semBFloat>(Memory, BitWidth);
39353943
}
39363944

3937-
void IEEEFloat::initFromHalfAPInt(const APInt &api) {
3938-
initFromIEEEAPInt<APFloatBase::semIEEEhalf>(api);
3945+
void IEEEFloat::initFromHalfMemory(const uint64_t *Memory, unsigned BitWidth) {
3946+
initFromIEEEMemory<APFloatBase::semIEEEhalf>(Memory, BitWidth);
39393947
}
39403948

3941-
void IEEEFloat::initFromFloat8E5M2APInt(const APInt &api) {
3942-
initFromIEEEAPInt<APFloatBase::semFloat8E5M2>(api);
3949+
void IEEEFloat::initFromFloat8E5M2Memory(const uint64_t *Memory,
3950+
unsigned BitWidth) {
3951+
initFromIEEEMemory<APFloatBase::semFloat8E5M2>(Memory, BitWidth);
39433952
}
39443953

3945-
void IEEEFloat::initFromFloat8E5M2FNUZAPInt(const APInt &api) {
3946-
initFromIEEEAPInt<APFloatBase::semFloat8E5M2FNUZ>(api);
3954+
void IEEEFloat::initFromFloat8E5M2FNUZMemory(const uint64_t *Memory,
3955+
unsigned BitWidth) {
3956+
initFromIEEEMemory<APFloatBase::semFloat8E5M2FNUZ>(Memory, BitWidth);
39473957
}
39483958

3949-
void IEEEFloat::initFromFloat8E4M3APInt(const APInt &api) {
3950-
initFromIEEEAPInt<APFloatBase::semFloat8E4M3>(api);
3959+
void IEEEFloat::initFromFloat8E4M3Memory(const uint64_t *Memory,
3960+
unsigned BitWidth) {
3961+
initFromIEEEMemory<APFloatBase::semFloat8E4M3>(Memory, BitWidth);
39513962
}
39523963

3953-
void IEEEFloat::initFromFloat8E4M3FNAPInt(const APInt &api) {
3954-
initFromIEEEAPInt<APFloatBase::semFloat8E4M3FN>(api);
3964+
void IEEEFloat::initFromFloat8E4M3FNMemory(const uint64_t *Memory,
3965+
unsigned BitWidth) {
3966+
initFromIEEEMemory<APFloatBase::semFloat8E4M3FN>(Memory, BitWidth);
39553967
}
39563968

3957-
void IEEEFloat::initFromFloat8E4M3FNUZAPInt(const APInt &api) {
3958-
initFromIEEEAPInt<APFloatBase::semFloat8E4M3FNUZ>(api);
3969+
void IEEEFloat::initFromFloat8E4M3FNUZMemory(const uint64_t *Memory,
3970+
unsigned BitWidth) {
3971+
initFromIEEEMemory<APFloatBase::semFloat8E4M3FNUZ>(Memory, BitWidth);
39593972
}
39603973

3961-
void IEEEFloat::initFromFloat8E4M3B11FNUZAPInt(const APInt &api) {
3962-
initFromIEEEAPInt<APFloatBase::semFloat8E4M3B11FNUZ>(api);
3974+
void IEEEFloat::initFromFloat8E4M3B11FNUZMemory(const uint64_t *Memory,
3975+
unsigned BitWidth) {
3976+
initFromIEEEMemory<APFloatBase::semFloat8E4M3B11FNUZ>(Memory, BitWidth);
39633977
}
39643978

3965-
void IEEEFloat::initFromFloat8E3M4APInt(const APInt &api) {
3966-
initFromIEEEAPInt<APFloatBase::semFloat8E3M4>(api);
3979+
void IEEEFloat::initFromFloat8E3M4Memory(const uint64_t *Memory,
3980+
unsigned BitWidth) {
3981+
initFromIEEEMemory<APFloatBase::semFloat8E3M4>(Memory, BitWidth);
39673982
}
39683983

3969-
void IEEEFloat::initFromFloatTF32APInt(const APInt &api) {
3970-
initFromIEEEAPInt<APFloatBase::semFloatTF32>(api);
3984+
void IEEEFloat::initFromFloatTF32Memory(const uint64_t *Memory,
3985+
unsigned BitWidth) {
3986+
initFromIEEEMemory<APFloatBase::semFloatTF32>(Memory, BitWidth);
39713987
}
39723988

3973-
void IEEEFloat::initFromFloat6E3M2FNAPInt(const APInt &api) {
3974-
initFromIEEEAPInt<APFloatBase::semFloat6E3M2FN>(api);
3989+
void IEEEFloat::initFromFloat6E3M2FNMemory(const uint64_t *Memory,
3990+
unsigned BitWidth) {
3991+
initFromIEEEMemory<APFloatBase::semFloat6E3M2FN>(Memory, BitWidth);
39753992
}
39763993

3977-
void IEEEFloat::initFromFloat6E2M3FNAPInt(const APInt &api) {
3978-
initFromIEEEAPInt<APFloatBase::semFloat6E2M3FN>(api);
3994+
void IEEEFloat::initFromFloat6E2M3FNMemory(const uint64_t *Memory,
3995+
unsigned BitWidth) {
3996+
initFromIEEEMemory<APFloatBase::semFloat6E2M3FN>(Memory, BitWidth);
39793997
}
39803998

3981-
void IEEEFloat::initFromFloat4E2M1FNAPInt(const APInt &api) {
3982-
initFromIEEEAPInt<APFloatBase::semFloat4E2M1FN>(api);
3999+
void IEEEFloat::initFromFloat4E2M1FNMemory(const uint64_t *Memory,
4000+
unsigned BitWidth) {
4001+
initFromIEEEMemory<APFloatBase::semFloat4E2M1FN>(Memory, BitWidth);
39834002
}
39844003

39854004
/// Treat api as containing the bits of a floating point number.
3986-
void IEEEFloat::initFromAPInt(const fltSemantics *Sem, const APInt &api) {
3987-
assert(api.getBitWidth() == Sem->sizeInBits);
4005+
void IEEEFloat::initFromMemory(const fltSemantics *Sem, const uint64_t *Memory,
4006+
unsigned BitWidth) {
4007+
assert(BitWidth == Sem->sizeInBits);
39884008
if (Sem == &APFloatBase::semIEEEhalf)
3989-
return initFromHalfAPInt(api);
4009+
return initFromHalfMemory(Memory, BitWidth);
39904010
if (Sem == &APFloatBase::semBFloat)
3991-
return initFromBFloatAPInt(api);
4011+
return initFromBFloatMemory(Memory, BitWidth);
39924012
if (Sem == &APFloatBase::semIEEEsingle)
3993-
return initFromFloatAPInt(api);
4013+
return initFromFloatMemory(Memory, BitWidth);
39944014
if (Sem == &APFloatBase::semIEEEdouble)
3995-
return initFromDoubleAPInt(api);
4015+
return initFromDoubleMemory(Memory, BitWidth);
39964016
if (Sem == &APFloatBase::semX87DoubleExtended)
3997-
return initFromF80LongDoubleAPInt(api);
4017+
return initFromF80LongDoubleMemory(Memory, BitWidth);
39984018
if (Sem == &APFloatBase::semIEEEquad)
3999-
return initFromQuadrupleAPInt(api);
4019+
return initFromQuadrupleMemory(Memory, BitWidth);
40004020
if (Sem == &APFloatBase::semPPCDoubleDoubleLegacy)
4001-
return initFromPPCDoubleDoubleLegacyAPInt(api);
4021+
return initFromPPCDoubleDoubleLegacyMemory(Memory, BitWidth);
40024022
if (Sem == &APFloatBase::semFloat8E5M2)
4003-
return initFromFloat8E5M2APInt(api);
4023+
return initFromFloat8E5M2Memory(Memory, BitWidth);
40044024
if (Sem == &APFloatBase::semFloat8E5M2FNUZ)
4005-
return initFromFloat8E5M2FNUZAPInt(api);
4025+
return initFromFloat8E5M2FNUZMemory(Memory, BitWidth);
40064026
if (Sem == &APFloatBase::semFloat8E4M3)
4007-
return initFromFloat8E4M3APInt(api);
4027+
return initFromFloat8E4M3Memory(Memory, BitWidth);
40084028
if (Sem == &APFloatBase::semFloat8E4M3FN)
4009-
return initFromFloat8E4M3FNAPInt(api);
4029+
return initFromFloat8E4M3FNMemory(Memory, BitWidth);
40104030
if (Sem == &APFloatBase::semFloat8E4M3FNUZ)
4011-
return initFromFloat8E4M3FNUZAPInt(api);
4031+
return initFromFloat8E4M3FNUZMemory(Memory, BitWidth);
40124032
if (Sem == &APFloatBase::semFloat8E4M3B11FNUZ)
4013-
return initFromFloat8E4M3B11FNUZAPInt(api);
4033+
return initFromFloat8E4M3B11FNUZMemory(Memory, BitWidth);
40144034
if (Sem == &APFloatBase::semFloat8E3M4)
4015-
return initFromFloat8E3M4APInt(api);
4035+
return initFromFloat8E3M4Memory(Memory, BitWidth);
40164036
if (Sem == &APFloatBase::semFloatTF32)
4017-
return initFromFloatTF32APInt(api);
4037+
return initFromFloatTF32Memory(Memory, BitWidth);
40184038
if (Sem == &APFloatBase::semFloat8E8M0FNU)
4019-
return initFromFloat8E8M0FNUAPInt(api);
4039+
return initFromFloat8E8M0FNUMemory(Memory, BitWidth);
40204040
if (Sem == &APFloatBase::semFloat6E3M2FN)
4021-
return initFromFloat6E3M2FNAPInt(api);
4041+
return initFromFloat6E3M2FNMemory(Memory, BitWidth);
40224042
if (Sem == &APFloatBase::semFloat6E2M3FN)
4023-
return initFromFloat6E2M3FNAPInt(api);
4043+
return initFromFloat6E2M3FNMemory(Memory, BitWidth);
40244044
if (Sem == &APFloatBase::semFloat4E2M1FN)
4025-
return initFromFloat4E2M1FNAPInt(api);
4045+
return initFromFloat4E2M1FNMemory(Memory, BitWidth);
40264046

40274047
llvm_unreachable("unsupported semantics");
40284048
}
@@ -4095,6 +4115,11 @@ IEEEFloat::IEEEFloat(const fltSemantics &Sem, const APInt &API) {
40954115
initFromAPInt(&Sem, API);
40964116
}
40974117

4118+
IEEEFloat::IEEEFloat(const fltSemantics &Sem, const uint64_t *Memory,
4119+
unsigned BitWidth) {
4120+
initFromMemory(&Sem, Memory, BitWidth);
4121+
}
4122+
40984123
IEEEFloat::IEEEFloat(float f) {
40994124
initFromAPInt(&APFloatBase::semIEEEsingle, APInt::floatToBits(f));
41004125
}
@@ -4736,6 +4761,15 @@ DoubleAPFloat::DoubleAPFloat(const fltSemantics &S, const APInt &I)
47364761
assert(Semantics == &APFloatBase::semPPCDoubleDouble);
47374762
}
47384763

4764+
DoubleAPFloat::DoubleAPFloat(const fltSemantics &S, const uint64_t *Memory,
4765+
unsigned BitWidth)
4766+
: Semantics(&S),
4767+
Floats(new APFloat[2]{
4768+
APFloat(APFloatBase::semIEEEdouble, APInt(64, Memory[0])),
4769+
APFloat(APFloatBase::semIEEEdouble, APInt(64, Memory[1]))}) {
4770+
assert(Semantics == &APFloatBase::semPPCDoubleDouble);
4771+
}
4772+
47394773
DoubleAPFloat::DoubleAPFloat(const fltSemantics &S, APFloat &&First,
47404774
APFloat &&Second)
47414775
: Semantics(&S),

0 commit comments

Comments
 (0)