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

Add support for floating-point calculations of log2 with limited precisions of 6

Browse Source 
and 18.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@55968 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Bill Wendling
2008-09-09 00:28:24 +00:00
parent 2379089a6e
commit 3eb594013f
1 changed files with 191 additions and 76 deletions
Download Patch File Download Diff File Expand all files Collapse all files

213
lib/CodeGen/SelectionDAG/SelectionDAGBuild.cpp
View File

@@ -2755,7 +2755,6 @@ SelectionDAGLowering::implVisitBinaryAtomic(CallInst& I, ISD::NodeType Op) {
/// visitExp - lower an exp intrinsic. Handles the special sequences /// visitExp - lower an exp intrinsic. Handles the special sequences
/// for limited-precision mode. /// for limited-precision mode.
void void
SelectionDAGLowering::visitExp(CallInst &I) { SelectionDAGLowering::visitExp(CallInst &I) {
SDValue result; SDValue result;
@@ -2768,7 +2767,6 @@ SelectionDAGLowering::visitExp(CallInst &I) {
/// visitLog - lower a log intrinsic. Handles the special sequences /// visitLog - lower a log intrinsic. Handles the special sequences
/// for limited-precision mode. /// for limited-precision mode.
void void
SelectionDAGLowering::visitLog(CallInst &I) { SelectionDAGLowering::visitLog(CallInst &I) {
SDValue result; SDValue result;
@@ -2779,108 +2777,225 @@ SelectionDAGLowering::visitLog(CallInst &I) {
setValue(&I, result); setValue(&I, result);
} }
/// visitLog2 - lower a log2 intrinsic. Handles the special sequences /// visitLog2 - Lower a log2 intrinsic. Handles the special sequences for
/// for limited-precision mode. /// limited-precision mode.
void void
SelectionDAGLowering::visitLog2(CallInst &I) { SelectionDAGLowering::visitLog2(CallInst &I) {
SDValue result; SDValue result;
if (getValue(I.getOperand(1)).getValueType() == MVT::f32 && if (getValue(I.getOperand(1)).getValueType() == MVT::f32 &&
LimitFloatPrecision>0 && LimitFloatPrecision<=12) { LimitFloatPrecision > 0 && LimitFloatPrecision <= 18) {
SDValue operand = getValue(I.getOperand(1)); SDValue Op = getValue(I.getOperand(1));
SDValue operand1 = DAG.getNode(ISD::BIT_CONVERT, MVT::i32, operand); SDValue Op1 = DAG.getNode(ISD::BIT_CONVERT, MVT::i32, Op);
SDValue t0 = DAG.getNode(ISD::SRL, MVT::i32, operand1,
// Get the exponent, which is most of log and scale by log(2):
//
// LogOfExponent = (float) (((Op1 & 0x7f800000) >> 23) - 127);
//
// where Op1 is the hexidecimal representation of floating point value.
SDValue t0 = DAG.getNode(ISD::AND, MVT::i32, Op1,
DAG.getConstant(0x7f800000, MVT::i32));
SDValue t1 = DAG.getNode(ISD::SRL, MVT::i32, t0,
DAG.getConstant(23, MVT::i32)); DAG.getConstant(23, MVT::i32));
SDValue t1 = DAG.getNode(ISD::AND, MVT::i32, t0,
DAG.getConstant(255, MVT::i32));
SDValue t2 = DAG.getNode(ISD::SUB, MVT::i32, t1, SDValue t2 = DAG.getNode(ISD::SUB, MVT::i32, t1,
DAG.getConstant(127, MVT::i32)); DAG.getConstant(127, MVT::i32));
SDValue t3 = DAG.getNode(ISD::UINT_TO_FP, MVT::f32, t2); SDValue LogOfExponent = DAG.getNode(ISD::UINT_TO_FP, MVT::f32, t2);
SDValue t4 = DAG.getNode(ISD::OR, MVT::i32, operand1,
DAG.getConstant(1065353216, MVT::i32)); // Get the significand and build it into a floating-point number with
SDValue t5 = DAG.getNode(ISD::AND, MVT::i32, t4, // exponent of 1:
DAG.getConstant(1073741823, MVT::i32)); //
SDValue t6 = DAG.getNode(ISD::BIT_CONVERT, MVT::f32, t5); // Op1 = (Op1 & 0x007fffff) | 0x3f800000;
SDValue t7 = DAG.getNode(ISD::FMUL, MVT::f32, t6, //
// where Op1 is the hexidecimal representation of floating point value.
SDValue t4 = DAG.getNode(ISD::AND, MVT::i32, Op1,
DAG.getConstant(0x007fffff, MVT::i32));
SDValue t5 = DAG.getNode(ISD::OR, MVT::i32, t4,
DAG.getConstant(0x3f800000, MVT::i32));
SDValue X = DAG.getNode(ISD::BIT_CONVERT, MVT::f32, t5);
// Different possible minimax approximations of significand in
// floating-point for various degrees of accuracy over [1,2].
if (LimitFloatPrecision <= 6) {
// For floating-point precision of 6:
//
// Log2ofMantissa = -1.6749035f + (2.0246817f - .34484768f * x) * x;
//
// error 0.0049451742, which is more than 7 bits
SDValue t8 = DAG.getNode(ISD::FMUL, MVT::f32, X,
DAG.getConstantFP(APFloat(
APInt(32, 0xbeb08fe0)), MVT::f32));
SDValue t9 = DAG.getNode(ISD::FADD, MVT::f32, t8,
DAG.getConstantFP(APFloat(
APInt(32, 0x40019463)), MVT::f32));
SDValue t10 = DAG.getNode(ISD::FMUL, MVT::f32, t9, X);
SDValue Log2ofMantissa = DAG.getNode(ISD::FSUB, MVT::f32, t10,
DAG.getConstantFP(APFloat(
APInt(32, 0x3fd6633d)), MVT::f32));
result = DAG.getNode(ISD::FADD, MVT::f32, LogOfExponent, Log2ofMantissa);
} else if (LimitFloatPrecision > 6 && LimitFloatPrecision <= 12) {
// For floating-point precision of 12:
//
// Log2ofMantissa =
// -2.51285454f +
// (4.07009056f +
// (-2.12067489f +
// (.645142248f - 0.816157886e-1f * x) * x) * x) * x;
//
// error 0.0000876136000, which is better than 13 bits
SDValue t8 = DAG.getNode(ISD::FMUL, MVT::f32, X,
DAG.getConstantFP(APFloat( DAG.getConstantFP(APFloat(
APInt(32, 0xbda7262e)), MVT::f32)); APInt(32, 0xbda7262e)), MVT::f32));
SDValue t8 = DAG.getNode(ISD::FADD, MVT::f32, t7, SDValue t9 = DAG.getNode(ISD::FADD, MVT::f32, t8,
DAG.getConstantFP(APFloat( DAG.getConstantFP(APFloat(
APInt(32, 0x3f25280b)), MVT::f32)); APInt(32, 0x3f25280b)), MVT::f32));
SDValue t9 = DAG.getNode(ISD::FMUL, MVT::f32, t8, t6); SDValue t10 = DAG.getNode(ISD::FMUL, MVT::f32, t9, X);
SDValue t10 = DAG.getNode(ISD::FSUB, MVT::f32, t9, SDValue t11 = DAG.getNode(ISD::FSUB, MVT::f32, t10,
DAG.getConstantFP(APFloat( DAG.getConstantFP(APFloat(
APInt(32, 0x4007b923)), MVT::f32)); APInt(32, 0x4007b923)), MVT::f32));
SDValue t11 = DAG.getNode(ISD::FMUL, MVT::f32, t10, t6); SDValue t12 = DAG.getNode(ISD::FMUL, MVT::f32, t11, X);
SDValue t12 = DAG.getNode(ISD::FADD, MVT::f32, t11, SDValue t13 = DAG.getNode(ISD::FADD, MVT::f32, t12,
DAG.getConstantFP(APFloat( DAG.getConstantFP(APFloat(
APInt(32, 0x40823e2f)), MVT::f32)); APInt(32, 0x40823e2f)), MVT::f32));
SDValue t13 = DAG.getNode(ISD::FMUL, MVT::f32, t12, t6); SDValue t14 = DAG.getNode(ISD::FMUL, MVT::f32, t13, X);
SDValue t14 = DAG.getNode(ISD::FSUB, MVT::f32, t13, SDValue Log2ofMantissa = DAG.getNode(ISD::FSUB, MVT::f32, t14,
DAG.getConstantFP(APFloat( DAG.getConstantFP(APFloat(
APInt(32, 0x4020d29c)), MVT::f32)); APInt(32, 0x4020d29c)), MVT::f32));
result = DAG.getNode(ISD::FADD, MVT::f32, t3, t14);
result = DAG.getNode(ISD::FADD, MVT::f32, LogOfExponent, Log2ofMantissa);
} else { // LimitFloatPrecision > 12 && LimitFloatPrecision <= 18
// For floating-point precision of 18:
//
// Log2ofMantissa =
// -3.0400495f +
// (6.1129976f +
// (-5.3420409f +
// (3.2865683f +
// (-1.2669343f +
// (0.27515199f -
// 0.25691327e-1f * x) * x) * x) * x) * x) * x;
//
// error 0.0000018516, which is better than 18 bits
SDValue t8 = DAG.getNode(ISD::FMUL, MVT::f32, X,
DAG.getConstantFP(APFloat(
APInt(32, 0xbcd2769e)), MVT::f32));
SDValue t9 = DAG.getNode(ISD::FADD, MVT::f32, t8,
DAG.getConstantFP(APFloat(
APInt(32, 0x3e8ce0b9)), MVT::f32));
SDValue t10 = DAG.getNode(ISD::FMUL, MVT::f32, t9, X);
SDValue t11 = DAG.getNode(ISD::FSUB, MVT::f32, t10,
DAG.getConstantFP(APFloat(
APInt(32, 0x3fa22ae7)), MVT::f32));
SDValue t12 = DAG.getNode(ISD::FMUL, MVT::f32, t11, X);
SDValue t13 = DAG.getNode(ISD::FADD, MVT::f32, t12,
DAG.getConstantFP(APFloat(
APInt(32, 0x40525723)), MVT::f32));
SDValue t14 = DAG.getNode(ISD::FMUL, MVT::f32, t13, X);
SDValue t15 = DAG.getNode(ISD::FSUB, MVT::f32, t14,
DAG.getConstantFP(APFloat(
APInt(32, 0x40aaf200)), MVT::f32));
SDValue t16 = DAG.getNode(ISD::FMUL, MVT::f32, t15, X);
SDValue t17 = DAG.getNode(ISD::FADD, MVT::f32, t16,
DAG.getConstantFP(APFloat(
APInt(32, 0x40c39dad)), MVT::f32));
SDValue t18 = DAG.getNode(ISD::FMUL, MVT::f32, t17, X);
SDValue Log2ofMantissa = DAG.getNode(ISD::FSUB, MVT::f32, t18,
DAG.getConstantFP(APFloat(
APInt(32, 0x4042902c)), MVT::f32));
result = DAG.getNode(ISD::FADD, MVT::f32, LogOfExponent, Log2ofMantissa);
}
} else { } else {
// No special expansion. // No special expansion.
result = DAG.getNode(ISD::FLOG2, result = DAG.getNode(ISD::FLOG2,
getValue(I.getOperand(1)).getValueType(), getValue(I.getOperand(1)).getValueType(),
getValue(I.getOperand(1))); getValue(I.getOperand(1)));
} }
setValue(&I, result); setValue(&I, result);
} }
/// visitLog10 - lower a log10 intrinsic. Handles the special sequences /// visitLog10 - Lower a log10 intrinsic. Handles the special sequences for
/// for limited-precision mode. /// limited-precision mode.
void void
SelectionDAGLowering::visitLog10(CallInst &I) { SelectionDAGLowering::visitLog10(CallInst &I) {
SDValue result; SDValue result;
if (getValue(I.getOperand(1)).getValueType() == MVT::f32 && if (getValue(I.getOperand(1)).getValueType() == MVT::f32 &&
LimitFloatPrecision>0 && LimitFloatPrecision<=12) { LimitFloatPrecision > 0 && LimitFloatPrecision <= 18) {
SDValue operand = getValue(I.getOperand(1)); SDValue Op = getValue(I.getOperand(1));
SDValue operand1 = DAG.getNode(ISD::BIT_CONVERT, MVT::i32, operand); SDValue Op1 = DAG.getNode(ISD::BIT_CONVERT, MVT::i32, Op);
SDValue t0 = DAG.getNode(ISD::SRL, MVT::i32, operand1,
// Get the exponent, which is most of log10 and scale by log10(2).
//
// #define LOG10OF2 0.30102999f
// Log10ofExponent = (float)(((Op1 & 0x7f800000) >> 23) - 127) * LOG10OF2;
//
// where Op1 is the hexidecimal value of the floating-point number.
SDValue t0 = DAG.getNode(ISD::AND, MVT::i32, Op1,
DAG.getConstant(0x7f800000, MVT::i32));
SDValue t1 = DAG.getNode(ISD::SRL, MVT::i32, t0,
DAG.getConstant(23, MVT::i32)); DAG.getConstant(23, MVT::i32));
SDValue t1 = DAG.getNode(ISD::AND, MVT::i32, t0,
DAG.getConstant(255, MVT::i32));
SDValue t2 = DAG.getNode(ISD::SUB, MVT::i32, t1, SDValue t2 = DAG.getNode(ISD::SUB, MVT::i32, t1,
DAG.getConstant(127, MVT::i32)); DAG.getConstant(127, MVT::i32));
SDValue t3 = DAG.getNode(ISD::UINT_TO_FP, MVT::f32, t2); SDValue t3 = DAG.getNode(ISD::UINT_TO_FP, MVT::f32, t2);
SDValue t4 = DAG.getNode(ISD::FMUL, MVT::f32, t3, SDValue LogOfExponent = DAG.getNode(ISD::FMUL, MVT::f32, t3,
DAG.getConstantFP(APFloat( DAG.getConstantFP(APFloat(
APInt(32, 0x3e9a209a)), MVT::f32)); APInt(32, 0x3e9a209a)), MVT::f32));
SDValue t5 = DAG.getNode(ISD::OR, MVT::i32, operand1,
DAG.getConstant(1065353216, MVT::i32)); // Get the significand and build it into a floating-point number with
SDValue t6 = DAG.getNode(ISD::AND, MVT::i32, t5, // exponent of 1:
DAG.getConstant(1073741823, MVT::i32)); //
SDValue t7 = DAG.getNode(ISD::BIT_CONVERT, MVT::f32, t6); // Op1 = (Op1 & 0x007fffff) | 0x3f800000;
SDValue t8 = DAG.getNode(ISD::FMUL, MVT::f32, t7, //
// where Op1 is the hexidecimal representation of floating point value.
SDValue t4 = DAG.getNode(ISD::AND, MVT::i32, Op1,
DAG.getConstant(0x007fffff, MVT::i32));
SDValue t5 = DAG.getNode(ISD::OR, MVT::i32, t4,
DAG.getConstant(0x3f800000, MVT::i32));
SDValue X = DAG.getNode(ISD::BIT_CONVERT, MVT::f32, t5);
if (LimitFloatPrecision <= 6) {
} else if (LimitFloatPrecision > 6 && LimitFloatPrecision <= 12) {
// For floating-point precision of 12:
//
// Log10ofMantissa =
// -0.64831180f +
// (0.91751397f +
// (-0.31664806f + 0.47637168e-1f * x) * x) * x;
//
// error 0.00019228036, which is better than 12 bits
SDValue t6 = DAG.getNode(ISD::FMUL, MVT::f32, X,
DAG.getConstantFP(APFloat( DAG.getConstantFP(APFloat(
APInt(32, 0x3d431f31)), MVT::f32)); APInt(32, 0x3d431f31)), MVT::f32));
SDValue t9 = DAG.getNode(ISD::FSUB, MVT::f32, t8, SDValue t7 = DAG.getNode(ISD::FSUB, MVT::f32, t6,
DAG.getConstantFP(APFloat( DAG.getConstantFP(APFloat(
APInt(32, 0x3ea21fb2)), MVT::f32)); APInt(32, 0x3ea21fb2)), MVT::f32));
SDValue t10 = DAG.getNode(ISD::FMUL, MVT::f32, t9, t7); SDValue t8 = DAG.getNode(ISD::FMUL, MVT::f32, t7, X);
SDValue t11 = DAG.getNode(ISD::FADD, MVT::f32, t10, SDValue t9 = DAG.getNode(ISD::FADD, MVT::f32, t8,
DAG.getConstantFP(APFloat( DAG.getConstantFP(APFloat(
APInt(32, 0x3f6ae232)), MVT::f32)); APInt(32, 0x3f6ae232)), MVT::f32));
SDValue t12 = DAG.getNode(ISD::FMUL, MVT::f32, t11, t7); SDValue t10 = DAG.getNode(ISD::FMUL, MVT::f32, t9, X);
SDValue t13 = DAG.getNode(ISD::FSUB, MVT::f32, t12, SDValue t11 = DAG.getNode(ISD::FSUB, MVT::f32, t10,
DAG.getConstantFP(APFloat( DAG.getConstantFP(APFloat(
APInt(32, 0x3f25f7c3)), MVT::f32)); APInt(32, 0x3f25f7c3)), MVT::f32));
result = DAG.getNode(ISD::FADD, MVT::f32, t4, t13); SDValue Log10ofMantissa = DAG.getNode(ISD::FP_ROUND, MVT::f32, t11,
DAG.getConstant(0, MVT::i32));
result = DAG.getNode(ISD::FADD, MVT::f32, LogOfExponent, Log10ofMantissa);
} else { // LimitFloatPrecision > 12 && LimitFloatPrecision <= 18
}
} else { } else {
// No special expansion. // No special expansion.
result = DAG.getNode(ISD::FLOG10, result = DAG.getNode(ISD::FLOG10,
getValue(I.getOperand(1)).getValueType(), getValue(I.getOperand(1)).getValueType(),
getValue(I.getOperand(1))); getValue(I.getOperand(1)));
} }
setValue(&I, result); setValue(&I, result);
} }
/// visitExp2 - lower an exp2 intrinsic. Handles the special sequences /// visitExp2 - lower an exp2 intrinsic. Handles the special sequences
/// for limited-precision mode. /// for limited-precision mode.
void void
SelectionDAGLowering::visitExp2(CallInst &I) { SelectionDAGLowering::visitExp2(CallInst &I) {
SDValue result; SDValue result;