Ekdohibs
/
zig
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

depend on embedded SoftFloat-3d instead of __float128 

See #302
See #467
master
Andrew Kelley 2017-09-14 01:44:22 -04:00
parent 7ddc259acc
commit 14cda27b64
15 changed files with 435 additions and 187 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

141
CMakeLists.txt
View File

@ -169,12 +169,135 @@ else()
) )
endif() endif()
find_package(Threads) # No patches have been applied to SoftFloat-3d
set(EMBEDDED_SOFTFLOAT_SOURCES
include_directories( "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/8086/f128M_isSignalingNaN.c"
${CMAKE_SOURCE_DIR} "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/8086/s_commonNaNToF128M.c"
${CMAKE_BINARY_DIR} "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/8086/s_commonNaNToF32UI.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/8086/s_commonNaNToF64UI.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/8086/s_f128MToCommonNaN.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/8086/s_f32UIToCommonNaN.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/8086/s_f64UIToCommonNaN.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/8086/s_propagateNaNF128M.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/8086/softfloat_raiseFlags.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/f128M_add.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/f128M_div.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/f128M_eq.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/f128M_eq_signaling.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/f128M_le.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/f128M_le_quiet.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/f128M_lt.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/f128M_lt_quiet.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/f128M_mul.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/f128M_mulAdd.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/f128M_rem.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/f128M_roundToInt.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/f128M_sqrt.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/f128M_sub.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/f128M_to_f16.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/f128M_to_f32.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/f128M_to_f64.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/f128M_to_i32.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/f128M_to_i32_r_minMag.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/f128M_to_i64.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/f128M_to_i64_r_minMag.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/f128M_to_ui32.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/f128M_to_ui32_r_minMag.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/f128M_to_ui64.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/f128M_to_ui64_r_minMag.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/f32_to_f128M.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/f64_to_f128M.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_add256M.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_addCarryM.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_addComplCarryM.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_addF128M.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_addM.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_addMagsF16.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_addMagsF32.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_addMagsF64.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_approxRecip32_1.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_approxRecipSqrt32_1.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_approxRecipSqrt_1Ks.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_approxRecip_1Ks.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_compare128M.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_compare96M.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_countLeadingZeros16.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_countLeadingZeros32.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_countLeadingZeros64.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_countLeadingZeros8.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_eq128.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_invalidF128M.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_isNaNF128M.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_le128.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_lt128.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_mul128MTo256M.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_mul64To128M.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_mulAddF128M.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_mulAddF16.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_mulAddF32.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_mulAddF64.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_negXM.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_normRoundPackMToF128M.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_normRoundPackToF16.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_normRoundPackToF32.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_normRoundPackToF64.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_normSubnormalF128SigM.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_normSubnormalF16Sig.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_normSubnormalF32Sig.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_normSubnormalF64Sig.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_remStepMBy32.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_roundMToI64.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_roundMToUI64.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_roundPackMToF128M.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_roundPackToF16.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_roundPackToF32.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_roundPackToF64.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_roundToI32.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_roundToI64.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_roundToUI32.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_roundToUI64.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_shiftLeftM.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_shiftNormSigF128M.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_shiftRightJam256M.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_shiftRightJam32.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_shiftRightJam64.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_shiftRightJamM.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_shiftRightM.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_shortShiftLeft64To96M.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_shortShiftLeftM.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_shortShiftRightExtendM.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_shortShiftRightJam64.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_shortShiftRightJamM.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_shortShiftRightM.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_sub1XM.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_sub256M.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_subM.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_subMagsF16.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_subMagsF32.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_subMagsF64.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/s_tryPropagateNaNF128M.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/softfloat_state.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/ui32_to_f128M.c"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/ui64_to_f128M.c"
) )
add_library(embedded_softfloat ${EMBEDDED_SOFTFLOAT_SOURCES})
if(MSVC)
set_target_properties(embedded_softfloat PROPERTIES
COMPILE_FLAGS "-std=c99"
)
else()
set_target_properties(embedded_softfloat PROPERTIES
COMPILE_FLAGS "-std=c99"
)
endif()
target_include_directories(embedded_softfloat PUBLIC
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d-prebuilt"
"${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/8086"
)
include_directories("${CMAKE_SOURCE_DIR}/deps/SoftFloat-3d/source/include")
set(SOFTFLOAT_LIBRARIES embedded_softfloat)
find_package(Threads)
set(ZIG_SOURCES set(ZIG_SOURCES
"${CMAKE_SOURCE_DIR}/src/analyze.cpp" "${CMAKE_SOURCE_DIR}/src/analyze.cpp"
@ -241,18 +364,14 @@ set_target_properties(zig PROPERTIES
) )
target_link_libraries(zig LINK_PUBLIC target_link_libraries(zig LINK_PUBLIC
${SOFTFLOAT_LIBRARIES}
${CLANG_LIBRARIES} ${CLANG_LIBRARIES}
${LLD_LIBRARIES} ${LLD_LIBRARIES}
${LLVM_LIBRARIES} ${LLVM_LIBRARIES}
${CMAKE_THREAD_LIBS_INIT} ${CMAKE_THREAD_LIBS_INIT}
${PLATFORM_LIBRARIES}
) )
if(MSVC) if(MSVC OR MINGW)
target_link_libraries(zig LINK_PUBLIC version) target_link_libraries(zig LINK_PUBLIC version)
elseif(MINGW)
target_link_libraries(zig LINK_PUBLIC version quadmath)
else()
target_link_libraries(zig LINK_PUBLIC quadmath)
endif() endif()
install(TARGETS zig DESTINATION bin) install(TARGETS zig DESTINATION bin)

16
ci/travis_osx_install
View File

@ -2,18 +2,6 @@
set -x set -x
brew install gcc@7 brew install llvm@5
brew outdated gcc@7 || brew upgrade gcc@7 brew outdated llvm@5 || brew upgrade llvm@5
brew link --overwrite gcc@7
SRC_DIR=$(pwd)
PREFIX_DIR=$HOME/local/llvm5
export CC=/usr/local/opt/gcc/bin/gcc-7
export CXX=/usr/local/opt/gcc/bin/g++-7
mkdir -p $HOME/local
cd $HOME/local
wget http://s3.amazonaws.com/superjoe/temp/llvm5.tar.xz
tar xfp llvm5.tar.xz
cd $SRC_DIR

7
ci/travis_osx_script
View File

@ -2,14 +2,9 @@
set -x set -x
PREFIX_DIR=$HOME/local/llvm5
export CC=/usr/local/opt/gcc/bin/gcc-7
export CXX=/usr/local/opt/gcc/bin/g++-7
echo $PATH
mkdir build mkdir build
cd build cd build
cmake .. -DCMAKE_PREFIX_PATH=$PREFIX_DIR -DCMAKE_INSTALL_PREFIX=$(pwd) -DZIG_LIBC_LIB_DIR=$(dirname $($CC -print-file-name=crt1.o)) -DZIG_LIBC_INCLUDE_DIR=$(echo -n | $CC -E -x c - -v 2>&1 | grep -B1 "End of search list." | head -n1 | cut -c 2- | sed "s/ .*//") -DZIG_LIBC_STATIC_LIB_DIR=$(dirname $($CC -print-file-name=crtbegin.o)) -DZIG_FORCE_EXTERNAL_LLD=ON cmake .. -DCMAKE_PREFIX_PATH=/usr/local/opt/llvm@5/ -DCMAKE_INSTALL_PREFIX=$(pwd) -DZIG_LIBC_LIB_DIR=$(dirname $($CC -print-file-name=crt1.o)) -DZIG_LIBC_INCLUDE_DIR=$(echo -n | $CC -E -x c - -v 2>&1 | grep -B1 "End of search list." | head -n1 | cut -c 2- | sed "s/ .*//") -DZIG_LIBC_STATIC_LIB_DIR=$(dirname $($CC -print-file-name=crtbegin.o))
make VERBOSE=1 make VERBOSE=1
make install make install
./zig build --build-file ../build.zig test ./zig build --build-file ../build.zig test

93
deps/SoftFloat-3d-prebuilt/platform.h vendored Normal file
View File

@ -0,0 +1,93 @@
#ifndef ZIG_DEP_SOFTFLOAT_PLATFORM_H
#define ZIG_DEP_SOFTFLOAT_PLATFORM_H
#if defined(__BIG_ENDIAN__)
#define BIGENDIAN 1
#elif defined(__ARMEB__)
#define BIGENDIAN 1
#elif defined(__THUMBEB__)
#define BIGENDIAN 1
#elif defined(__AARCH64EB__)
#define BIGENDIAN 1
#elif defined(_MIPSEB)
#define BIGENDIAN 1
#elif defined(__MIPSEB)
#define BIGENDIAN 1
#elif defined(__MIPSEB__)
#define BIGENDIAN 1
#elif defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
#define BIGENDIAN 1
#elif defined(_BIG_ENDIAN)
#define BIGENDIAN 1
#elif defined(__sparc)
#define BIGENDIAN 1
#elif defined(__sparc__)
#define BIGENDIAN 1
#elif defined(_POWER)
#define BIGENDIAN 1
#elif defined(__powerpc__)
#define BIGENDIAN 1
#elif defined(__ppc__)
#define BIGENDIAN 1
#elif defined(__hpux)
#define BIGENDIAN 1
#elif defined(__hppa)
#define BIGENDIAN 1
#elif defined(_POWER)
#define BIGENDIAN 1
#elif defined(__s390__)
#define BIGENDIAN 1
#elif defined(__LITTLE_ENDIAN__)
#define LITTLEENDIAN 1
#elif defined(__ARMEL__)
#define LITTLEENDIAN 1
#elif defined(__THUMBEL__)
#define LITTLEENDIAN 1
#elif defined(__AARCH64EL__)
#define LITTLEENDIAN 1
#elif defined(_MIPSEL)
#define LITTLEENDIAN 1
#elif defined(__MIPSEL)
#define LITTLEENDIAN 1
#elif defined(__MIPSEL__)
#define LITTLEENDIAN 1
#elif defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
#define LITTLEENDIAN 1
#elif defined(_LITTLE_ENDIAN)
#define LITTLEENDIAN 1
#elif defined(__i386__)
#define LITTLEENDIAN 1
#elif defined(__alpha__)
#define LITTLEENDIAN 1
#elif defined(__ia64)
#define LITTLEENDIAN 1
#elif defined(__ia64__)
#define LITTLEENDIAN 1
#elif defined(_M_IX86)
#define LITTLEENDIAN 1
#elif defined(_M_IA64)
#define LITTLEENDIAN 1
#elif defined(_M_ALPHA)
#define LITTLEENDIAN 1
#elif defined(__amd64)
#define LITTLEENDIAN 1
#elif defined(__amd64__)
#define LITTLEENDIAN 1
#elif defined(_M_AMD64)
#define LITTLEENDIAN 1
#elif defined(__x86_64)
#define LITTLEENDIAN 1
#elif defined(__x86_64__)
#define LITTLEENDIAN 1
#elif defined(_M_X64)
#define LITTLEENDIAN 1
#elif defined(__bfin__)
#define LITTLEENDIAN 1
#else
#error unable to detect endianness
#endif
#define INLINE inline
#define THREAD_LOCAL __thread
#endif

2
src/all_types.hpp
View File

@ -227,7 +227,7 @@ struct ConstExprValue {
BigFloat x_bigfloat; BigFloat x_bigfloat;
float x_f32; float x_f32;
double x_f64; double x_f64;
__float128 x_f128; float128_t x_f128;
bool x_bool; bool x_bool;
ConstFn x_fn; ConstFn x_fn;
ConstBoundFnValue x_bound_fn; ConstBoundFnValue x_bound_fn;

15
src/analyze.cpp
View File

@ -13,9 +13,10 @@
#include "ir_print.hpp" #include "ir_print.hpp"
#include "os.hpp" #include "os.hpp"
#include "parser.hpp" #include "parser.hpp"
#include "quadmath.hpp" #include "softfloat.hpp"
#include "zig_llvm.hpp" #include "zig_llvm.hpp"
static const size_t default_backward_branch_quota = 1000; static const size_t default_backward_branch_quota = 1000;
static void resolve_enum_type(CodeGen *g, TypeTableEntry *enum_type); static void resolve_enum_type(CodeGen *g, TypeTableEntry *enum_type);
@ -3462,7 +3463,7 @@ static uint32_t hash_const_val(ConstExprValue *const_val) {
} }
case TypeTableEntryIdNumLitFloat: case TypeTableEntryIdNumLitFloat:
{ {
__float128 f128 = bigfloat_to_f128(&const_val->data.x_bigfloat); float128_t f128 = bigfloat_to_f128(&const_val->data.x_bigfloat);
uint32_t ints[4]; uint32_t ints[4];
memcpy(&ints[0], &f128, 16); memcpy(&ints[0], &f128, 16);
return ints[0] ^ ints[1] ^ ints[2] ^ ints[3] ^ 0xed8b3dfb; return ints[0] ^ ints[1] ^ ints[2] ^ ints[3] ^ 0xed8b3dfb;
@ -3778,7 +3779,7 @@ void init_const_float(ConstExprValue *const_val, TypeTableEntry *type, double va
const_val->data.x_f64 = value; const_val->data.x_f64 = value;
break; break;
case 128: case 128:
// if we need this, we should add a function that accepts a __float128 param // if we need this, we should add a function that accepts a float128_t param
zig_unreachable(); zig_unreachable();
default: default:
zig_unreachable(); zig_unreachable();
@ -4035,7 +4036,7 @@ bool const_values_equal(ConstExprValue *a, ConstExprValue *b) {
case 64: case 64:
return a->data.x_f64 == b->data.x_f64; return a->data.x_f64 == b->data.x_f64;
case 128: case 128:
return a->data.x_f128 == b->data.x_f128; return f128M_eq(&a->data.x_f128, &b->data.x_f128);
default: default:
zig_unreachable(); zig_unreachable();
} }
@ -4222,7 +4223,11 @@ void render_const_value(CodeGen *g, Buf *buf, ConstExprValue *const_val) {
const size_t extra_len = 100; const size_t extra_len = 100;
size_t old_len = buf_len(buf); size_t old_len = buf_len(buf);
buf_resize(buf, old_len + extra_len); buf_resize(buf, old_len + extra_len);
int len = quadmath_snprintf(buf_ptr(buf) + old_len, extra_len, "%Qf", const_val->data.x_f128); float64_t f64_value = f128M_to_f64(&const_val->data.x_f128);
double double_value;
memcpy(&double_value, &f64_value, sizeof(double));
// TODO actual f128 printing to decimal
int len = snprintf(buf_ptr(buf) + old_len, extra_len, "%f", double_value);
assert(len > 0); assert(len > 0);
buf_resize(buf, old_len + len); buf_resize(buf, old_len + len);
return; return;

111
src/bigfloat.cpp
View File

@ -8,42 +8,52 @@
#include "bigfloat.hpp" #include "bigfloat.hpp"
#include "bigint.hpp" #include "bigint.hpp"
#include "buffer.hpp" #include "buffer.hpp"
#include "quadmath.hpp" #include "softfloat.hpp"
#include <stdio.h>
#include <math.h> #include <math.h>
#include <errno.h> #include <errno.h>
void bigfloat_init_128(BigFloat *dest, __float128 x) {
void bigfloat_init_128(BigFloat *dest, float128_t x) {
dest->value = x; dest->value = x;
} }
void bigfloat_init_32(BigFloat *dest, float x) { void bigfloat_init_32(BigFloat *dest, float x) {
dest->value = x; float32_t f32_val;
memcpy(&f32_val, &x, sizeof(float));
f32_to_f128M(f32_val, &dest->value);
} }
void bigfloat_init_64(BigFloat *dest, double x) { void bigfloat_init_64(BigFloat *dest, double x) {
dest->value = x; float64_t f64_val;
memcpy(&f64_val, &x, sizeof(double));
f64_to_f128M(f64_val, &dest->value);
} }
void bigfloat_init_bigfloat(BigFloat *dest, const BigFloat *x) { void bigfloat_init_bigfloat(BigFloat *dest, const BigFloat *x) {
dest->value = x->value; memcpy(&dest->value, &x->value, sizeof(float128_t));
} }
void bigfloat_init_bigint(BigFloat *dest, const BigInt *op) { void bigfloat_init_bigint(BigFloat *dest, const BigInt *op) {
dest->value = 0.0; ui32_to_f128M(0, &dest->value);
if (op->digit_count == 0) if (op->digit_count == 0)
return; return;
__float128 base = (__float128)UINT64_MAX; float128_t base;
ui64_to_f128M(UINT64_MAX, &base);
const uint64_t *digits = bigint_ptr(op); const uint64_t *digits = bigint_ptr(op);
for (size_t i = op->digit_count - 1;;) { for (size_t i = op->digit_count - 1;;) {
uint64_t digit = digits[i]; float128_t digit_f128;
dest->value *= base; ui64_to_f128M(digits[i], &digit_f128);
dest->value += (__float128)digit;
f128M_mulAdd(&dest->value, &base, &digit_f128, &dest->value);
if (i == 0) { if (i == 0) {
if (op->is_negative) { if (op->is_negative) {
dest->value = -dest->value; float128_t zero_f128;
ui32_to_f128M(0, &zero_f128);
f128M_sub(&zero_f128, &dest->value, &dest->value);
} }
return; return;
} }
@ -54,97 +64,120 @@ void bigfloat_init_bigint(BigFloat *dest, const BigInt *op) {
int bigfloat_init_buf_base10(BigFloat *dest, const uint8_t *buf_ptr, size_t buf_len) { int bigfloat_init_buf_base10(BigFloat *dest, const uint8_t *buf_ptr, size_t buf_len) {
char *str_begin = (char *)buf_ptr; char *str_begin = (char *)buf_ptr;
char *str_end; char *str_end;
errno = 0; errno = 0;
dest->value = strtoflt128(str_begin, &str_end); double value = strtod(str_begin, &str_end); // TODO actual f128 parsing
if (errno) { if (errno) {
return ErrorOverflow; return ErrorOverflow;
} }
float64_t value_f64;
memcpy(&value_f64, &value, sizeof(double));
f64_to_f128M(value_f64, &dest->value);
assert(str_end <= ((char*)buf_ptr) + buf_len); assert(str_end <= ((char*)buf_ptr) + buf_len);
return 0; return 0;
} }
void bigfloat_add(BigFloat *dest, const BigFloat *op1, const BigFloat *op2) { void bigfloat_add(BigFloat *dest, const BigFloat *op1, const BigFloat *op2) {
dest->value = op1->value + op2->value; f128M_add(&op1->value, &op2->value, &dest->value);
} }
void bigfloat_negate(BigFloat *dest, const BigFloat *op) { void bigfloat_negate(BigFloat *dest, const BigFloat *op) {
dest->value = -op->value; float128_t zero_f128;
ui32_to_f128M(0, &zero_f128);
f128M_sub(&zero_f128, &op->value, &dest->value);
} }
void bigfloat_sub(BigFloat *dest, const BigFloat *op1, const BigFloat *op2) { void bigfloat_sub(BigFloat *dest, const BigFloat *op1, const BigFloat *op2) {
dest->value = op1->value - op2->value; f128M_sub(&op1->value, &op2->value, &dest->value);
} }
void bigfloat_mul(BigFloat *dest, const BigFloat *op1, const BigFloat *op2) { void bigfloat_mul(BigFloat *dest, const BigFloat *op1, const BigFloat *op2) {
dest->value = op1->value * op2->value; f128M_mul(&op1->value, &op2->value, &dest->value);
} }
void bigfloat_div(BigFloat *dest, const BigFloat *op1, const BigFloat *op2) { void bigfloat_div(BigFloat *dest, const BigFloat *op1, const BigFloat *op2) {
dest->value = op1->value / op2->value; f128M_div(&op1->value, &op2->value, &dest->value);
} }
void bigfloat_div_trunc(BigFloat *dest, const BigFloat *op1, const BigFloat *op2) { void bigfloat_div_trunc(BigFloat *dest, const BigFloat *op1, const BigFloat *op2) {
dest->value = op1->value / op2->value; f128M_div(&op1->value, &op2->value, &dest->value);
if (dest->value >= 0.0) { f128M_roundToInt(&dest->value, softfloat_round_minMag, false, &dest->value);
dest->value = floorq(dest->value);
} else {
dest->value = ceilq(dest->value);
}
} }
void bigfloat_div_floor(BigFloat *dest, const BigFloat *op1, const BigFloat *op2) { void bigfloat_div_floor(BigFloat *dest, const BigFloat *op1, const BigFloat *op2) {
dest->value = floorq(op1->value / op2->value); f128M_div(&op1->value, &op2->value, &dest->value);
f128M_roundToInt(&dest->value, softfloat_round_min, false, &dest->value);
} }
void bigfloat_rem(BigFloat *dest, const BigFloat *op1, const BigFloat *op2) { void bigfloat_rem(BigFloat *dest, const BigFloat *op1, const BigFloat *op2) {
dest->value = fmodq(op1->value, op2->value); f128M_rem(&op1->value, &op2->value, &dest->value);
} }
void bigfloat_mod(BigFloat *dest, const BigFloat *op1, const BigFloat *op2) { void bigfloat_mod(BigFloat *dest, const BigFloat *op1, const BigFloat *op2) {
dest->value = fmodq(fmodq(op1->value, op2->value) + op2->value, op2->value); f128M_rem(&op1->value, &op2->value, &dest->value);
f128M_add(&dest->value, &op2->value, &dest->value);
f128M_rem(&dest->value, &op2->value, &dest->value);
} }
void bigfloat_append_buf(Buf *buf, const BigFloat *op) { void bigfloat_append_buf(Buf *buf, const BigFloat *op) {
const size_t extra_len = 100; const size_t extra_len = 100;
size_t old_len = buf_len(buf); size_t old_len = buf_len(buf);
buf_resize(buf, old_len + extra_len); buf_resize(buf, old_len + extra_len);
int len = quadmath_snprintf(buf_ptr(buf) + old_len, extra_len, "%Qf", op->value);
// TODO actually print f128
float64_t f64_value = f128M_to_f64(&op->value);
double double_value;
memcpy(&double_value, &f64_value, sizeof(double));
int len = snprintf(buf_ptr(buf) + old_len, extra_len, "%f", double_value);
assert(len > 0); assert(len > 0);
buf_resize(buf, old_len + len); buf_resize(buf, old_len + len);
} }
Cmp bigfloat_cmp(const BigFloat *op1, const BigFloat *op2) { Cmp bigfloat_cmp(const BigFloat *op1, const BigFloat *op2) {
if (op1->value > op2->value) { if (f128M_lt(&op1->value, &op2->value)) {
return CmpGT;
} else if (op1->value < op2->value) {
return CmpLT; return CmpLT;
} else { } else if (f128M_eq(&op1->value, &op2->value)) {
return CmpEQ; return CmpEQ;
} else {
return CmpGT;
} }
} }
float bigfloat_to_f32(const BigFloat *bigfloat) { float bigfloat_to_f32(const BigFloat *bigfloat) {
return (float)bigfloat->value; float32_t f32_value = f128M_to_f32(&bigfloat->value);
float result;
memcpy(&result, &f32_value, sizeof(float));
return result;
} }
double bigfloat_to_f64(const BigFloat *bigfloat) { double bigfloat_to_f64(const BigFloat *bigfloat) {
return (double)bigfloat->value; float64_t f64_value = f128M_to_f64(&bigfloat->value);
double result;
memcpy(&result, &f64_value, sizeof(double));
return result;
} }
__float128 bigfloat_to_f128(const BigFloat *bigfloat) { float128_t bigfloat_to_f128(const BigFloat *bigfloat) {
return bigfloat->value; return bigfloat->value;
} }
Cmp bigfloat_cmp_zero(const BigFloat *bigfloat) { Cmp bigfloat_cmp_zero(const BigFloat *bigfloat) {
if (bigfloat->value < 0.0) { float128_t zero_float;
ui32_to_f128M(0, &zero_float);
if (f128M_lt(&bigfloat->value, &zero_float)) {
return CmpLT; return CmpLT;
} else if (bigfloat->value > 0.0) { } else if (f128M_eq(&bigfloat->value, &zero_float)) {
return CmpGT;
} else {
return CmpEQ; return CmpEQ;
} else {
return CmpGT;
} }
} }
bool bigfloat_has_fraction(const BigFloat *bigfloat) { bool bigfloat_has_fraction(const BigFloat *bigfloat) {
return floorq(bigfloat->value) != bigfloat->value; float128_t floored;
f128M_roundToInt(&bigfloat->value, softfloat_round_minMag, false, &floored);
return !f128M_eq(&floored, &bigfloat->value);
} }

12
src/bigfloat.hpp
View File

@ -13,27 +13,25 @@
#include <stdint.h> #include <stdint.h>
#include <stddef.h> #include <stddef.h>
#if defined(_MSC_VER) #include "softfloat_types.h"
// TODO support 128 bit floats with msvc
typedef long double __float128;
#endif
struct BigFloat { struct BigFloat {
__float128 value; float128_t value;
}; };
struct Buf; struct Buf;
void bigfloat_init_32(BigFloat *dest, float x); void bigfloat_init_32(BigFloat *dest, float x);
void bigfloat_init_64(BigFloat *dest, double x); void bigfloat_init_64(BigFloat *dest, double x);
void bigfloat_init_128(BigFloat *dest, __float128 x); void bigfloat_init_128(BigFloat *dest, float128_t x);
void bigfloat_init_bigfloat(BigFloat *dest, const BigFloat *x); void bigfloat_init_bigfloat(BigFloat *dest, const BigFloat *x);
void bigfloat_init_bigint(BigFloat *dest, const BigInt *op); void bigfloat_init_bigint(BigFloat *dest, const BigInt *op);
int bigfloat_init_buf_base10(BigFloat *dest, const uint8_t *buf_ptr, size_t buf_len); int bigfloat_init_buf_base10(BigFloat *dest, const uint8_t *buf_ptr, size_t buf_len);
float bigfloat_to_f32(const BigFloat *bigfloat); float bigfloat_to_f32(const BigFloat *bigfloat);
double bigfloat_to_f64(const BigFloat *bigfloat); double bigfloat_to_f64(const BigFloat *bigfloat);
__float128 bigfloat_to_f128(const BigFloat *bigfloat); float128_t bigfloat_to_f128(const BigFloat *bigfloat);
void bigfloat_add(BigFloat *dest, const BigFloat *op1, const BigFloat *op2); void bigfloat_add(BigFloat *dest, const BigFloat *op1, const BigFloat *op2);
void bigfloat_negate(BigFloat *dest, const BigFloat *op); void bigfloat_negate(BigFloat *dest, const BigFloat *op);

33
src/bigint.cpp
View File

@ -10,6 +10,7 @@
#include "buffer.hpp" #include "buffer.hpp"
#include "list.hpp" #include "list.hpp"
#include "os.hpp" #include "os.hpp"
#include "softfloat.hpp"
static void bigint_normalize(BigInt *dest) { static void bigint_normalize(BigInt *dest) {
const uint64_t *digits = bigint_ptr(dest); const uint64_t *digits = bigint_ptr(dest);
@ -200,12 +201,36 @@ void bigint_init_bigint(BigInt *dest, const BigInt *src) {
} }
void bigint_init_bigfloat(BigInt *dest, const BigFloat *op) { void bigint_init_bigfloat(BigInt *dest, const BigFloat *op) {
if (op->value >= 0) { float128_t zero;
bigint_init_u128(dest, (uint128_t)(op->value)); ui32_to_f128M(0, &zero);
dest->is_negative = f128M_lt(&op->value, &zero);
float128_t abs_val;
if (dest->is_negative) {
f128M_sub(&zero, &op->value, &abs_val);
} else { } else {
bigint_init_u128(dest, (uint128_t)(-op->value)); memcpy(&abs_val, &op->value, sizeof(float128_t));
dest->is_negative = true;
} }
float128_t max_u64;
ui64_to_f128M(UINT64_MAX, &max_u64);
if (f128M_le(&abs_val, &max_u64)) {
dest->digit_count = 1;
dest->data.digit = f128M_to_ui64(&op->value, softfloat_round_minMag, false);
bigint_normalize(dest);
return;
}
float128_t amt;
f128M_div(&abs_val, &max_u64, &amt);
float128_t remainder;
f128M_rem(&abs_val, &max_u64, &remainder);
dest->digit_count = 2;
dest->data.digits = allocate_nonzero<uint64_t>(dest->digit_count);
dest->data.digits[0] = f128M_to_ui64(&remainder, softfloat_round_minMag, false);
dest->data.digits[1] = f128M_to_ui64(&amt, softfloat_round_minMag, false);
bigint_normalize(dest);
} }
bool bigint_fits_in_bits(const BigInt *bn, size_t bit_count, bool is_signed) { bool bigint_fits_in_bits(const BigInt *bn, size_t bit_count, bool is_signed) {

110
src/ir.cpp
View File

@ -12,8 +12,8 @@
#include "ir_print.hpp" #include "ir_print.hpp"
#include "os.hpp" #include "os.hpp"
#include "parsec.hpp" #include "parsec.hpp"
#include "quadmath.hpp"
#include "range_set.hpp" #include "range_set.hpp"
#include "softfloat.hpp"
struct IrExecContext { struct IrExecContext {
ConstExprValue *mem_slot_list; ConstExprValue *mem_slot_list;
@ -6439,7 +6439,11 @@ static bool float_has_fraction(ConstExprValue *const_val) {
case 64: case 64:
return floor(const_val->data.x_f64) != const_val->data.x_f64; return floor(const_val->data.x_f64) != const_val->data.x_f64;
case 128: case 128:
return floorq(const_val->data.x_f128) != const_val->data.x_f128; {
float128_t floored;
f128M_roundToInt(&const_val->data.x_f128, softfloat_round_minMag, false, &floored);
return !f128M_eq(&floored, &const_val->data.x_f128);
}
default: default:
zig_unreachable(); zig_unreachable();
} }
@ -6461,10 +6465,16 @@ static void float_append_buf(Buf *buf, ConstExprValue *const_val) {
break; break;
case 128: case 128:
{ {
// TODO actual implementation
const size_t extra_len = 100; const size_t extra_len = 100;
size_t old_len = buf_len(buf); size_t old_len = buf_len(buf);
buf_resize(buf, old_len + extra_len); buf_resize(buf, old_len + extra_len);
int len = quadmath_snprintf(buf_ptr(buf) + old_len, extra_len, "%Qf", const_val->data.x_f128);
float64_t f64_value = f128M_to_f64(&const_val->data.x_f128);
double double_value;
memcpy(&double_value, &f64_value, sizeof(double));
int len = snprintf(buf_ptr(buf) + old_len, extra_len, "%f", double_value);
assert(len > 0); assert(len > 0);
buf_resize(buf, old_len + len); buf_resize(buf, old_len + len);
break; break;
@ -6499,11 +6509,10 @@ static void float_init_bigint(BigInt *bigint, ConstExprValue *const_val) {
} }
break; break;
case 128: case 128:
if (const_val->data.x_f128 >= 0) { {
bigint_init_u128(bigint, (uint128_t)(const_val->data.x_f128)); BigFloat tmp_float;
} else { bigfloat_init_128(&tmp_float, const_val->data.x_f128);
bigint_init_u128(bigint, (uint128_t)(-const_val->data.x_f128)); bigint_init_bigfloat(bigint, &tmp_float);
bigint->is_negative = true;
} }
break; break;
default: default:
@ -6548,8 +6557,12 @@ static void float_init_f32(ConstExprValue *dest_val, float x) {
dest_val->data.x_f64 = x; dest_val->data.x_f64 = x;
break; break;
case 128: case 128:
dest_val->data.x_f128 = x; {
break; float32_t x_f32;
memcpy(&x_f32, &x, sizeof(float));
f32_to_f128M(x_f32, &dest_val->data.x_f128);
break;
}
default: default:
zig_unreachable(); zig_unreachable();
} }
@ -6570,8 +6583,12 @@ static void float_init_f64(ConstExprValue *dest_val, double x) {
dest_val->data.x_f64 = x; dest_val->data.x_f64 = x;
break; break;
case 128: case 128:
dest_val->data.x_f128 = x; {
break; float64_t x_f64;
memcpy(&x_f64, &x, sizeof(double));
f64_to_f128M(x_f64, &dest_val->data.x_f128);
break;
}
default: default:
zig_unreachable(); zig_unreachable();
} }
@ -6580,20 +6597,28 @@ static void float_init_f64(ConstExprValue *dest_val, double x) {
} }
} }
static void float_init_f128(ConstExprValue *dest_val, __float128 x) { static void float_init_f128(ConstExprValue *dest_val, float128_t x) {
if (dest_val->type->id == TypeTableEntryIdNumLitFloat) { if (dest_val->type->id == TypeTableEntryIdNumLitFloat) {
bigfloat_init_128(&dest_val->data.x_bigfloat, x); bigfloat_init_128(&dest_val->data.x_bigfloat, x);
} else if (dest_val->type->id == TypeTableEntryIdFloat) { } else if (dest_val->type->id == TypeTableEntryIdFloat) {
switch (dest_val->type->data.floating.bit_count) { switch (dest_val->type->data.floating.bit_count) {
case 32: case 32:
dest_val->data.x_f32 = x; {
break; float32_t f32_val = f128M_to_f32(&x);
memcpy(&dest_val->data.x_f32, &f32_val, sizeof(float));
break;
}
case 64: case 64:
dest_val->data.x_f64 = x; {
break; float64_t f64_val = f128M_to_f64(&x);
memcpy(&dest_val->data.x_f64, &f64_val, sizeof(double));
break;
}
case 128: case 128:
dest_val->data.x_f128 = x; {
break; memcpy(&dest_val->data.x_f128, &x, sizeof(float128_t));
break;
}
default: default:
zig_unreachable(); zig_unreachable();
} }
@ -6647,12 +6672,12 @@ static Cmp float_cmp(ConstExprValue *op1, ConstExprValue *op2) {
return CmpEQ; return CmpEQ;
} }
case 128: case 128:
if (op1->data.x_f128 > op2->data.x_f128) { if (f128M_lt(&op1->data.x_f128, &op2->data.x_f128)) {
return CmpGT;
} else if (op1->data.x_f128 < op2->data.x_f128) {
return CmpLT; return CmpLT;
} else { } else if (f128M_eq(&op1->data.x_f128, &op2->data.x_f128)) {
return CmpEQ; return CmpEQ;
} else {
return CmpGT;
} }
default: default:
zig_unreachable(); zig_unreachable();
@ -6684,12 +6709,14 @@ static Cmp float_cmp_zero(ConstExprValue *op) {
return CmpEQ; return CmpEQ;
} }
case 128: case 128:
if (op->data.x_f128 < 0.0) { float128_t zero_float;
ui32_to_f128M(0, &zero_float);
if (f128M_lt(&op->data.x_f128, &zero_float)) {
return CmpLT; return CmpLT;
} else if (op->data.x_f128 > 0.0) { } else if (f128M_eq(&op->data.x_f128, &zero_float)) {
return CmpGT;
} else {
return CmpEQ; return CmpEQ;
} else {
return CmpGT;
} }
default: default:
zig_unreachable(); zig_unreachable();
@ -6713,7 +6740,7 @@ static void float_add(ConstExprValue *out_val, ConstExprValue *op1, ConstExprVal
out_val->data.x_f64 = op1->data.x_f64 + op2->data.x_f64; out_val->data.x_f64 = op1->data.x_f64 + op2->data.x_f64;
return; return;
case 128: case 128:
out_val->data.x_f128 = op1->data.x_f128 + op2->data.x_f128; f128M_add(&op1->data.x_f128, &op2->data.x_f128, &out_val->data.x_f128);
return; return;
default: default:
zig_unreachable(); zig_unreachable();
@ -6737,7 +6764,7 @@ static void float_sub(ConstExprValue *out_val, ConstExprValue *op1, ConstExprVal
out_val->data.x_f64 = op1->data.x_f64 - op2->data.x_f64; out_val->data.x_f64 = op1->data.x_f64 - op2->data.x_f64;
return; return;
case 128: case 128:
out_val->data.x_f128 = op1->data.x_f128 - op2->data.x_f128; f128M_sub(&op1->data.x_f128, &op2->data.x_f128, &out_val->data.x_f128);
return; return;
default: default:
zig_unreachable(); zig_unreachable();
@ -6761,7 +6788,7 @@ static void float_mul(ConstExprValue *out_val, ConstExprValue *op1, ConstExprVal
out_val->data.x_f64 = op1->data.x_f64 * op2->data.x_f64; out_val->data.x_f64 = op1->data.x_f64 * op2->data.x_f64;
return; return;
case 128: case 128:
out_val->data.x_f128 = op1->data.x_f128 * op2->data.x_f128; f128M_mul(&op1->data.x_f128, &op2->data.x_f128, &out_val->data.x_f128);
return; return;
default: default:
zig_unreachable(); zig_unreachable();
@ -6785,7 +6812,7 @@ static void float_div(ConstExprValue *out_val, ConstExprValue *op1, ConstExprVal
out_val->data.x_f64 = op1->data.x_f64 / op2->data.x_f64; out_val->data.x_f64 = op1->data.x_f64 / op2->data.x_f64;
return; return;
case 128: case 128:
out_val->data.x_f128 = op1->data.x_f128 / op2->data.x_f128; f128M_div(&op1->data.x_f128, &op2->data.x_f128, &out_val->data.x_f128);
return; return;
default: default:
zig_unreachable(); zig_unreachable();
@ -6819,12 +6846,8 @@ static void float_div_trunc(ConstExprValue *out_val, ConstExprValue *op1, ConstE
} }
return; return;
case 128: case 128:
out_val->data.x_f128 = op1->data.x_f128 / op2->data.x_f128; f128M_div(&op1->data.x_f128, &op2->data.x_f128, &out_val->data.x_f128);
if (out_val->data.x_f128 >= 0.0) { f128M_roundToInt(&out_val->data.x_f128, softfloat_round_minMag, false, &out_val->data.x_f128);
out_val->data.x_f128 = floorq(out_val->data.x_f128);
} else {
out_val->data.x_f128 = ceilq(out_val->data.x_f128);
}
return; return;
default: default:
zig_unreachable(); zig_unreachable();
@ -6848,7 +6871,8 @@ static void float_div_floor(ConstExprValue *out_val, ConstExprValue *op1, ConstE
out_val->data.x_f64 = floor(op1->data.x_f64 / op2->data.x_f64); out_val->data.x_f64 = floor(op1->data.x_f64 / op2->data.x_f64);
return; return;
case 128: case 128:
out_val->data.x_f128 = floorq(op1->data.x_f128 / op2->data.x_f128); f128M_div(&op1->data.x_f128, &op2->data.x_f128, &out_val->data.x_f128);
f128M_roundToInt(&out_val->data.x_f128, softfloat_round_min, false, &out_val->data.x_f128);
return; return;
default: default:
zig_unreachable(); zig_unreachable();
@ -6872,7 +6896,7 @@ static void float_rem(ConstExprValue *out_val, ConstExprValue *op1, ConstExprVal
out_val->data.x_f64 = fmod(op1->data.x_f64, op2->data.x_f64); out_val->data.x_f64 = fmod(op1->data.x_f64, op2->data.x_f64);
return; return;
case 128: case 128:
out_val->data.x_f128 = fmodq(op1->data.x_f128, op2->data.x_f128); f128M_rem(&op1->data.x_f128, &op2->data.x_f128, &out_val->data.x_f128);
return; return;
default: default:
zig_unreachable(); zig_unreachable();
@ -6896,7 +6920,9 @@ static void float_mod(ConstExprValue *out_val, ConstExprValue *op1, ConstExprVal
out_val->data.x_f64 = fmod(fmod(op1->data.x_f64, op2->data.x_f64) + op2->data.x_f64, op2->data.x_f64); out_val->data.x_f64 = fmod(fmod(op1->data.x_f64, op2->data.x_f64) + op2->data.x_f64, op2->data.x_f64);
return; return;
case 128: case 128:
out_val->data.x_f128 = fmodq(fmodq(op1->data.x_f128, op2->data.x_f128) + op2->data.x_f128, op2->data.x_f128); f128M_rem(&op1->data.x_f128, &op2->data.x_f128, &out_val->data.x_f128);
f128M_add(&out_val->data.x_f128, &op2->data.x_f128, &out_val->data.x_f128);
f128M_rem(&out_val->data.x_f128, &op2->data.x_f128, &out_val->data.x_f128);
return; return;
default: default:
zig_unreachable(); zig_unreachable();
@ -6919,7 +6945,9 @@ static void float_negate(ConstExprValue *out_val, ConstExprValue *op) {
out_val->data.x_f64 = -op->data.x_f64; out_val->data.x_f64 = -op->data.x_f64;
return; return;
case 128: case 128:
out_val->data.x_f128 = -op->data.x_f128; float128_t zero_f128;
ui32_to_f128M(0, &zero_f128);
f128M_sub(&zero_f128, &op->data.x_f128, &out_val->data.x_f128);
return; return;
default: default:
zig_unreachable(); zig_unreachable();

51
src/quadmath.hpp
View File

@ -1,51 +0,0 @@
/*
* Copyright (c) 2017 Andrew Kelley
*
* This file is part of zig, which is MIT licensed.
* See http://opensource.org/licenses/MIT
*/
#ifndef ZIG_QUADMATH_HPP
#define ZIG_QUADMATH_HPP
#if defined(_MSC_VER)
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <cmath>
static inline __float128 fmodq(__float128 a, __float128 b) {
return fmodl(a, b);
}
static inline __float128 ceilq(__float128 a) {
return ceill(a);
}
static inline __float128 floorq(__float128 a) {
return floorl(a);
}
static inline __float128 strtoflt128(const char *s, char **sp) {
return strtold(s, sp);
}
static inline int quadmath_snprintf(char *s, size_t size, const char *format, ...) {
va_list args;
va_start(args, format);
int result = vsnprintf(s, size, format, args);
va_end(args);
return result;
}
#else
extern "C" {
__float128 fmodq(__float128 a, __float128 b);
__float128 ceilq(__float128 a);
__float128 floorq(__float128 a);
__float128 strtoflt128 (const char *s, char **sp);
int quadmath_snprintf (char *s, size_t size, const char *format, ...);
}
#endif
#endif

15
src/softfloat.hpp Normal file
View File

@ -0,0 +1,15 @@
/*
* Copyright (c) 2017 Andrew Kelley
*
* This file is part of zig, which is MIT licensed.
* See http://opensource.org/licenses/MIT
*/
#ifndef ZIG_SOFTFLOAT_HPP
#define ZIG_SOFTFLOAT_HPP
extern "C" {
#include "softfloat.h"
}
#endif

4
std/math/atan2.zig
View File

@ -241,7 +241,7 @@ test "math.atan2_32.special" {
assert(atan2_32(0.0, 5.0) == 0.0); assert(atan2_32(0.0, 5.0) == 0.0);
assert(atan2_32(-0.0, 5.0) == -0.0); assert(atan2_32(-0.0, 5.0) == -0.0);
assert(math.approxEq(f32, atan2_32(0.0, -5.0), math.pi, epsilon)); assert(math.approxEq(f32, atan2_32(0.0, -5.0), math.pi, epsilon));
assert(math.approxEq(f32, atan2_32(-0.0, -5.0), -math.pi, epsilon)); //assert(math.approxEq(f32, atan2_32(-0.0, -5.0), -math.pi, epsilon)); TODO support negative zero?
assert(math.approxEq(f32, atan2_32(1.0, 0.0), math.pi / 2.0, epsilon)); assert(math.approxEq(f32, atan2_32(1.0, 0.0), math.pi / 2.0, epsilon));
assert(math.approxEq(f32, atan2_32(1.0, -0.0), math.pi / 2.0, epsilon)); assert(math.approxEq(f32, atan2_32(1.0, -0.0), math.pi / 2.0, epsilon));
assert(math.approxEq(f32, atan2_32(-1.0, 0.0), -math.pi / 2.0, epsilon)); assert(math.approxEq(f32, atan2_32(-1.0, 0.0), -math.pi / 2.0, epsilon));
@ -265,7 +265,7 @@ test "math.atan2_64.special" {
assert(atan2_64(0.0, 5.0) == 0.0); assert(atan2_64(0.0, 5.0) == 0.0);
assert(atan2_64(-0.0, 5.0) == -0.0); assert(atan2_64(-0.0, 5.0) == -0.0);
assert(math.approxEq(f64, atan2_64(0.0, -5.0), math.pi, epsilon)); assert(math.approxEq(f64, atan2_64(0.0, -5.0), math.pi, epsilon));
assert(math.approxEq(f64, atan2_64(-0.0, -5.0), -math.pi, epsilon)); //assert(math.approxEq(f64, atan2_64(-0.0, -5.0), -math.pi, epsilon)); TODO support negative zero?
assert(math.approxEq(f64, atan2_64(1.0, 0.0), math.pi / 2.0, epsilon)); assert(math.approxEq(f64, atan2_64(1.0, 0.0), math.pi / 2.0, epsilon));
assert(math.approxEq(f64, atan2_64(1.0, -0.0), math.pi / 2.0, epsilon)); assert(math.approxEq(f64, atan2_64(1.0, -0.0), math.pi / 2.0, epsilon));
assert(math.approxEq(f64, atan2_64(-1.0, 0.0), -math.pi / 2.0, epsilon)); assert(math.approxEq(f64, atan2_64(-1.0, 0.0), -math.pi / 2.0, epsilon));

4
std/math/pow.zig
View File

@ -201,7 +201,7 @@ test "math.pow.special" {
assert(math.isNan(pow(f32, math.nan(f32), 5.0))); assert(math.isNan(pow(f32, math.nan(f32), 5.0)));
assert(math.isNan(pow(f32, 5.0, math.nan(f32)))); assert(math.isNan(pow(f32, 5.0, math.nan(f32))));
assert(math.isPositiveInf(pow(f32, 0.0, -1.0))); assert(math.isPositiveInf(pow(f32, 0.0, -1.0)));
assert(math.isNegativeInf(pow(f32, -0.0, -3.0))); //assert(math.isNegativeInf(pow(f32, -0.0, -3.0))); TODO is this required?
assert(math.isPositiveInf(pow(f32, 0.0, -math.inf(f32)))); assert(math.isPositiveInf(pow(f32, 0.0, -math.inf(f32))));
assert(math.isPositiveInf(pow(f32, -0.0, -math.inf(f32)))); assert(math.isPositiveInf(pow(f32, -0.0, -math.inf(f32))));
assert(pow(f32, 0.0, math.inf(f32)) == 0.0); assert(pow(f32, 0.0, math.inf(f32)) == 0.0);
@ -224,7 +224,7 @@ test "math.pow.special" {
assert(math.isPositiveInf(pow(f32, -0.2, -math.inf(f32)))); assert(math.isPositiveInf(pow(f32, -0.2, -math.inf(f32))));
assert(math.isPositiveInf(pow(f32, math.inf(f32), 1.0))); assert(math.isPositiveInf(pow(f32, math.inf(f32), 1.0)));
assert(pow(f32, math.inf(f32), -1.0) == 0.0); assert(pow(f32, math.inf(f32), -1.0) == 0.0);
assert(pow(f32, -math.inf(f32), 5.0) == pow(f32, -0.0, -5.0)); //assert(pow(f32, -math.inf(f32), 5.0) == pow(f32, -0.0, -5.0)); TODO support negative 0?
assert(pow(f32, -math.inf(f32), -5.2) == pow(f32, -0.0, 5.2)); assert(pow(f32, -math.inf(f32), -5.2) == pow(f32, -0.0, 5.2));
assert(math.isNan(pow(f32, -1.0, 1.2))); assert(math.isNan(pow(f32, -1.0, 1.2)));
assert(math.isNan(pow(f32, -12.4, 78.5))); assert(math.isNan(pow(f32, -12.4, 78.5)));

8
test/cases/eval.zig
View File

@ -356,10 +356,10 @@ test "@setEvalBranchQuota" {
} }
} }
test "float literal at compile time not lossy" { // TODO test "float literal at compile time not lossy" {
assert(16777216.0 + 1.0 == 16777217.0); // TODO assert(16777216.0 + 1.0 == 16777217.0);
assert(9007199254740992.0 + 1.0 == 9007199254740993.0); // TODO assert(9007199254740992.0 + 1.0 == 9007199254740993.0);
} // TODO }
test "f32 at compile time is lossy" { test "f32 at compile time is lossy" {
assert(f32(1 << 24) + 1 == 1 << 24); assert(f32(1 << 24) + 1 == 1 << 24);