Compare commits
169 Commits
d2efb23ff7
...
develop
Author | SHA1 | Date | |
---|---|---|---|
9fcbeb478b | |||
a768bde7f2 | |||
cd866fd74d | |||
67f364049c | |||
047e2e12b0 | |||
fe3ed49519 | |||
1afd77a942 | |||
cdf5038e59 | |||
651897e1e4 | |||
a1803c61c1 | |||
bfa2182f8e | |||
b01c9b27e5 | |||
07f394d5ff | |||
7e97329e78 | |||
8f5d666b7d | |||
cc123939ce | |||
a2e5405e25 | |||
cd3ec0b79d | |||
0e35a2a8c9 | |||
8220c00a3d | |||
ec5fb1e87e | |||
453407568c | |||
0fe9e6ebc8 | |||
484d9dbe08 | |||
7a7035f267 | |||
d9f1e5d31b | |||
7b35f45a48 | |||
ece6f7290f | |||
2166a6d81e | |||
fe9f2a5455 | |||
42bf6ee380 | |||
f0b582df6c | |||
6fcb3dbb66 | |||
c01eb39a76 | |||
08280a094f | |||
ae90adc854 | |||
cd358198ad | |||
8746003d3e | |||
60d2b45a81 | |||
0264c5d66f | |||
528c2536af | |||
19e38ec898 | |||
fd11ce18c4 | |||
9b7a9fa273 | |||
e24c1874c4 | |||
221d2ee38c | |||
877cad27ba | |||
a26505cb5c | |||
c1277b6528 | |||
63889b02e7 | |||
f049d8cbb3 | |||
28ac169cfe | |||
a6f24db83a | |||
e1911bc450 | |||
75d96bf18d | |||
e59458aa0e | |||
77807fec01 | |||
6852d1d299 | |||
ac1322d66b | |||
9ba9d2432c | |||
c9b7962cd3 | |||
ab31fd27c9 | |||
b3f189145f | |||
dd4416ab15 | |||
0027946f90 | |||
feaff8c4a5 | |||
af3e76cc98 | |||
b1ceac2c2a | |||
b5862039e7 | |||
51f3802394 | |||
6ce0d97e81 | |||
69c8fda5d2 | |||
c1f9328528 | |||
2b85748279 | |||
f7aa51b12e | |||
3428745a00 | |||
512b79a3e7 | |||
7a048f8b93 | |||
6f4daf91ed | |||
947d353bbf | |||
b95f518c91 | |||
4cef0f57c1 | |||
28af695592 | |||
f6cdd9d07c | |||
9e390971d4 | |||
2bb2e56310 | |||
a0eeae7dd6 | |||
8f491ef36b | |||
cbe4c2d62f | |||
31c6bb55f4 | |||
63d0162119 | |||
3b294d9da0 | |||
54233b448d | |||
e238369e18 | |||
cfc980a069 | |||
502f3e8df9 | |||
88475bfa55 | |||
71260a3ef4 | |||
23842742a6 | |||
a13b7ac6d3 | |||
aaebeaf023 | |||
fb0f6255e9 | |||
57d5ea92be | |||
383d762abc | |||
03cbd305c6 | |||
9f5326c110 | |||
f4718c6de3 | |||
53de21eef9 | |||
d443c89c87 | |||
9a2df32d57 | |||
be0f783af8 | |||
1089800682 | |||
a6a6f51f0b | |||
21e1f791ad | |||
be6f5791fa | |||
d907dc7f54 | |||
75e81ce236 | |||
82a70efdb8 | |||
978c3db06e | |||
0e88664ff7 | |||
ac818f304d | |||
ad60449073 | |||
b45b3589fa | |||
1fb7e8fcea | |||
5f9d0beafb | |||
4c0d1c75aa | |||
2f3abf2f76 | |||
62768bf81e | |||
f6be8ec006 | |||
a8f56b6e27 | |||
76ea0db25d | |||
ec1b820c18 | |||
64329cf0f6 | |||
9de0aed84d | |||
bb4e2766d1 | |||
0996d15bd4 | |||
6305efa7c2 | |||
de79adc50d | |||
0473aa5344 | |||
a45fcd28db | |||
0f15032210 | |||
efc11d87a5 | |||
4a19e27926 | |||
c15cdb0955 | |||
6609d12582 | |||
b5341700aa | |||
0b5062d21c | |||
fbca690b3b | |||
235a7e6e24 | |||
62d21e1156 | |||
9c51d6eade | |||
2878dca6b5 | |||
c28e8fd00c | |||
b3cc9d2346 | |||
933f08494c | |||
21f8eab432 | |||
6ddb8da07f | |||
edf456c59f | |||
42efced1eb | |||
c376e34b2b | |||
f579ec6e48 | |||
fd20e66f1f | |||
5d69b79232 | |||
2edd68d1bd | |||
7ffa7667b6 | |||
93d89e07ca | |||
17dcba4b90 | |||
39d2518fdd | |||
a365110054 |
@ -18,8 +18,11 @@ add_subdirectory(softfloat)
|
||||
set(LIB_SOURCES
|
||||
src/iss/plugin/instruction_count.cpp
|
||||
src/iss/arch/tgc5c.cpp
|
||||
src/iss/mem/memory_if.cpp
|
||||
src/vm/interp/vm_tgc5c.cpp
|
||||
src/vm/fp_functions.cpp
|
||||
src/vm/vector_functions.cpp
|
||||
src/iss/debugger/csr_names.cpp
|
||||
src/iss/semihosting/semihosting.cpp
|
||||
)
|
||||
|
||||
@ -108,16 +111,6 @@ if(TARGET yaml-cpp::yaml-cpp)
|
||||
target_link_libraries(${PROJECT_NAME} PUBLIC yaml-cpp::yaml-cpp)
|
||||
endif()
|
||||
|
||||
if(WITH_LLVM)
|
||||
find_package(LLVM)
|
||||
target_compile_definitions(${PROJECT_NAME} PUBLIC ${LLVM_DEFINITIONS})
|
||||
target_include_directories(${PROJECT_NAME} PUBLIC ${LLVM_INCLUDE_DIRS})
|
||||
|
||||
if(BUILD_SHARED_LIBS)
|
||||
target_link_libraries(${PROJECT_NAME} PUBLIC ${LLVM_LIBRARIES})
|
||||
endif()
|
||||
endif()
|
||||
|
||||
set_target_properties(${PROJECT_NAME} PROPERTIES
|
||||
VERSION ${PROJECT_VERSION}
|
||||
FRAMEWORK FALSE
|
||||
@ -261,3 +254,9 @@ if(TARGET scc-sysc)
|
||||
INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} # headers
|
||||
)
|
||||
endif()
|
||||
|
||||
project(elfio-test)
|
||||
find_package(Boost COMPONENTS program_options thread REQUIRED)
|
||||
|
||||
add_executable(${PROJECT_NAME} src/elfio.cpp)
|
||||
target_link_libraries(${PROJECT_NAME} PUBLIC elfio::elfio)
|
||||
|
@ -20,7 +20,7 @@ RVI:
|
||||
mask: 0b00000000000000000000000001111111
|
||||
size: 32
|
||||
branch: true
|
||||
delay: 1
|
||||
delay: [1,1]
|
||||
JALR:
|
||||
index: 3
|
||||
encoding: 0b00000000000000000000000001100111
|
||||
|
@ -30,11 +30,21 @@
|
||||
*
|
||||
*******************************************************************************/
|
||||
<%
|
||||
def nativeTypeSize(int size){
|
||||
if(size<=8) return 8; else if(size<=16) return 16; else if(size<=32) return 32; else return 64;
|
||||
def nativeSize(int size){
|
||||
if(size<=8) return 8;
|
||||
if(size<=16) return 16;
|
||||
if(size<=32) return 32;
|
||||
if(size<=64) return 64;
|
||||
if(size<=128) return 128;
|
||||
if(size<=256) return 256;
|
||||
if(size<=512) return 512;
|
||||
if(size<=1024) return 1024;
|
||||
if(size<=2048) return 2048;
|
||||
if(size<=4096) return 4096;
|
||||
throw new IllegalArgumentException("Unsupported size in nativeSize in CORENAME.h.gtl");
|
||||
}
|
||||
def getRegisterSizes(){
|
||||
def regs = registers.collect{nativeTypeSize(it.size)}
|
||||
def regs = registers.collect{nativeSize(it.size)}
|
||||
regs+=[32,32, 64, 64, 64, 32, 32] // append TRAP_STATE, PENDING_TRAP, ICOUNT, CYCLE, INSTRET, INSTRUCTION, LAST_BRANCH
|
||||
return regs
|
||||
}
|
||||
@ -47,13 +57,7 @@ def getRegisterOffsets(){
|
||||
}
|
||||
return offsets
|
||||
}
|
||||
def byteSize(int size){
|
||||
if(size<=8) return 8;
|
||||
if(size<=16) return 16;
|
||||
if(size<=32) return 32;
|
||||
if(size<=64) return 64;
|
||||
return 128;
|
||||
}
|
||||
|
||||
def getCString(def val){
|
||||
return val.toString()+'ULL'
|
||||
}
|
||||
@ -84,6 +88,8 @@ template <> struct traits<${coreDef.name.toLowerCase()}> {
|
||||
enum constants {${constants.collect{c -> c.name+"="+getCString(c.value)}.join(', ')}};
|
||||
|
||||
constexpr static unsigned FP_REGS_SIZE = ${constants.find {it.name=='FLEN'}?.value?:0};
|
||||
constexpr static unsigned V_REGS_SIZE = ${constants.find {it.name=='VLEN'}?.value?:0};
|
||||
|
||||
|
||||
enum reg_e {
|
||||
${registers.collect{it.name}.join(', ')}, NUM_REGS, TRAP_STATE=NUM_REGS, PENDING_TRAP, ICOUNT, CYCLE, INSTRET, INSTRUCTION, LAST_BRANCH
|
||||
@ -131,8 +137,6 @@ struct ${coreDef.name.toLowerCase()}: public arch_if {
|
||||
|
||||
uint8_t* get_regs_base_ptr() override;
|
||||
|
||||
inline uint64_t get_icount() { return reg.icount; }
|
||||
|
||||
inline bool should_stop() { return interrupt_sim; }
|
||||
|
||||
inline uint64_t stop_code() { return interrupt_sim; }
|
||||
@ -141,20 +145,20 @@ struct ${coreDef.name.toLowerCase()}: public arch_if {
|
||||
|
||||
virtual iss::sync_type needed_sync() const { return iss::NO_SYNC; }
|
||||
|
||||
inline uint32_t get_last_branch() { return reg.last_branch; }
|
||||
|
||||
|
||||
#pragma pack(push, 1)
|
||||
struct ${coreDef.name}_regs {<%
|
||||
registers.each { reg -> if(reg.size>0) {%>
|
||||
uint${byteSize(reg.size)}_t ${reg.name} = 0;<%
|
||||
registers.each { reg -> if(reg.size>64) {%>
|
||||
uint8_t ${reg.name}[${reg.size/8}] = {0};<%
|
||||
}else if(reg.size>0) {%>
|
||||
uint${nativeSize(reg.size)}_t ${reg.name} = 0;<%
|
||||
}}%>
|
||||
uint32_t trap_state = 0, pending_trap = 0;
|
||||
uint64_t icount = 0;
|
||||
uint64_t cycle = 0;
|
||||
uint64_t instret = 0;
|
||||
uint32_t instruction = 0;
|
||||
uint32_t last_branch = 0;
|
||||
uint64_t icount = 0; // counts number of instructions undisturbed
|
||||
uint64_t cycle = 0; // counts number of cycles, in functional mode equals icount
|
||||
uint64_t instret = 0; // counts number of instructions, can be reset via CSR write
|
||||
uint32_t instruction = 0; // holds op code of currently executed instruction
|
||||
uint32_t last_branch = 0; // indicates if last branch was taken
|
||||
} reg;
|
||||
#pragma pack(pop)
|
||||
std::array<address_type, 4> addr_mode;
|
||||
@ -168,6 +172,31 @@ if(fcsr != null) {%>
|
||||
<%} else { %>
|
||||
uint32_t get_fcsr(){return 0;}
|
||||
void set_fcsr(uint32_t val){}
|
||||
<%}
|
||||
def vstart = registers.find {it.name=='vstart'}
|
||||
def vl = registers.find {it.name=='vl'}
|
||||
def vtype = registers.find {it.name=='vtype'}
|
||||
def vxsat = registers.find {it.name=='vxsat'}
|
||||
def vxrm = registers.find {it.name=='vxrm'}
|
||||
|
||||
if(vtype != null) {%>
|
||||
uint${vstart.size}_t get_vstart(){return reg.vstart;}
|
||||
void set_vstart(uint${vstart.size}_t val){reg.vstart = val;}
|
||||
uint${vl.size}_t get_vl(){return reg.vl;}
|
||||
uint${vtype.size}_t get_vtype(){return reg.vtype;}
|
||||
uint${vxsat.size}_t get_vxsat(){return reg.vxsat;}
|
||||
void set_vxsat(uint${vxsat.size}_t val){reg.vxsat = val;}
|
||||
uint${vxrm.size}_t get_vxrm(){return reg.vxrm;}
|
||||
void set_vxrm(uint${vxrm.size}_t val){reg.vxrm = val;}
|
||||
<%} else { %>
|
||||
uint32_t get_vstart(){return 0;}
|
||||
void set_vstart(uint32_t val){}
|
||||
uint32_t get_vl(){return 0;}
|
||||
uint32_t get_vtype(){return 0;}
|
||||
uint32_t get_vxsat(){return 0;}
|
||||
void set_vxsat(uint32_t val){}
|
||||
uint32_t get_vxrm(){return 0;}
|
||||
void set_vxrm(uint32_t val){}
|
||||
<%}%>
|
||||
};
|
||||
|
||||
|
@ -45,17 +45,17 @@ namespace interp {
|
||||
using namespace sysc;
|
||||
volatile std::array<bool, ${array_count}> ${coreDef.name.toLowerCase()}_init = {
|
||||
iss_factory::instance().register_creator("${coreDef.name.toLowerCase()}|m_p|interp", [](unsigned gdb_port, void* data) -> iss_factory::base_t {
|
||||
auto* cc = reinterpret_cast<sysc::tgfs::core_complex*>(data);
|
||||
auto* cc = reinterpret_cast<sysc::tgfs::core_complex_if*>(data);
|
||||
auto* cpu = new sc_core_adapter<arch::riscv_hart_m_p<arch::${coreDef.name.toLowerCase()}>>(cc);
|
||||
return {sysc::sc_cpu_ptr{cpu}, vm_ptr{create(static_cast<arch::${coreDef.name.toLowerCase()}*>(cpu), gdb_port)}};
|
||||
}),
|
||||
iss_factory::instance().register_creator("${coreDef.name.toLowerCase()}|mu_p|interp", [](unsigned gdb_port, void* data) -> iss_factory::base_t {
|
||||
auto* cc = reinterpret_cast<sysc::tgfs::core_complex*>(data);
|
||||
auto* cc = reinterpret_cast<sysc::tgfs::core_complex_if*>(data);
|
||||
auto* cpu = new sc_core_adapter<arch::riscv_hart_mu_p<arch::${coreDef.name.toLowerCase()}>>(cc);
|
||||
return {sysc::sc_cpu_ptr{cpu}, vm_ptr{create(static_cast<arch::${coreDef.name.toLowerCase()}*>(cpu), gdb_port)}};
|
||||
})<%if(coreDef.name.toLowerCase()=="tgc5d" || coreDef.name.toLowerCase()=="tgc5e") {%>,
|
||||
iss_factory::instance().register_creator("${coreDef.name.toLowerCase()}|mu_p_clic_pmp|interp", [](unsigned gdb_port, void* data) -> iss_factory::base_t {
|
||||
auto* cc = reinterpret_cast<sysc::tgfs::core_complex*>(data);
|
||||
auto* cc = reinterpret_cast<sysc::tgfs::core_complex_if*>(data);
|
||||
auto* cpu = new sc_core_adapter<arch::riscv_hart_mu_p<arch::${coreDef.name.toLowerCase()}, (iss::arch::features_e)(iss::arch::FEAT_PMP | iss::arch::FEAT_EXT_N | iss::arch::FEAT_CLIC)>>(cc);
|
||||
return {sysc::sc_cpu_ptr{cpu}, vm_ptr{create(static_cast<arch::${coreDef.name.toLowerCase()}*>(cpu), gdb_port)}};
|
||||
})<%}%>
|
||||
@ -66,17 +66,17 @@ namespace llvm {
|
||||
using namespace sysc;
|
||||
volatile std::array<bool, ${array_count}> ${coreDef.name.toLowerCase()}_init = {
|
||||
iss_factory::instance().register_creator("${coreDef.name.toLowerCase()}|m_p|llvm", [](unsigned gdb_port, void* data) -> iss_factory::base_t {
|
||||
auto* cc = reinterpret_cast<sysc::tgfs::core_complex*>(data);
|
||||
auto* cc = reinterpret_cast<sysc::tgfs::core_complex_if*>(data);
|
||||
auto* cpu = new sc_core_adapter<arch::riscv_hart_m_p<arch::${coreDef.name.toLowerCase()}>>(cc);
|
||||
return {sysc::sc_cpu_ptr{cpu}, vm_ptr{create(static_cast<arch::${coreDef.name.toLowerCase()}*>(cpu), gdb_port)}};
|
||||
}),
|
||||
iss_factory::instance().register_creator("${coreDef.name.toLowerCase()}|mu_p|llvm", [](unsigned gdb_port, void* data) -> iss_factory::base_t {
|
||||
auto* cc = reinterpret_cast<sysc::tgfs::core_complex*>(data);
|
||||
auto* cc = reinterpret_cast<sysc::tgfs::core_complex_if*>(data);
|
||||
auto* cpu = new sc_core_adapter<arch::riscv_hart_mu_p<arch::${coreDef.name.toLowerCase()}>>(cc);
|
||||
return {sysc::sc_cpu_ptr{cpu}, vm_ptr{create(static_cast<arch::${coreDef.name.toLowerCase()}*>(cpu), gdb_port)}};
|
||||
})<%if(coreDef.name.toLowerCase()=="tgc5d" || coreDef.name.toLowerCase()=="tgc5e") {%>,
|
||||
iss_factory::instance().register_creator("${coreDef.name.toLowerCase()}|mu_p_clic_pmp|llvm", [](unsigned gdb_port, void* data) -> iss_factory::base_t {
|
||||
auto* cc = reinterpret_cast<sysc::tgfs::core_complex*>(data);
|
||||
auto* cc = reinterpret_cast<sysc::tgfs::core_complex_if*>(data);
|
||||
auto* cpu = new sc_core_adapter<arch::riscv_hart_mu_p<arch::${coreDef.name.toLowerCase()}, (iss::arch::features_e)(iss::arch::FEAT_PMP | iss::arch::FEAT_EXT_N | iss::arch::FEAT_CLIC)>>(cc);
|
||||
return {sysc::sc_cpu_ptr{cpu}, vm_ptr{create(static_cast<arch::${coreDef.name.toLowerCase()}*>(cpu), gdb_port)}};
|
||||
})<%}%>
|
||||
@ -88,17 +88,17 @@ namespace tcc {
|
||||
using namespace sysc;
|
||||
volatile std::array<bool, ${array_count}> ${coreDef.name.toLowerCase()}_init = {
|
||||
iss_factory::instance().register_creator("${coreDef.name.toLowerCase()}|m_p|tcc", [](unsigned gdb_port, void* data) -> iss_factory::base_t {
|
||||
auto* cc = reinterpret_cast<sysc::tgfs::core_complex*>(data);
|
||||
auto* cc = reinterpret_cast<sysc::tgfs::core_complex_if*>(data);
|
||||
auto* cpu = new sc_core_adapter<arch::riscv_hart_m_p<arch::${coreDef.name.toLowerCase()}>>(cc);
|
||||
return {sysc::sc_cpu_ptr{cpu}, vm_ptr{create(static_cast<arch::${coreDef.name.toLowerCase()}*>(cpu), gdb_port)}};
|
||||
}),
|
||||
iss_factory::instance().register_creator("${coreDef.name.toLowerCase()}|mu_p|tcc", [](unsigned gdb_port, void* data) -> iss_factory::base_t {
|
||||
auto* cc = reinterpret_cast<sysc::tgfs::core_complex*>(data);
|
||||
auto* cc = reinterpret_cast<sysc::tgfs::core_complex_if*>(data);
|
||||
auto* cpu = new sc_core_adapter<arch::riscv_hart_mu_p<arch::${coreDef.name.toLowerCase()}>>(cc);
|
||||
return {sysc::sc_cpu_ptr{cpu}, vm_ptr{create(static_cast<arch::${coreDef.name.toLowerCase()}*>(cpu), gdb_port)}};
|
||||
})<%if(coreDef.name.toLowerCase()=="tgc5d" || coreDef.name.toLowerCase()=="tgc5e") {%>,
|
||||
iss_factory::instance().register_creator("${coreDef.name.toLowerCase()}|mu_p_clic_pmp|tcc", [](unsigned gdb_port, void* data) -> iss_factory::base_t {
|
||||
auto* cc = reinterpret_cast<sysc::tgfs::core_complex*>(data);
|
||||
auto* cc = reinterpret_cast<sysc::tgfs::core_complex_if*>(data);
|
||||
auto* cpu = new sc_core_adapter<arch::riscv_hart_mu_p<arch::${coreDef.name.toLowerCase()}, (iss::arch::features_e)(iss::arch::FEAT_PMP | iss::arch::FEAT_EXT_N | iss::arch::FEAT_CLIC)>>(cc);
|
||||
return {sysc::sc_cpu_ptr{cpu}, vm_ptr{create(static_cast<arch::${coreDef.name.toLowerCase()}*>(cpu), gdb_port)}};
|
||||
})<%}%>
|
||||
@ -110,17 +110,17 @@ namespace asmjit {
|
||||
using namespace sysc;
|
||||
volatile std::array<bool, ${array_count}> ${coreDef.name.toLowerCase()}_init = {
|
||||
iss_factory::instance().register_creator("${coreDef.name.toLowerCase()}|m_p|asmjit", [](unsigned gdb_port, void* data) -> iss_factory::base_t {
|
||||
auto* cc = reinterpret_cast<sysc::tgfs::core_complex*>(data);
|
||||
auto* cc = reinterpret_cast<sysc::tgfs::core_complex_if*>(data);
|
||||
auto* cpu = new sc_core_adapter<arch::riscv_hart_m_p<arch::${coreDef.name.toLowerCase()}>>(cc);
|
||||
return {sysc::sc_cpu_ptr{cpu}, vm_ptr{create(static_cast<arch::${coreDef.name.toLowerCase()}*>(cpu), gdb_port)}};
|
||||
}),
|
||||
iss_factory::instance().register_creator("${coreDef.name.toLowerCase()}|mu_p|asmjit", [](unsigned gdb_port, void* data) -> iss_factory::base_t {
|
||||
auto* cc = reinterpret_cast<sysc::tgfs::core_complex*>(data);
|
||||
auto* cc = reinterpret_cast<sysc::tgfs::core_complex_if*>(data);
|
||||
auto* cpu = new sc_core_adapter<arch::riscv_hart_mu_p<arch::${coreDef.name.toLowerCase()}>>(cc);
|
||||
return {sysc::sc_cpu_ptr{cpu}, vm_ptr{create(static_cast<arch::${coreDef.name.toLowerCase()}*>(cpu), gdb_port)}};
|
||||
})<%if(coreDef.name.toLowerCase()=="tgc5d" || coreDef.name.toLowerCase()=="tgc5e") {%>,
|
||||
iss_factory::instance().register_creator("${coreDef.name.toLowerCase()}|mu_p_clic_pmp|asmjit", [](unsigned gdb_port, void* data) -> iss_factory::base_t {
|
||||
auto* cc = reinterpret_cast<sysc::tgfs::core_complex*>(data);
|
||||
auto* cc = reinterpret_cast<sysc::tgfs::core_complex_if*>(data);
|
||||
auto* cpu = new sc_core_adapter<arch::riscv_hart_mu_p<arch::${coreDef.name.toLowerCase()}, (iss::arch::features_e)(iss::arch::FEAT_PMP | iss::arch::FEAT_EXT_N | iss::arch::FEAT_CLIC)>>(cc);
|
||||
return {sysc::sc_cpu_ptr{cpu}, vm_ptr{create(static_cast<arch::${coreDef.name.toLowerCase()}*>(cpu), gdb_port)}};
|
||||
})<%}%>
|
||||
|
@ -38,7 +38,13 @@
|
||||
#include <asmjit/asmjit.h>
|
||||
#include <util/logging.h>
|
||||
#include <iss/instruction_decoder.h>
|
||||
|
||||
<%def fcsr = registers.find {it.name=='FCSR'}
|
||||
if(fcsr != null) {%>
|
||||
#include <vm/fp_functions.h><%}
|
||||
def aes = functions.find { it.contains('aes') }
|
||||
if(aes != null) {%>
|
||||
#include <vm/aes_sbox.h>
|
||||
<%}%>
|
||||
#ifndef FMT_HEADER_ONLY
|
||||
#define FMT_HEADER_ONLY
|
||||
#endif
|
||||
@ -47,6 +53,22 @@
|
||||
#include <array>
|
||||
#include <iss/debugger/riscv_target_adapter.h>
|
||||
|
||||
#ifndef _MSC_VER
|
||||
using int128_t = __int128;
|
||||
using uint128_t = unsigned __int128;
|
||||
namespace std {
|
||||
template <> struct make_unsigned<__int128> { typedef unsigned __int128 type; };
|
||||
template <> class __make_unsigned_selector<__int128 unsigned, false, false> {
|
||||
public:
|
||||
typedef unsigned __int128 __type;
|
||||
};
|
||||
template <> struct is_signed<int128_t> { static constexpr bool value = true; };
|
||||
template <> struct is_signed<uint128_t> { static constexpr bool value = false; };
|
||||
template <> struct is_unsigned<int128_t> { static constexpr bool value = false; };
|
||||
template <> struct is_unsigned<uint128_t> { static constexpr bool value = true; };
|
||||
} // namespace std
|
||||
#endif
|
||||
|
||||
namespace iss {
|
||||
namespace asmjit {
|
||||
|
||||
@ -88,23 +110,24 @@ protected:
|
||||
using super::write_reg_to_mem;
|
||||
using super::gen_read_mem;
|
||||
using super::gen_write_mem;
|
||||
using super::gen_wait;
|
||||
using super::gen_leave;
|
||||
using super::gen_sync;
|
||||
|
||||
using this_class = vm_impl<ARCH>;
|
||||
using compile_func = continuation_e (this_class::*)(virt_addr_t&, code_word_t, jit_holder&);
|
||||
|
||||
continuation_e gen_single_inst_behavior(virt_addr_t&, unsigned int &, jit_holder&) override;
|
||||
continuation_e gen_single_inst_behavior(virt_addr_t&, jit_holder&) override;
|
||||
enum globals_e {TVAL = 0, GLOBALS_SIZE};
|
||||
void gen_block_prologue(jit_holder& jh) override;
|
||||
void gen_block_epilogue(jit_holder& jh) override;
|
||||
inline const char *name(size_t index){return traits::reg_aliases.at(index);}
|
||||
|
||||
<%if(fcsr != null) {%>
|
||||
inline const char *fname(size_t index){return index < 32?name(index+traits::F0):"illegal";}
|
||||
<%}%>
|
||||
void gen_instr_prologue(jit_holder& jh);
|
||||
void gen_instr_epilogue(jit_holder& jh);
|
||||
inline void gen_raise(jit_holder& jh, uint16_t trap_id, uint16_t cause);
|
||||
template <typename T, typename = std::enable_if_t<std::is_integral_v<T>>> void gen_set_tval(jit_holder& jh, T new_tval) ;
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type> void gen_set_tval(jit_holder& jh, T new_tval) ;
|
||||
void gen_set_tval(jit_holder& jh, x86_reg_t _new_tval) ;
|
||||
|
||||
template<unsigned W, typename U, typename S = typename std::make_signed<U>::type>
|
||||
@ -112,7 +135,15 @@ protected:
|
||||
auto mask = (1ULL<<W) - 1;
|
||||
auto sign_mask = 1ULL<<(W-1);
|
||||
return (from & mask) | ((from & sign_mask) ? ~mask : 0);
|
||||
}
|
||||
}
|
||||
inline void raise(uint16_t trap_id, uint16_t cause){
|
||||
auto trap_val = 0x80ULL << 24 | (cause << 16) | trap_id;
|
||||
this->core.reg.trap_state = trap_val;
|
||||
}
|
||||
|
||||
<%functions.each{ it.eachLine { %>
|
||||
${it}<%}
|
||||
}%>
|
||||
private:
|
||||
/****************************************************************************
|
||||
* start opcode definitions
|
||||
@ -160,7 +191,6 @@ private:
|
||||
mov(cc, jh.next_pc, pc.val);
|
||||
|
||||
gen_instr_prologue(jh);
|
||||
cc.comment("//behavior:");
|
||||
/*generate behavior*/
|
||||
<%instr.behavior.eachLine{%>${it}
|
||||
<%}%>
|
||||
@ -191,11 +221,10 @@ private:
|
||||
pc = pc + ((instr & 3) == 3 ? 4 : 2);
|
||||
mov(cc, jh.next_pc, pc.val);
|
||||
gen_instr_prologue(jh);
|
||||
cc.comment("//behavior:");
|
||||
gen_raise(jh, 0, 2);
|
||||
gen_sync(jh, POST_SYNC, instr_descr.size());
|
||||
gen_instr_epilogue(jh);
|
||||
return BRANCH;
|
||||
return ILLEGAL_INSTR;
|
||||
}
|
||||
};
|
||||
|
||||
@ -215,19 +244,16 @@ vm_impl<ARCH>::vm_impl(ARCH &core, unsigned core_id, unsigned cluster_id)
|
||||
}()) {}
|
||||
|
||||
template <typename ARCH>
|
||||
continuation_e vm_impl<ARCH>::gen_single_inst_behavior(virt_addr_t &pc, unsigned int &inst_cnt, jit_holder& jh) {
|
||||
continuation_e vm_impl<ARCH>::gen_single_inst_behavior(virt_addr_t &pc, jit_holder& jh) {
|
||||
enum {TRAP_ID=1<<16};
|
||||
code_word_t instr = 0;
|
||||
phys_addr_t paddr(pc);
|
||||
auto *const data = (uint8_t *)&instr;
|
||||
if(this->core.has_mmu())
|
||||
paddr = this->core.virt2phys(pc);
|
||||
auto res = this->core.read(paddr, 4, data);
|
||||
if (res != iss::Ok)
|
||||
throw trap_access(TRAP_ID, pc.val);
|
||||
return ILLEGAL_FETCH;
|
||||
if (instr == 0x0000006f || (instr&0xffff)==0xa001)
|
||||
throw simulation_stopped(0); // 'J 0' or 'C.J 0'
|
||||
++inst_cnt;
|
||||
return JUMP_TO_SELF;
|
||||
uint32_t inst_index = instr_decoder.decode_instr(instr);
|
||||
compile_func f = nullptr;
|
||||
if(inst_index < instr_descr.size())
|
||||
@ -240,23 +266,25 @@ template <typename ARCH>
|
||||
void vm_impl<ARCH>::gen_instr_prologue(jit_holder& jh) {
|
||||
auto& cc = jh.cc;
|
||||
|
||||
cc.comment("//gen_instr_prologue");
|
||||
|
||||
x86_reg_t current_trap_state = get_reg_for(cc, traits::TRAP_STATE);
|
||||
mov(cc, current_trap_state, get_ptr_for(jh, traits::TRAP_STATE));
|
||||
mov(cc, get_ptr_for(jh, traits::PENDING_TRAP), current_trap_state);
|
||||
cc.comment("//Instruction prologue end");
|
||||
|
||||
}
|
||||
template <typename ARCH>
|
||||
void vm_impl<ARCH>::gen_instr_epilogue(jit_holder& jh) {
|
||||
auto& cc = jh.cc;
|
||||
|
||||
cc.comment("//gen_instr_epilogue");
|
||||
cc.comment("//Instruction epilogue begin");
|
||||
x86_reg_t current_trap_state = get_reg_for(cc, traits::TRAP_STATE);
|
||||
mov(cc, current_trap_state, get_ptr_for(jh, traits::TRAP_STATE));
|
||||
cmp(cc, current_trap_state, 0);
|
||||
cc.jne(jh.trap_entry);
|
||||
cc.inc(get_ptr_for(jh, traits::ICOUNT));
|
||||
cc.inc(get_ptr_for(jh, traits::CYCLE));
|
||||
cc.comment("//Instruction epilogue end");
|
||||
|
||||
}
|
||||
template <typename ARCH>
|
||||
void vm_impl<ARCH>::gen_block_prologue(jit_holder& jh){
|
||||
@ -268,7 +296,7 @@ void vm_impl<ARCH>::gen_block_prologue(jit_holder& jh){
|
||||
template <typename ARCH>
|
||||
void vm_impl<ARCH>::gen_block_epilogue(jit_holder& jh){
|
||||
x86::Compiler& cc = jh.cc;
|
||||
cc.comment("//gen_block_epilogue");
|
||||
cc.comment("//block epilogue begin");
|
||||
cc.ret(jh.next_pc);
|
||||
|
||||
cc.bind(jh.trap_entry);
|
||||
@ -280,7 +308,6 @@ void vm_impl<ARCH>::gen_block_epilogue(jit_holder& jh){
|
||||
x86::Gp current_pc = get_reg_for_Gp(cc, traits::PC);
|
||||
mov(cc, current_pc, get_ptr_for(jh, traits::PC));
|
||||
|
||||
cc.comment("//enter trap call;");
|
||||
InvokeNode* call_enter_trap;
|
||||
cc.invoke(&call_enter_trap, &enter_trap, FuncSignature::build<uint64_t, void*, uint64_t, uint64_t, uint64_t>());
|
||||
call_enter_trap->setArg(0, jh.arch_if_ptr);
|
||||
@ -298,10 +325,10 @@ void vm_impl<ARCH>::gen_block_epilogue(jit_holder& jh){
|
||||
template <typename ARCH>
|
||||
inline void vm_impl<ARCH>::gen_raise(jit_holder& jh, uint16_t trap_id, uint16_t cause) {
|
||||
auto& cc = jh.cc;
|
||||
cc.comment("//gen_raise");
|
||||
auto tmp1 = get_reg_for(cc, traits::TRAP_STATE);
|
||||
mov(cc, tmp1, 0x80ULL << 24 | (cause << 16) | trap_id);
|
||||
mov(cc, get_ptr_for(jh, traits::TRAP_STATE), tmp1);
|
||||
cc.jmp(jh.trap_entry);
|
||||
}
|
||||
template <typename ARCH>
|
||||
template <typename T, typename>
|
||||
@ -310,8 +337,8 @@ void vm_impl<ARCH>::gen_set_tval(jit_holder& jh, T new_tval) {
|
||||
}
|
||||
template <typename ARCH>
|
||||
void vm_impl<ARCH>::gen_set_tval(jit_holder& jh, x86_reg_t _new_tval) {
|
||||
if(std::holds_alternative<x86::Gp>(_new_tval)) {
|
||||
x86::Gp new_tval = std::get<x86::Gp>(_new_tval);
|
||||
if(nonstd::holds_alternative<x86::Gp>(_new_tval)) {
|
||||
x86::Gp new_tval = nonstd::get<x86::Gp>(_new_tval);
|
||||
if(new_tval.size() < 8)
|
||||
new_tval = gen_ext_Gp(jh.cc, new_tval, 64, false);
|
||||
mov(jh.cc, jh.globals[TVAL], new_tval);
|
||||
|
@ -30,6 +30,9 @@
|
||||
*
|
||||
*******************************************************************************/
|
||||
<%
|
||||
def floating_point = registers.find {it.name=='FCSR'}
|
||||
def vector = registers.find {it.name=='vtype'}
|
||||
def aes = functions.find { it.contains('aes') }
|
||||
def nativeTypeSize(int size){
|
||||
if(size<=8) return 8; else if(size<=16) return 16; else if(size<=32) return 32; else return 64;
|
||||
}
|
||||
@ -41,7 +44,16 @@ def nativeTypeSize(int size){
|
||||
#include <iss/debugger/server.h>
|
||||
#include <iss/iss.h>
|
||||
#include <iss/interp/vm_base.h>
|
||||
<%
|
||||
if(floating_point != null) {%>
|
||||
#include <vm/fp_functions.h>
|
||||
<%}
|
||||
if(vector != null) {%>
|
||||
#include <vm/vector_functions.h>
|
||||
<%}
|
||||
if(aes != null) {%>
|
||||
#include <vm/aes_sbox.h>
|
||||
<%}%>
|
||||
#include <util/logging.h>
|
||||
#include <boost/coroutine2/all.hpp>
|
||||
#include <functional>
|
||||
@ -100,7 +112,50 @@ protected:
|
||||
using compile_ret_t = virt_addr_t;
|
||||
using compile_func = compile_ret_t (this_class::*)(virt_addr_t &pc, code_word_t instr);
|
||||
|
||||
inline const char *name(size_t index){return index<traits::reg_aliases.size()?traits::reg_aliases[index]:"illegal";}
|
||||
inline const char *name(size_t index){return traits::reg_aliases.at(index);}
|
||||
<%
|
||||
if(floating_point != null) {%>
|
||||
inline const char *fname(size_t index){return index < 32?name(index+traits::F0):"illegal";}
|
||||
<%}
|
||||
if(vector != null) {%>
|
||||
inline const char* vname(size_t index) { return index < 32 ? name(index + traits::V0) : "illegal"; }
|
||||
inline const char* sew_name(size_t bits) {
|
||||
switch(bits) {
|
||||
case 0b000:
|
||||
return "e8";
|
||||
case 0b001:
|
||||
return "e16";
|
||||
case 0b010:
|
||||
return "e32";
|
||||
case 0b011:
|
||||
return "e64";
|
||||
default:
|
||||
return "illegal";
|
||||
}
|
||||
}
|
||||
inline const char* lmul_name(size_t bits) {
|
||||
switch(bits) {
|
||||
case 0b101:
|
||||
return "mf8";
|
||||
case 0b110:
|
||||
return "mf4";
|
||||
case 0b111:
|
||||
return "mf2";
|
||||
case 0b000:
|
||||
return "m1";
|
||||
case 0b001:
|
||||
return "m2";
|
||||
case 0b010:
|
||||
return "m4";
|
||||
case 0b011:
|
||||
return "m8";
|
||||
default:
|
||||
return "illegal";
|
||||
}
|
||||
}
|
||||
inline const char* ma_name(bool ma) { return ma ? "ma" : "mu"; }
|
||||
inline const char* ta_name(bool ta) { return ta ? "ta" : "tu"; }
|
||||
<%}%>
|
||||
|
||||
virt_addr_t execute_inst(finish_cond_e cond, virt_addr_t start, uint64_t icount_limit) override;
|
||||
|
||||
@ -122,7 +177,806 @@ protected:
|
||||
inline void set_tval(uint64_t new_tval){
|
||||
tval = new_tval;
|
||||
}
|
||||
<%if(vector != null) {
|
||||
def xlen = constants.find { it.name == 'XLEN' }?.value ?: 0
|
||||
def vlen = constants.find { it.name == 'VLEN' }?.value ?: 0 %>
|
||||
inline void lower(){
|
||||
this->core.reg.trap_state = 0;
|
||||
}
|
||||
uint64_t vlseg(uint8_t* V, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, uint8_t vd, uint64_t rs1_val, uint8_t width_val, uint8_t segment_size){
|
||||
switch(width_val){
|
||||
case 0b000:
|
||||
return softvector::vector_load_store<${vlen}, uint8_t>(this->get_arch(), softvector::softvec_read, V, vl, vstart, vtype, vm, vd, rs1_val, segment_size);
|
||||
case 0b101:
|
||||
return softvector::vector_load_store<${vlen}, uint16_t>(this->get_arch(), softvector::softvec_read, V, vl, vstart, vtype, vm, vd, rs1_val, segment_size);
|
||||
case 0b110:
|
||||
return softvector::vector_load_store<${vlen}, uint32_t>(this->get_arch(), softvector::softvec_read, V, vl, vstart, vtype, vm, vd, rs1_val, segment_size);
|
||||
case 0b111:
|
||||
return softvector::vector_load_store<${vlen}, uint64_t>(this->get_arch(), softvector::softvec_read, V, vl, vstart, vtype, vm, vd, rs1_val, segment_size);
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported width bit value");
|
||||
}
|
||||
}
|
||||
uint64_t vsseg(uint8_t* V, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, uint8_t vd, uint64_t rs1_val, uint8_t width_val, uint8_t segment_size){
|
||||
switch(width_val){
|
||||
case 0b000:
|
||||
return softvector::vector_load_store<${vlen}, uint8_t>(this->get_arch(), softvector::softvec_write, V, vl, vstart, vtype, vm, vd, rs1_val, segment_size);
|
||||
case 0b101:
|
||||
return softvector::vector_load_store<${vlen}, uint16_t>(this->get_arch(), softvector::softvec_write, V, vl, vstart, vtype, vm, vd, rs1_val, segment_size);
|
||||
case 0b110:
|
||||
return softvector::vector_load_store<${vlen}, uint32_t>(this->get_arch(), softvector::softvec_write, V, vl, vstart, vtype, vm, vd, rs1_val, segment_size);
|
||||
case 0b111:
|
||||
return softvector::vector_load_store<${vlen}, uint64_t>(this->get_arch(), softvector::softvec_write, V, vl, vstart, vtype, vm, vd, rs1_val, segment_size);
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported width bit value");
|
||||
}
|
||||
}
|
||||
uint64_t vlsseg(uint8_t* V, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, uint8_t vd, uint64_t rs1_val, uint8_t width_val, uint8_t segment_size, int64_t stride){
|
||||
switch(width_val){
|
||||
case 0b000:
|
||||
return softvector::vector_load_store<${vlen}, uint8_t>(this->get_arch(), softvector::softvec_read, V, vl, vstart, vtype, vm, vd, rs1_val, segment_size, stride, true);
|
||||
case 0b101:
|
||||
return softvector::vector_load_store<${vlen}, uint16_t>(this->get_arch(), softvector::softvec_read, V, vl, vstart, vtype, vm, vd, rs1_val, segment_size, stride, true);
|
||||
case 0b110:
|
||||
return softvector::vector_load_store<${vlen}, uint32_t>(this->get_arch(), softvector::softvec_read, V, vl, vstart, vtype, vm, vd, rs1_val, segment_size, stride, true);
|
||||
case 0b111:
|
||||
return softvector::vector_load_store<${vlen}, uint64_t>(this->get_arch(), softvector::softvec_read, V, vl, vstart, vtype, vm, vd, rs1_val, segment_size, stride, true);
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported width bit value");
|
||||
}
|
||||
}
|
||||
uint64_t vssseg(uint8_t* V, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, uint8_t vd, uint64_t rs1_val, uint8_t width_val, uint8_t segment_size, int64_t stride){
|
||||
switch(width_val){
|
||||
case 0b000:
|
||||
return softvector::vector_load_store<${vlen}, uint8_t>(this->get_arch(), softvector::softvec_write, V, vl, vstart, vtype, vm, vd, rs1_val, segment_size, stride, true);
|
||||
case 0b101:
|
||||
return softvector::vector_load_store<${vlen}, uint16_t>(this->get_arch(), softvector::softvec_write, V, vl, vstart, vtype, vm, vd, rs1_val, segment_size, stride, true);
|
||||
case 0b110:
|
||||
return softvector::vector_load_store<${vlen}, uint32_t>(this->get_arch(), softvector::softvec_write, V, vl, vstart, vtype, vm, vd, rs1_val, segment_size, stride, true);
|
||||
case 0b111:
|
||||
return softvector::vector_load_store<${vlen}, uint64_t>(this->get_arch(), softvector::softvec_write, V, vl, vstart, vtype, vm, vd, rs1_val, segment_size, stride, true);
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported width bit value");
|
||||
}
|
||||
}
|
||||
|
||||
using indexed_load_store_t = std::function<uint64_t(void*, std::function<bool(void*, uint64_t, uint64_t, uint8_t*)>, uint8_t*, uint64_t, uint64_t, softvector::vtype_t, bool, uint8_t, uint64_t, uint8_t, uint8_t)>;
|
||||
template <typename T1, typename T2> indexed_load_store_t getFunction() {
|
||||
return [this](void* core, std::function<uint64_t(void*, uint64_t, uint64_t, uint8_t*)> load_store_fn, uint8_t* V, uint64_t vl,
|
||||
uint64_t vstart, softvector::vtype_t vtype, bool vm, uint8_t vd, uint64_t rs1, uint8_t vs2, uint8_t segment_size) {
|
||||
return softvector::vector_load_store_index<${xlen}, ${vlen}, T1, T2>(core, load_store_fn, V, vl, vstart, vtype, vm, vd, rs1, vs2, segment_size);
|
||||
};
|
||||
}
|
||||
|
||||
const std::array<std::array<indexed_load_store_t, 4>, 4> functionTable = {{
|
||||
{getFunction<uint8_t, uint8_t>(), getFunction<uint8_t, uint16_t>(), getFunction<uint8_t, uint32_t>(), getFunction<uint8_t, uint64_t>()},
|
||||
{getFunction<uint16_t, uint8_t>(), getFunction<uint16_t, uint16_t>(), getFunction<uint16_t, uint32_t>(), getFunction<uint16_t, uint64_t>()},
|
||||
{getFunction<uint32_t, uint8_t>(), getFunction<uint32_t, uint16_t>(), getFunction<uint32_t, uint32_t>(), getFunction<uint32_t, uint64_t>()},
|
||||
{getFunction<uint64_t, uint8_t>(), getFunction<uint64_t, uint16_t>(), getFunction<uint64_t, uint32_t>(), getFunction<uint64_t, uint64_t>()}
|
||||
}};
|
||||
const size_t map_index_size[9] = { 0, 0, 1, 0, 2, 0, 0, 0, 3 }; // translate number of bytes to index in functionTable
|
||||
uint64_t vlxseg(uint8_t* V, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, uint8_t vd, uint64_t rs1_val, uint8_t vs2, uint8_t segment_size, uint8_t index_byte_size, uint8_t data_byte_size, bool ordered){
|
||||
return functionTable[map_index_size[index_byte_size]][data_byte_size](this->get_arch(), softvector::softvec_read, V, vl, vstart, vtype, vm, vd, rs1_val, vs2, segment_size);
|
||||
}
|
||||
uint64_t vsxseg(uint8_t* V, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, uint8_t vs3, uint64_t rs1_val, uint8_t vs2, uint8_t segment_size, uint8_t index_byte_size, uint8_t data_byte_size, bool ordered){
|
||||
return functionTable[map_index_size[index_byte_size]][data_byte_size](this->get_arch(), softvector::softvec_write, V, vl, vstart, vtype, vm, vs3, rs1_val, vs2, segment_size);
|
||||
}
|
||||
void vector_vector_op(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, uint8_t vd, uint8_t vs2, uint8_t vs1, uint8_t sew_val){
|
||||
switch(sew_val){
|
||||
case 0b000:
|
||||
return softvector::vector_vector_op<${vlen}, uint8_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1);
|
||||
case 0b001:
|
||||
return softvector::vector_vector_op<${vlen}, uint16_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1);
|
||||
case 0b010:
|
||||
return softvector::vector_vector_op<${vlen}, uint32_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1);
|
||||
case 0b011:
|
||||
return softvector::vector_vector_op<${vlen}, uint64_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1);
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
}
|
||||
}
|
||||
void vector_imm_op(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, uint8_t vd, uint8_t vs2, int64_t imm, uint8_t sew_val){
|
||||
switch(sew_val){
|
||||
case 0b000:
|
||||
return softvector::vector_imm_op<${vlen}, uint8_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, imm);
|
||||
case 0b001:
|
||||
return softvector::vector_imm_op<${vlen}, uint16_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, imm);
|
||||
case 0b010:
|
||||
return softvector::vector_imm_op<${vlen}, uint32_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, imm);
|
||||
case 0b011:
|
||||
return softvector::vector_imm_op<${vlen}, uint64_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, imm);
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
}
|
||||
}
|
||||
void vector_vector_wv(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, uint8_t vd, uint8_t vs2, uint8_t vs1, uint8_t sew_val){
|
||||
switch(sew_val){
|
||||
case 0b000:
|
||||
return softvector::vector_vector_op<${vlen}, uint16_t, uint8_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1);
|
||||
case 0b001:
|
||||
return softvector::vector_vector_op<${vlen}, uint32_t, uint16_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1);
|
||||
case 0b010:
|
||||
return softvector::vector_vector_op<${vlen}, uint64_t, uint32_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1);
|
||||
case 0b011: // would widen to 128 bits
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
}
|
||||
}
|
||||
void vector_imm_wv(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, uint8_t vd, uint8_t vs2, int64_t imm, uint8_t sew_val){
|
||||
switch(sew_val){
|
||||
case 0b000:
|
||||
return softvector::vector_imm_op<${vlen}, uint16_t, uint8_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, imm);
|
||||
case 0b001:
|
||||
return softvector::vector_imm_op<${vlen}, uint32_t, uint16_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, imm);
|
||||
case 0b010:
|
||||
return softvector::vector_imm_op<${vlen}, uint64_t, uint32_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, imm);
|
||||
case 0b011: // would widen to 128 bits
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
}
|
||||
}
|
||||
void vector_vector_ww(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, uint8_t vd, uint8_t vs2, uint8_t vs1, uint8_t sew_val){
|
||||
switch(sew_val){
|
||||
case 0b000:
|
||||
return softvector::vector_vector_op<${vlen}, uint16_t, uint16_t, uint8_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1);
|
||||
case 0b001:
|
||||
return softvector::vector_vector_op<${vlen}, uint32_t, uint32_t, uint16_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1);
|
||||
case 0b010:
|
||||
return softvector::vector_vector_op<${vlen}, uint64_t, uint64_t, uint32_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1);
|
||||
case 0b011: // would widen to 128 bits
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
}
|
||||
}
|
||||
void vector_imm_ww(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, uint8_t vd, uint8_t vs2, int64_t imm, uint8_t sew_val){
|
||||
switch(sew_val){
|
||||
case 0b000:
|
||||
return softvector::vector_imm_op<${vlen}, uint16_t, uint16_t, uint8_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, imm);
|
||||
case 0b001:
|
||||
return softvector::vector_imm_op<${vlen}, uint32_t, uint32_t, uint16_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, imm);
|
||||
case 0b010:
|
||||
return softvector::vector_imm_op<${vlen}, uint64_t, uint64_t, uint32_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, imm);
|
||||
case 0b011: // would widen to 128 bits
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
}
|
||||
}
|
||||
void vector_extend(uint8_t* V, uint8_t unary_op, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, uint8_t vd, uint8_t vs2, uint8_t target_sew_pow, uint8_t frac_pow){
|
||||
switch(target_sew_pow){
|
||||
case 4: // uint16_t target
|
||||
if(frac_pow != 1) throw new std::runtime_error("Unsupported frac_pow");
|
||||
return softvector::vector_unary_op<${vlen}, uint16_t, uint8_t>(V, unary_op, vl, vstart, vtype, vm, vd, vs2);
|
||||
case 5: // uint32_t target
|
||||
switch(frac_pow){
|
||||
case 1:
|
||||
return softvector::vector_unary_op<${vlen}, uint32_t, uint16_t>(V, unary_op, vl, vstart, vtype, vm, vd, vs2);
|
||||
case 2:
|
||||
return softvector::vector_unary_op<${vlen}, uint32_t, uint8_t>(V, unary_op, vl, vstart, vtype, vm, vd, vs2);
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported frac_pow");
|
||||
}
|
||||
case 6: // uint64_t target
|
||||
switch(frac_pow){
|
||||
case 1:
|
||||
return softvector::vector_unary_op<${vlen}, uint64_t, uint32_t>(V, unary_op, vl, vstart, vtype, vm, vd, vs2);
|
||||
case 2:
|
||||
return softvector::vector_unary_op<${vlen}, uint64_t, uint16_t>(V, unary_op, vl, vstart, vtype, vm, vd, vs2);
|
||||
case 3:
|
||||
return softvector::vector_unary_op<${vlen}, uint64_t, uint8_t>(V, unary_op, vl, vstart, vtype, vm, vd, vs2);
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported frac_pow");
|
||||
}
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported target_sew_pow");
|
||||
}
|
||||
}
|
||||
void vector_vector_carry(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, uint8_t vd, uint8_t vs2, uint8_t vs1, uint8_t sew_val, int8_t carry){
|
||||
switch(sew_val){
|
||||
case 0b000:
|
||||
return softvector::vector_vector_carry<${vlen}, uint8_t>(V, funct6, funct3, vl, vstart, vtype, vd, vs2, vs1, carry);
|
||||
case 0b001:
|
||||
return softvector::vector_vector_carry<${vlen}, uint16_t>(V, funct6, funct3, vl, vstart, vtype, vd, vs2, vs1, carry);
|
||||
case 0b010:
|
||||
return softvector::vector_vector_carry<${vlen}, uint32_t>(V, funct6, funct3, vl, vstart, vtype, vd, vs2, vs1, carry);
|
||||
case 0b011:
|
||||
return softvector::vector_vector_carry<${vlen}, uint64_t>(V, funct6, funct3, vl, vstart, vtype, vd, vs2, vs1, carry);
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
} }
|
||||
void vector_imm_carry(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, uint8_t vd, uint8_t vs2, int64_t imm, uint8_t sew_val, int8_t carry){
|
||||
switch(sew_val){
|
||||
case 0b000:
|
||||
return softvector::vector_imm_carry<${vlen}, uint8_t>(V, funct6, funct3, vl, vstart, vtype, vd, vs2, imm, carry);
|
||||
case 0b001:
|
||||
return softvector::vector_imm_carry<${vlen}, uint16_t>(V, funct6, funct3, vl, vstart, vtype, vd, vs2, imm, carry);
|
||||
case 0b010:
|
||||
return softvector::vector_imm_carry<${vlen}, uint32_t>(V, funct6, funct3, vl, vstart, vtype, vd, vs2, imm, carry);
|
||||
case 0b011:
|
||||
return softvector::vector_imm_carry<${vlen}, uint64_t>(V, funct6, funct3, vl, vstart, vtype, vd, vs2, imm, carry);
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
}
|
||||
}
|
||||
void carry_vector_vector_op(uint8_t* V, unsigned funct6, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, unsigned vd, unsigned vs2, unsigned vs1, uint8_t sew_val){
|
||||
switch(sew_val){
|
||||
case 0b000:
|
||||
return softvector::carry_vector_vector_op<${vlen}, uint8_t>(V, funct6, vl, vstart, vtype, vm, vd, vs2, vs1);
|
||||
case 0b001:
|
||||
return softvector::carry_vector_vector_op<${vlen}, uint16_t>(V, funct6, vl, vstart, vtype, vm, vd, vs2, vs1);
|
||||
case 0b010:
|
||||
return softvector::carry_vector_vector_op<${vlen}, uint32_t>(V, funct6, vl, vstart, vtype, vm, vd, vs2, vs1);
|
||||
case 0b011:
|
||||
return softvector::carry_vector_vector_op<${vlen}, uint64_t>(V, funct6, vl, vstart, vtype, vm, vd, vs2, vs1);
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
}
|
||||
}
|
||||
void carry_vector_imm_op(uint8_t* V, unsigned funct6, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, unsigned vd, unsigned vs2, int64_t imm, uint8_t sew_val){
|
||||
switch(sew_val){
|
||||
case 0b000:
|
||||
return softvector::carry_vector_imm_op<${vlen}, uint8_t>(V, funct6, vl, vstart, vtype, vm, vd, vs2, imm);
|
||||
case 0b001:
|
||||
return softvector::carry_vector_imm_op<${vlen}, uint16_t>(V, funct6, vl, vstart, vtype, vm, vd, vs2, imm);
|
||||
case 0b010:
|
||||
return softvector::carry_vector_imm_op<${vlen}, uint32_t>(V, funct6, vl, vstart, vtype, vm, vd, vs2, imm);
|
||||
case 0b011:
|
||||
return softvector::carry_vector_imm_op<${vlen}, uint64_t>(V, funct6, vl, vstart, vtype, vm, vd, vs2, imm);
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
}
|
||||
}
|
||||
void mask_vector_vector_op(uint8_t* V, unsigned funct6, uint8_t funct3, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, unsigned vd, unsigned vs2, unsigned vs1, uint8_t sew_val){
|
||||
switch(sew_val){
|
||||
case 0b000:
|
||||
return softvector::mask_vector_vector_op<${vlen}, uint8_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1);
|
||||
case 0b001:
|
||||
return softvector::mask_vector_vector_op<${vlen}, uint16_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1);
|
||||
case 0b010:
|
||||
return softvector::mask_vector_vector_op<${vlen}, uint32_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1);
|
||||
case 0b011:
|
||||
return softvector::mask_vector_vector_op<${vlen}, uint64_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1);
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
}
|
||||
}
|
||||
void mask_vector_imm_op(uint8_t* V, unsigned funct6, uint8_t funct3, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, unsigned vd, unsigned vs2, int64_t imm, uint8_t sew_val){
|
||||
switch(sew_val){
|
||||
case 0b000:
|
||||
return softvector::mask_vector_imm_op<${vlen}, uint8_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, imm);
|
||||
case 0b001:
|
||||
return softvector::mask_vector_imm_op<${vlen}, uint16_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, imm);
|
||||
case 0b010:
|
||||
return softvector::mask_vector_imm_op<${vlen}, uint32_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, imm);
|
||||
case 0b011:
|
||||
return softvector::mask_vector_imm_op<${vlen}, uint64_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, imm);
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
}
|
||||
}
|
||||
void vector_vector_vw(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, uint8_t vd, uint8_t vs2, uint8_t vs1, uint8_t sew_val){
|
||||
switch(sew_val){
|
||||
case 0b000:
|
||||
return softvector::vector_vector_op<${vlen}, uint8_t, uint16_t, uint8_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1);
|
||||
case 0b001:
|
||||
return softvector::vector_vector_op<${vlen}, uint16_t, uint32_t, uint16_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1);
|
||||
case 0b010:
|
||||
return softvector::vector_vector_op<${vlen}, uint32_t, uint64_t, uint32_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1);
|
||||
case 0b011: // would require 128 bits vs2 value
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
}
|
||||
}
|
||||
void vector_imm_vw(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, uint8_t vd, uint8_t vs2, int64_t imm, uint8_t sew_val){
|
||||
switch(sew_val){
|
||||
case 0b000:
|
||||
return softvector::vector_imm_op<${vlen}, uint8_t, uint16_t, uint8_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, imm);
|
||||
case 0b001:
|
||||
return softvector::vector_imm_op<${vlen}, uint16_t, uint32_t, uint16_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, imm);
|
||||
case 0b010:
|
||||
return softvector::vector_imm_op<${vlen}, uint32_t, uint64_t, uint32_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, imm);
|
||||
case 0b011: // would require 128 bits vs2 value
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
}
|
||||
}
|
||||
void vector_vector_merge(uint8_t* V, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, uint8_t vd, uint8_t vs2, uint8_t vs1, uint8_t sew_val){
|
||||
switch(sew_val){
|
||||
case 0b000:
|
||||
return softvector::vector_vector_merge<${vlen}, uint8_t>(V, vl, vstart, vtype, vm, vd, vs2, vs1);
|
||||
case 0b001:
|
||||
return softvector::vector_vector_merge<${vlen}, uint16_t>(V, vl, vstart, vtype, vm, vd, vs2, vs1);
|
||||
case 0b010:
|
||||
return softvector::vector_vector_merge<${vlen}, uint32_t>(V, vl, vstart, vtype, vm, vd, vs2, vs1);
|
||||
case 0b011:
|
||||
return softvector::vector_vector_merge<${vlen}, uint64_t>(V, vl, vstart, vtype, vm, vd, vs2, vs1);
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
}
|
||||
}
|
||||
void vector_imm_merge(uint8_t* V, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, uint8_t vd, uint8_t vs2, int64_t imm, uint8_t sew_val){
|
||||
switch(sew_val){
|
||||
case 0b000:
|
||||
return softvector::vector_imm_merge<${vlen}, uint8_t>(V, vl, vstart, vtype, vm, vd, vs2, imm);
|
||||
case 0b001:
|
||||
return softvector::vector_imm_merge<${vlen}, uint16_t>(V, vl, vstart, vtype, vm, vd, vs2, imm);
|
||||
case 0b010:
|
||||
return softvector::vector_imm_merge<${vlen}, uint32_t>(V, vl, vstart, vtype, vm, vd, vs2, imm);
|
||||
case 0b011:
|
||||
return softvector::vector_imm_merge<${vlen}, uint64_t>(V, vl, vstart, vtype, vm, vd, vs2, imm);
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
}
|
||||
}
|
||||
bool sat_vector_vector_op(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, uint64_t vxrm, bool vm, uint8_t vd, uint8_t vs2, uint8_t vs1, uint8_t sew_val){
|
||||
switch(sew_val){
|
||||
case 0b000:
|
||||
return softvector::sat_vector_vector_op<${vlen}, uint8_t>(V, funct6, funct3, vl, vstart, vtype, vxrm, vm, vd, vs2, vs1);
|
||||
case 0b001:
|
||||
return softvector::sat_vector_vector_op<${vlen}, uint16_t>(V, funct6, funct3, vl, vstart, vtype, vxrm, vm, vd, vs2, vs1);
|
||||
case 0b010:
|
||||
return softvector::sat_vector_vector_op<${vlen}, uint32_t>(V, funct6, funct3, vl, vstart, vtype, vxrm, vm, vd, vs2, vs1);
|
||||
case 0b011:
|
||||
return softvector::sat_vector_vector_op<${vlen}, uint64_t>(V, funct6, funct3, vl, vstart, vtype, vxrm, vm, vd, vs2, vs1);
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
}
|
||||
}
|
||||
bool sat_vector_imm_op(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, uint64_t vxrm, bool vm, uint8_t vd, uint8_t vs2, int64_t imm, uint8_t sew_val){
|
||||
switch(sew_val){
|
||||
case 0b000:
|
||||
return softvector::sat_vector_imm_op<${vlen}, uint8_t>(V, funct6, funct3, vl, vstart, vtype, vxrm, vm, vd, vs2, imm);
|
||||
case 0b001:
|
||||
return softvector::sat_vector_imm_op<${vlen}, uint16_t>(V, funct6, funct3, vl, vstart, vtype, vxrm, vm, vd, vs2, imm);
|
||||
case 0b010:
|
||||
return softvector::sat_vector_imm_op<${vlen}, uint32_t>(V, funct6, funct3, vl, vstart, vtype, vxrm, vm, vd, vs2, imm);
|
||||
case 0b011:
|
||||
return softvector::sat_vector_imm_op<${vlen}, uint64_t>(V, funct6, funct3, vl, vstart, vtype, vxrm, vm, vd, vs2, imm);
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
}
|
||||
}
|
||||
bool sat_vector_vector_vw(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, uint64_t vxrm, bool vm, uint8_t vd, uint8_t vs2, uint8_t vs1, uint8_t sew_val){
|
||||
switch(sew_val){
|
||||
case 0b000:
|
||||
return softvector::sat_vector_vector_op<${vlen}, uint8_t, uint16_t>(V, funct6, funct3, vl, vstart, vtype, vxrm, vm, vd, vs2, vs1);
|
||||
case 0b001:
|
||||
return softvector::sat_vector_vector_op<${vlen}, uint16_t, uint32_t>(V, funct6, funct3, vl, vstart, vtype, vxrm, vm, vd, vs2, vs1);
|
||||
case 0b010:
|
||||
return softvector::sat_vector_vector_op<${vlen}, uint32_t, uint64_t>(V, funct6, funct3, vl, vstart, vtype, vxrm, vm, vd, vs2, vs1);
|
||||
case 0b011: // would require 128 bits vs2 value
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
}
|
||||
}
|
||||
bool sat_vector_imm_vw(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, uint64_t vxrm, bool vm, uint8_t vd, uint8_t vs2, int64_t imm, uint8_t sew_val){
|
||||
switch(sew_val){
|
||||
case 0b000:
|
||||
return softvector::sat_vector_imm_op<${vlen}, uint8_t, uint16_t>(V, funct6, funct3, vl, vstart, vtype, vxrm, vm, vd, vs2, imm);
|
||||
case 0b001:
|
||||
return softvector::sat_vector_imm_op<${vlen}, uint16_t, uint32_t>(V, funct6, funct3, vl, vstart, vtype, vxrm, vm, vd, vs2, imm);
|
||||
case 0b010:
|
||||
return softvector::sat_vector_imm_op<${vlen}, uint32_t, uint64_t>(V, funct6, funct3, vl, vstart, vtype, vxrm, vm, vd, vs2, imm);
|
||||
case 0b011: // would require 128 bits vs2 value
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
}
|
||||
}
|
||||
void vector_red_op(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, uint8_t vd, uint8_t vs2, uint8_t vs1, uint8_t sew_val){
|
||||
switch(sew_val){
|
||||
case 0b000:
|
||||
return softvector::vector_red_op<${vlen}, uint8_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1);
|
||||
case 0b001:
|
||||
return softvector::vector_red_op<${vlen}, uint16_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1);
|
||||
case 0b010:
|
||||
return softvector::vector_red_op<${vlen}, uint32_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1);
|
||||
case 0b011:
|
||||
return softvector::vector_red_op<${vlen}, uint64_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1);
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
}
|
||||
}
|
||||
void vector_red_wv(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, uint8_t vd, uint8_t vs2, uint8_t vs1, uint8_t sew_val){
|
||||
switch(sew_val){
|
||||
case 0b000:
|
||||
return softvector::vector_red_op<${vlen}, uint16_t, uint8_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1);
|
||||
case 0b001:
|
||||
return softvector::vector_red_op<${vlen}, uint32_t, uint16_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1);
|
||||
case 0b010:
|
||||
return softvector::vector_red_op<${vlen}, uint64_t, uint32_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1);
|
||||
case 0b011: // would require 128 bits vs2 value
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
}
|
||||
}
|
||||
void mask_mask_op(uint8_t* V, unsigned funct6, unsigned funct3, uint64_t vl, uint64_t vstart, unsigned vd, unsigned vs2, unsigned vs1){
|
||||
return softvector::mask_mask_op<${vlen}>(V, funct6, funct3, vl, vstart, vd, vs2, vs1);
|
||||
}
|
||||
uint64_t vcpop(uint8_t* V, uint64_t vl, uint64_t vstart, bool vm, unsigned vs2){
|
||||
return softvector::vcpop<${vlen}>(V, vl, vstart, vm, vs2);
|
||||
}
|
||||
int64_t vfirst(uint8_t* V, uint64_t vl, uint64_t vstart, bool vm, unsigned vs2){
|
||||
return softvector::vfirst<${vlen}>(V, vl, vstart, vm, vs2);
|
||||
}
|
||||
void mask_set_op(uint8_t* V, unsigned enc, uint64_t vl, uint64_t vstart, bool vm, unsigned vd, unsigned vs2){
|
||||
return softvector::mask_set_op<${vlen}>(V, enc, vl, vstart, vm, vd, vs2);
|
||||
}
|
||||
void viota(uint8_t* V, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, uint8_t vd, uint8_t vs2, uint8_t sew_val){
|
||||
switch(sew_val){
|
||||
case 0b000:
|
||||
return softvector::viota<${vlen}, uint8_t>(V, vl, vstart, vtype, vm, vd, vs2);
|
||||
case 0b001:
|
||||
return softvector::viota<${vlen}, uint16_t>(V, vl, vstart, vtype, vm, vd, vs2);
|
||||
case 0b010:
|
||||
return softvector::viota<${vlen}, uint32_t>(V, vl, vstart, vtype, vm, vd, vs2);
|
||||
case 0b011:
|
||||
return softvector::viota<${vlen}, uint64_t>(V, vl, vstart, vtype, vm, vd, vs2);
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
}
|
||||
}
|
||||
void vid(uint8_t* V, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, uint8_t vd, uint8_t sew_val){
|
||||
switch(sew_val){
|
||||
case 0b000:
|
||||
return softvector::vid<${vlen}, uint8_t>(V, vl, vstart, vtype, vm, vd);
|
||||
case 0b001:
|
||||
return softvector::vid<${vlen}, uint16_t>(V, vl, vstart, vtype, vm, vd);
|
||||
case 0b010:
|
||||
return softvector::vid<${vlen}, uint32_t>(V, vl, vstart, vtype, vm, vd);
|
||||
case 0b011:
|
||||
return softvector::vid<${vlen}, uint64_t>(V, vl, vstart, vtype, vm, vd);
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
}
|
||||
}
|
||||
void scalar_to_vector(uint8_t* V, softvector::vtype_t vtype, unsigned vd, uint64_t val, uint8_t sew_val){
|
||||
switch(sew_val){
|
||||
case 0b000:
|
||||
softvector::scalar_move<${vlen}, uint8_t>(V, vtype, vd, val, true);
|
||||
break;
|
||||
case 0b001:
|
||||
softvector::scalar_move<${vlen}, uint16_t>(V, vtype, vd, val, true);
|
||||
break;
|
||||
case 0b010:
|
||||
softvector::scalar_move<${vlen}, uint32_t>(V, vtype, vd, val, true);
|
||||
break;
|
||||
case 0b011:
|
||||
softvector::scalar_move<${vlen}, uint64_t>(V, vtype, vd, val, true);
|
||||
break;
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
}
|
||||
}
|
||||
uint64_t scalar_from_vector(uint8_t* V, softvector::vtype_t vtype, unsigned vd, uint8_t sew_val){
|
||||
switch(sew_val){
|
||||
case 0b000:
|
||||
return softvector::scalar_move<${vlen}, uint8_t>(V, vtype, vd, 0, false);
|
||||
case 0b001:
|
||||
return softvector::scalar_move<${vlen}, uint16_t>(V, vtype, vd, 0, false);
|
||||
case 0b010:
|
||||
return softvector::scalar_move<${vlen}, uint32_t>(V, vtype, vd, 0, false);
|
||||
case 0b011:
|
||||
return softvector::scalar_move<${vlen}, uint64_t>(V, vtype, vd, 0, false);
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
}
|
||||
}
|
||||
void vector_slideup(uint8_t* V, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, unsigned vd, unsigned vs2, uint64_t imm, uint8_t sew_val) {
|
||||
switch(sew_val){
|
||||
case 0b000:
|
||||
return softvector::vector_slideup<${vlen}, uint8_t>(V, vl, vstart, vtype, vm, vd, vs2, imm);
|
||||
case 0b001:
|
||||
return softvector::vector_slideup<${vlen}, uint16_t>(V, vl, vstart, vtype, vm, vd, vs2, imm);
|
||||
case 0b010:
|
||||
return softvector::vector_slideup<${vlen}, uint32_t>(V, vl, vstart, vtype, vm, vd, vs2, imm);
|
||||
case 0b011:
|
||||
return softvector::vector_slideup<${vlen}, uint64_t>(V, vl, vstart, vtype, vm, vd, vs2, imm);
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
}
|
||||
}
|
||||
void vector_slidedown(uint8_t* V, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, unsigned vd, unsigned vs2, uint64_t imm, uint8_t sew_val) {
|
||||
switch(sew_val){
|
||||
case 0b000:
|
||||
return softvector::vector_slidedown<${vlen}, uint8_t>(V, vl, vstart, vtype, vm, vd, vs2, imm);
|
||||
case 0b001:
|
||||
return softvector::vector_slidedown<${vlen}, uint16_t>(V, vl, vstart, vtype, vm, vd, vs2, imm);
|
||||
case 0b010:
|
||||
return softvector::vector_slidedown<${vlen}, uint32_t>(V, vl, vstart, vtype, vm, vd, vs2, imm);
|
||||
case 0b011:
|
||||
return softvector::vector_slidedown<${vlen}, uint64_t>(V, vl, vstart, vtype, vm, vd, vs2, imm);
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
}
|
||||
}
|
||||
void vector_slide1up(uint8_t* V, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, unsigned vd, unsigned vs2, uint64_t imm, uint8_t sew_val) {
|
||||
switch(sew_val){
|
||||
case 0b000:
|
||||
return softvector::vector_slide1up<${vlen}, uint8_t>(V, vl, vstart, vtype, vm, vd, vs2, imm);
|
||||
case 0b001:
|
||||
return softvector::vector_slide1up<${vlen}, uint16_t>(V, vl, vstart, vtype, vm, vd, vs2, imm);
|
||||
case 0b010:
|
||||
return softvector::vector_slide1up<${vlen}, uint32_t>(V, vl, vstart, vtype, vm, vd, vs2, imm);
|
||||
case 0b011:
|
||||
return softvector::vector_slide1up<${vlen}, uint64_t>(V, vl, vstart, vtype, vm, vd, vs2, imm);
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
}
|
||||
}
|
||||
void vector_slide1down(uint8_t* V, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, unsigned vd, unsigned vs2, uint64_t imm, uint8_t sew_val) {
|
||||
switch(sew_val){
|
||||
case 0b000:
|
||||
return softvector::vector_slide1down<${vlen}, uint8_t>(V, vl, vstart, vtype, vm, vd, vs2, imm);
|
||||
case 0b001:
|
||||
return softvector::vector_slide1down<${vlen}, uint16_t>(V, vl, vstart, vtype, vm, vd, vs2, imm);
|
||||
case 0b010:
|
||||
return softvector::vector_slide1down<${vlen}, uint32_t>(V, vl, vstart, vtype, vm, vd, vs2, imm);
|
||||
case 0b011:
|
||||
return softvector::vector_slide1down<${vlen}, uint64_t>(V, vl, vstart, vtype, vm, vd, vs2, imm);
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
}
|
||||
}
|
||||
void vector_vector_gather(uint8_t* V, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, uint8_t vd, uint8_t vs2, uint8_t vs1, uint8_t sew_val){
|
||||
switch(sew_val){
|
||||
case 0b000:
|
||||
return softvector::vector_vector_gather<${vlen}, uint8_t>(V, vl, vstart, vtype, vm, vd, vs2, vs1);
|
||||
case 0b001:
|
||||
return softvector::vector_vector_gather<${vlen}, uint16_t>(V, vl, vstart, vtype, vm, vd, vs2, vs1);
|
||||
case 0b010:
|
||||
return softvector::vector_vector_gather<${vlen}, uint32_t>(V, vl, vstart, vtype, vm, vd, vs2, vs1);
|
||||
case 0b011:
|
||||
return softvector::vector_vector_gather<${vlen}, uint64_t>(V, vl, vstart, vtype, vm, vd, vs2, vs1);
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
}
|
||||
}
|
||||
void vector_vector_gatherei16(uint8_t* V, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, uint8_t vd, uint8_t vs2, uint8_t vs1, uint8_t sew_val){
|
||||
switch(sew_val){
|
||||
case 0b000:
|
||||
return softvector::vector_vector_gather<${vlen}, uint8_t, uint16_t>(V, vl, vstart, vtype, vm, vd, vs2, vs1);
|
||||
case 0b001:
|
||||
return softvector::vector_vector_gather<${vlen}, uint16_t, uint16_t>(V, vl, vstart, vtype, vm, vd, vs2, vs1);
|
||||
case 0b010:
|
||||
return softvector::vector_vector_gather<${vlen}, uint32_t, uint16_t>(V, vl, vstart, vtype, vm, vd, vs2, vs1);
|
||||
case 0b011:
|
||||
return softvector::vector_vector_gather<${vlen}, uint64_t, uint16_t>(V, vl, vstart, vtype, vm, vd, vs2, vs1);
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
}
|
||||
}
|
||||
void vector_imm_gather(uint8_t* V, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, uint8_t vd, uint8_t vs2, uint64_t imm, uint8_t sew_val){
|
||||
switch(sew_val){
|
||||
case 0b000:
|
||||
return softvector::vector_imm_gather<${vlen}, uint8_t>(V, vl, vstart, vtype, vm, vd, vs2, imm);
|
||||
case 0b001:
|
||||
return softvector::vector_imm_gather<${vlen}, uint16_t>(V, vl, vstart, vtype, vm, vd, vs2, imm);
|
||||
case 0b010:
|
||||
return softvector::vector_imm_gather<${vlen}, uint32_t>(V, vl, vstart, vtype, vm, vd, vs2, imm);
|
||||
case 0b011:
|
||||
return softvector::vector_imm_gather<${vlen}, uint64_t>(V, vl, vstart, vtype, vm, vd, vs2, imm);
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
}
|
||||
}
|
||||
void vector_compress(uint8_t* V, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, uint8_t vd, uint8_t vs2, uint8_t vs1, uint8_t sew_val){
|
||||
switch(sew_val){
|
||||
case 0b000:
|
||||
return softvector::vector_compress<${vlen}, uint8_t>(V, vl, vstart, vtype, vd, vs2, vs1);
|
||||
case 0b001:
|
||||
return softvector::vector_compress<${vlen}, uint16_t>(V, vl, vstart, vtype, vd, vs2, vs1);
|
||||
case 0b010:
|
||||
return softvector::vector_compress<${vlen}, uint32_t>(V, vl, vstart, vtype, vd, vs2, vs1);
|
||||
case 0b011:
|
||||
return softvector::vector_compress<${vlen}, uint64_t>(V, vl, vstart, vtype, vd, vs2, vs1);
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
}
|
||||
}
|
||||
void vector_whole_move(uint8_t* V, uint8_t vd, uint8_t vs2, uint8_t count){
|
||||
return softvector::vector_whole_move<${vlen}>(V, vd, vs2, count);
|
||||
}
|
||||
uint64_t fp_scalar_from_vector(uint8_t* V, softvector::vtype_t vtype, unsigned vd, uint8_t sew_val){
|
||||
return scalar_from_vector(V, vtype, vd, sew_val);
|
||||
}
|
||||
void fp_vector_slide1up(uint8_t* V, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, unsigned vd, unsigned vs2, uint64_t imm, uint8_t sew_val) {
|
||||
return vector_slide1up(V, vl, vstart, vtype, vm, vd, vs2, imm, sew_val);
|
||||
}
|
||||
void fp_vector_slide1down(uint8_t* V, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, unsigned vd, unsigned vs2, uint64_t imm, uint8_t sew_val) {
|
||||
return vector_slide1down(V, vl, vstart, vtype, vm, vd, vs2, imm, sew_val);
|
||||
}
|
||||
void fp_vector_red_op(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, uint8_t vd, uint8_t vs2, uint8_t vs1, uint8_t rm, uint8_t sew_val){
|
||||
switch(sew_val){
|
||||
case 0b000:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
case 0b001:
|
||||
return softvector::fp_vector_red_op<${vlen}, uint16_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1, rm);
|
||||
case 0b010:
|
||||
return softvector::fp_vector_red_op<${vlen}, uint32_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1, rm);
|
||||
case 0b011:
|
||||
return softvector::fp_vector_red_op<${vlen}, uint64_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1, rm);
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
}
|
||||
}
|
||||
void fp_vector_red_wv(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, uint8_t vd, uint8_t vs2, uint8_t vs1, uint8_t rm, uint8_t sew_val){
|
||||
switch(sew_val){
|
||||
case 0b000:
|
||||
return softvector::fp_vector_red_op<${vlen}, uint16_t, uint8_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1, rm);
|
||||
case 0b001:
|
||||
return softvector::fp_vector_red_op<${vlen}, uint32_t, uint16_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1, rm);
|
||||
case 0b010:
|
||||
return softvector::fp_vector_red_op<${vlen}, uint64_t, uint32_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1, rm);
|
||||
case 0b011: // would require 128 bits vs2 value
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
}
|
||||
}
|
||||
void fp_vector_vector_op(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, uint8_t vd, uint8_t vs2, uint8_t vs1, uint8_t rm, uint8_t sew_val){
|
||||
switch(sew_val){
|
||||
case 0b000:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
case 0b001:
|
||||
return softvector::fp_vector_vector_op<${vlen}, uint16_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1, rm);
|
||||
case 0b010:
|
||||
return softvector::fp_vector_vector_op<${vlen}, uint32_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1, rm);
|
||||
case 0b011:
|
||||
return softvector::fp_vector_vector_op<${vlen}, uint64_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1, rm);
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
}
|
||||
}
|
||||
void fp_vector_imm_op(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, uint8_t vd, uint8_t vs2, uint64_t imm, uint8_t rm, uint8_t sew_val){
|
||||
switch(sew_val){
|
||||
case 0b000:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
case 0b001:
|
||||
return softvector::fp_vector_imm_op<${vlen}, uint16_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, imm, rm);
|
||||
case 0b010:
|
||||
return softvector::fp_vector_imm_op<${vlen}, uint32_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, imm, rm);
|
||||
case 0b011:
|
||||
return softvector::fp_vector_imm_op<${vlen}, uint64_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, imm, rm);
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
}
|
||||
}
|
||||
void fp_vector_vector_wv(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, uint8_t vd, uint8_t vs2, uint8_t vs1, uint8_t rm, uint8_t sew_val){
|
||||
switch(sew_val){
|
||||
case 0b000:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
case 0b001:
|
||||
return softvector::fp_vector_vector_op<${vlen}, uint32_t, uint16_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1, rm);
|
||||
case 0b010:
|
||||
return softvector::fp_vector_vector_op<${vlen}, uint64_t, uint32_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1, rm);
|
||||
case 0b011: // would widen to 128 bits
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
}
|
||||
}
|
||||
void fp_vector_imm_wv(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, uint8_t vd, uint8_t vs2, uint64_t imm, uint8_t rm, uint8_t sew_val){
|
||||
switch(sew_val){
|
||||
case 0b000:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
case 0b001:
|
||||
return softvector::fp_vector_imm_op<${vlen}, uint32_t, uint16_t, uint16_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, imm, rm);
|
||||
case 0b010:
|
||||
return softvector::fp_vector_imm_op<${vlen}, uint64_t, uint32_t, uint32_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, imm, rm);
|
||||
case 0b011: // would widen to 128 bits
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
}
|
||||
}
|
||||
void fp_vector_vector_ww(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, uint8_t vd, uint8_t vs2, uint8_t vs1, uint8_t rm, uint8_t sew_val){
|
||||
switch(sew_val){
|
||||
case 0b000:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
case 0b001:
|
||||
return softvector::fp_vector_vector_op<${vlen}, uint32_t, uint32_t, uint16_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1, rm);
|
||||
case 0b010:
|
||||
return softvector::fp_vector_vector_op<${vlen}, uint64_t, uint64_t, uint32_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, vs1, rm);
|
||||
case 0b011: // would widen to 128 bits
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
}
|
||||
}
|
||||
void fp_vector_imm_ww(uint8_t* V, uint8_t funct6, uint8_t funct3, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, uint8_t vd, uint8_t vs2, uint64_t imm, uint8_t rm, uint8_t sew_val){
|
||||
switch(sew_val){
|
||||
case 0b000:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
case 0b001:
|
||||
return softvector::fp_vector_imm_op<${vlen}, uint32_t, uint32_t, uint16_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, imm, rm);
|
||||
case 0b010:
|
||||
return softvector::fp_vector_imm_op<${vlen}, uint64_t, uint64_t, uint32_t>(V, funct6, funct3, vl, vstart, vtype, vm, vd, vs2, imm, rm);
|
||||
case 0b011: // would widen to 128 bits
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
}
|
||||
}
|
||||
void fp_vector_unary_op(uint8_t* V, uint8_t encoding_space, uint8_t unary_op, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, uint8_t vd, uint8_t vs2, uint8_t rm, uint8_t sew_val){
|
||||
switch(sew_val){
|
||||
case 0b000:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
case 0b001:
|
||||
return softvector::fp_vector_unary_op<${vlen}, uint16_t>(V, encoding_space, unary_op, vl, vstart, vtype, vm, vd, vs2, rm);
|
||||
case 0b010:
|
||||
return softvector::fp_vector_unary_op<${vlen}, uint32_t>(V, encoding_space, unary_op, vl, vstart, vtype, vm, vd, vs2, rm);
|
||||
case 0b011:
|
||||
return softvector::fp_vector_unary_op<${vlen}, uint64_t>(V, encoding_space, unary_op, vl, vstart, vtype, vm, vd, vs2, rm);
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
}
|
||||
}
|
||||
void mask_fp_vector_vector_op(uint8_t* V, uint8_t funct6, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, uint8_t vd, uint8_t vs2, uint8_t vs1, uint8_t rm, uint8_t sew_val){
|
||||
switch(sew_val){
|
||||
case 0b000:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
case 0b001:
|
||||
return softvector::mask_fp_vector_vector_op<${vlen}, uint16_t>(V, funct6, vl, vstart, vtype, vm, vd, vs2, vs1, rm);
|
||||
case 0b010:
|
||||
return softvector::mask_fp_vector_vector_op<${vlen}, uint32_t>(V, funct6, vl, vstart, vtype, vm, vd, vs2, vs1, rm);
|
||||
case 0b011:
|
||||
return softvector::mask_fp_vector_vector_op<${vlen}, uint64_t>(V, funct6, vl, vstart, vtype, vm, vd, vs2, vs1, rm);
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
}
|
||||
}
|
||||
void mask_fp_vector_imm_op(uint8_t* V, uint8_t funct6, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, uint8_t vd, uint8_t vs2, uint64_t imm, uint8_t rm, uint8_t sew_val){
|
||||
switch(sew_val){
|
||||
case 0b000:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
case 0b001:
|
||||
return softvector::mask_fp_vector_imm_op<${vlen}, uint16_t>(V, funct6, vl, vstart, vtype, vm, vd, vs2, imm, rm);
|
||||
case 0b010:
|
||||
return softvector::mask_fp_vector_imm_op<${vlen}, uint32_t>(V, funct6, vl, vstart, vtype, vm, vd, vs2, imm, rm);
|
||||
case 0b011:
|
||||
return softvector::mask_fp_vector_imm_op<${vlen}, uint64_t>(V, funct6, vl, vstart, vtype, vm, vd, vs2, imm, rm);
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
}
|
||||
}
|
||||
void fp_vector_imm_merge(uint8_t* V, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, uint8_t vd, uint8_t vs2, uint64_t imm, uint8_t sew_val){
|
||||
vector_imm_merge(V, vl, vstart, vtype, vm, vd, vs2, imm, sew_val);
|
||||
}
|
||||
void fp_vector_unary_w(uint8_t* V, uint8_t unary_op, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, uint8_t vd, uint8_t vs2, uint8_t rm, uint8_t sew_val){
|
||||
switch(sew_val){
|
||||
case 0b000:
|
||||
return softvector::fp_vector_unary_w<${vlen}, uint16_t, uint8_t>(V, unary_op, vl, vstart, vtype, vm, vd, vs2, rm);
|
||||
case 0b001:
|
||||
return softvector::fp_vector_unary_w<${vlen}, uint32_t, uint16_t>(V, unary_op, vl, vstart, vtype, vm, vd, vs2, rm);
|
||||
case 0b010:
|
||||
return softvector::fp_vector_unary_w<${vlen}, uint64_t, uint32_t>(V, unary_op, vl, vstart, vtype, vm, vd, vs2, rm);
|
||||
case 0b011: // would widen to 128 bits
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
}
|
||||
}
|
||||
void fp_vector_unary_n(uint8_t* V, uint8_t unary_op, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, uint8_t vd, uint8_t vs2, uint8_t rm, uint8_t sew_val){
|
||||
switch(sew_val){
|
||||
case 0b000:
|
||||
return softvector::fp_vector_unary_n<${vlen}, uint8_t, uint16_t>(V, unary_op, vl, vstart, vtype, vm, vd, vs2, rm);
|
||||
case 0b001:
|
||||
return softvector::fp_vector_unary_n<${vlen}, uint16_t, uint32_t>(V, unary_op, vl, vstart, vtype, vm, vd, vs2, rm);
|
||||
case 0b010:
|
||||
return softvector::fp_vector_unary_n<${vlen}, uint32_t, uint64_t>(V, unary_op, vl, vstart, vtype, vm, vd, vs2, rm);
|
||||
case 0b011: // would require 128 bit value to narrow
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported sew bit value");
|
||||
}
|
||||
}
|
||||
void vector_unary_op(uint8_t* V, uint8_t unary_op, uint64_t vl, uint64_t vstart, softvector::vtype_t vtype, bool vm, uint8_t vd, uint8_t vs2, uint8_t sew_val){
|
||||
switch(sew_val){
|
||||
case 0b000:
|
||||
return softvector::vector_unary_op<${vlen}, uint8_t>(V, unary_op, vl, vstart, vtype, vm, vd, vs2);
|
||||
case 0b001:
|
||||
return softvector::vector_unary_op<${vlen}, uint16_t>(V, unary_op, vl, vstart, vtype, vm, vd, vs2);
|
||||
case 0b010:
|
||||
return softvector::vector_unary_op<${vlen}, uint32_t>(V, unary_op, vl, vstart, vtype, vm, vd, vs2);
|
||||
case 0b011:
|
||||
return softvector::vector_unary_op<${vlen}, uint64_t>(V, unary_op, vl, vstart, vtype, vm, vd, vs2);
|
||||
default:
|
||||
throw new std::runtime_error("Unsupported sew_val");
|
||||
}
|
||||
}
|
||||
<%}%>
|
||||
uint64_t fetch_count{0};
|
||||
uint64_t tval{0};
|
||||
|
||||
@ -170,22 +1024,8 @@ private:
|
||||
decoder instr_decoder;
|
||||
|
||||
iss::status fetch_ins(virt_addr_t pc, uint8_t * data){
|
||||
if(this->core.has_mmu()) {
|
||||
auto phys_pc = this->core.virt2phys(pc);
|
||||
// if ((pc.val & upper_bits) != ((pc.val + 2) & upper_bits)) { // we may cross a page boundary
|
||||
// if (this->core.read(phys_pc, 2, data) != iss::Ok) return iss::Err;
|
||||
// if ((data[0] & 0x3) == 0x3) // this is a 32bit instruction
|
||||
// if (this->core.read(this->core.v2p(pc + 2), 2, data + 2) != iss::Ok)
|
||||
// return iss::Err;
|
||||
// } else {
|
||||
if (this->core.read(phys_pc, 4, data) != iss::Ok)
|
||||
return iss::Err;
|
||||
// }
|
||||
} else {
|
||||
if (this->core.read(phys_addr_t(pc.access, pc.space, pc.val), 4, data) != iss::Ok)
|
||||
return iss::Err;
|
||||
|
||||
}
|
||||
if (this->core.read(iss::address_type::PHYSICAL, pc.access, pc.space, pc.val, 4, data) != iss::Ok)
|
||||
return iss::Err;
|
||||
return iss::Ok;
|
||||
}
|
||||
};
|
||||
@ -194,9 +1034,6 @@ template <typename CODE_WORD> void debug_fn(CODE_WORD insn) {
|
||||
volatile CODE_WORD x = insn;
|
||||
insn = 2 * x;
|
||||
}
|
||||
|
||||
template <typename ARCH> vm_impl<ARCH>::vm_impl() { this(new ARCH()); }
|
||||
|
||||
// according to
|
||||
// https://stackoverflow.com/questions/8871204/count-number-of-1s-in-binary-representation
|
||||
#ifdef __GCC__
|
||||
@ -252,17 +1089,21 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
|
||||
while(!this->core.should_stop() &&
|
||||
!(is_icount_limit_enabled(cond) && icount >= count_limit) &&
|
||||
!(is_fcount_limit_enabled(cond) && fetch_count >= count_limit)){
|
||||
fetch_count++;
|
||||
if(this->debugging_enabled())
|
||||
this->tgt_adapter->check_continue(*PC);
|
||||
pc.val=*PC;
|
||||
if(fetch_ins(pc, data)!=iss::Ok){
|
||||
this->do_sync(POST_SYNC, std::numeric_limits<unsigned>::max());
|
||||
pc.val = super::core.enter_trap(std::numeric_limits<uint64_t>::max(), pc.val, 0);
|
||||
if(this->sync_exec && PRE_SYNC) this->do_sync(PRE_SYNC, std::numeric_limits<unsigned>::max());
|
||||
process_spawn_blocks();
|
||||
if(this->sync_exec && POST_SYNC) this->do_sync(PRE_SYNC, std::numeric_limits<unsigned>::max());
|
||||
pc.val = super::core.enter_trap(arch::traits<ARCH>::RV_CAUSE_FETCH_ACCESS<<16, pc.val, 0);
|
||||
} else {
|
||||
if (is_jump_to_self_enabled(cond) &&
|
||||
(instr == 0x0000006f || (instr&0xffff)==0xa001)) throw simulation_stopped(0); // 'J 0' or 'C.J 0'
|
||||
uint32_t inst_index = instr_decoder.decode_instr(instr);
|
||||
opcode_e inst_id = arch::traits<ARCH>::opcode_e::MAX_OPCODE;;
|
||||
if(inst_index <instr_descr.size())
|
||||
inst_id = instr_descr.at(instr_decoder.decode_instr(instr)).op;
|
||||
inst_id = instr_descr[inst_index].op;
|
||||
|
||||
// pre execution stuff
|
||||
this->core.reg.last_branch = 0;
|
||||
@ -274,12 +1115,13 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
|
||||
<%}%>if(this->disass_enabled){
|
||||
/* generate console output when executing the command */<%instr.disass.eachLine{%>
|
||||
${it}<%}%>
|
||||
this->core.disass_output(pc.val, mnemonic);
|
||||
}
|
||||
// used registers<%instr.usedVariables.each{ k,v->
|
||||
if(v.isArray) {%>
|
||||
auto* ${k} = reinterpret_cast<uint${nativeTypeSize(v.type.size)}_t*>(this->regs_base_ptr+arch::traits<ARCH>::reg_byte_offsets[arch::traits<ARCH>::${k}0]);<% }else{ %>
|
||||
auto* ${k} = reinterpret_cast<uint${nativeTypeSize(v.type.size)}_t*>(this->regs_base_ptr+arch::traits<ARCH>::reg_byte_offsets[arch::traits<ARCH>::${k}]);
|
||||
<%}}%>// calculate next pc value
|
||||
auto* ${k} = reinterpret_cast<uint${nativeTypeSize(v.type.size)}_t*>(this->regs_base_ptr+arch::traits<ARCH>::reg_byte_offsets[arch::traits<ARCH>::${k}]);<%}}%>
|
||||
// calculate next pc value
|
||||
*NEXT_PC = *PC + ${instr.length/8};
|
||||
// execute instruction<%instr.behavior.eachLine{%>
|
||||
${it}<%}%>
|
||||
@ -305,11 +1147,11 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
|
||||
icount++;
|
||||
instret++;
|
||||
}
|
||||
cycle++;
|
||||
pc.val=*NEXT_PC;
|
||||
this->core.reg.PC = this->core.reg.NEXT_PC;
|
||||
*PC = *NEXT_PC;
|
||||
this->core.reg.trap_state = this->core.reg.pending_trap;
|
||||
}
|
||||
fetch_count++;
|
||||
cycle++;
|
||||
}
|
||||
return pc;
|
||||
}
|
||||
|
@ -31,13 +31,17 @@
|
||||
*******************************************************************************/
|
||||
// clang-format off
|
||||
#include <iss/arch/${coreDef.name.toLowerCase()}.h>
|
||||
// vm_base needs to be included before gdb_session as termios.h (via boost and gdb_server) has a define which clashes with a variable
|
||||
// name in ConstantRange.h
|
||||
#include <iss/llvm/vm_base.h>
|
||||
#include <iss/iss.h>
|
||||
#include <iss/debugger/gdb_session.h>
|
||||
#include <iss/debugger/server.h>
|
||||
#include <iss/iss.h>
|
||||
#include <iss/llvm/vm_base.h>
|
||||
#include <util/logging.h>
|
||||
#include <iss/instruction_decoder.h>
|
||||
|
||||
#include <util/logging.h>
|
||||
<%def fcsr = registers.find {it.name=='FCSR'}
|
||||
if(fcsr != null) {%>
|
||||
#include <vm/fp_functions.h><%}%>
|
||||
#ifndef FMT_HEADER_ONLY
|
||||
#define FMT_HEADER_ONLY
|
||||
#endif
|
||||
@ -83,7 +87,9 @@ protected:
|
||||
using vm_base<ARCH>::get_reg_ptr;
|
||||
|
||||
inline const char *name(size_t index){return traits::reg_aliases.at(index);}
|
||||
|
||||
<%if(fcsr != null) {%>
|
||||
inline const char *fname(size_t index){return index < 32?name(index+traits::F0):"illegal";}
|
||||
<%}%>
|
||||
template <typename T> inline ConstantInt *size(T type) {
|
||||
return ConstantInt::get(getContext(), APInt(32, type->getType()->getScalarSizeInBits()));
|
||||
}
|
||||
@ -97,7 +103,7 @@ protected:
|
||||
return super::gen_cond_assign(cond, this->gen_ext(trueVal, size), this->gen_ext(falseVal, size));
|
||||
}
|
||||
|
||||
std::tuple<continuation_e, BasicBlock *> gen_single_inst_behavior(virt_addr_t &, unsigned int &, BasicBlock *) override;
|
||||
std::tuple<continuation_e, BasicBlock *> gen_single_inst_behavior(virt_addr_t &, BasicBlock *) override;
|
||||
|
||||
void gen_leave_behavior(BasicBlock *leave_blk) override;
|
||||
void gen_raise_trap(uint16_t trap_id, uint16_t cause);
|
||||
@ -130,8 +136,31 @@ protected:
|
||||
auto mask = (1ULL<<W) - 1;
|
||||
auto sign_mask = 1ULL<<(W-1);
|
||||
return (from & mask) | ((from & sign_mask) ? ~mask : 0);
|
||||
}
|
||||
}
|
||||
<%functions.each{ it.eachLine { %>
|
||||
${it}<%}
|
||||
}
|
||||
if(fcsr != null) {%>
|
||||
Value* NaNBox16(BasicBlock* bb, Value* NaNBox16_val){
|
||||
if(static_cast<uint32_t>(traits::FLEN) == 16)
|
||||
return this->gen_ext(NaNBox16_val, traits::FLEN, false);
|
||||
auto box = this->builder.CreateNot((this->gen_ext(0, 32, false)));
|
||||
return this->gen_ext((this->builder.CreateOr(this->builder.CreateShl(this->gen_ext(box, traits::FLEN), 16), this->gen_ext(NaNBox16_val, traits::FLEN))), traits::FLEN, false);
|
||||
}
|
||||
Value* NaNBox32(BasicBlock* bb, Value* NaNBox32_val){
|
||||
if(static_cast<uint32_t>(traits::FLEN) == 32)
|
||||
return this->gen_ext(NaNBox32_val, traits::FLEN, false);
|
||||
auto box = this->builder.CreateNot((this->gen_ext(0, 64, false)));
|
||||
return this->gen_ext((this->builder.CreateOr(this->builder.CreateShl(this->gen_ext(box, traits::FLEN), 32), this->gen_ext(NaNBox32_val, traits::FLEN))), traits::FLEN, false);
|
||||
}
|
||||
Value* NaNBox64(BasicBlock* bb, Value* NaNBox64_val){
|
||||
if(static_cast<uint32_t>(traits::FLEN) == 64)
|
||||
return this->gen_ext(NaNBox64_val, traits::FLEN, false);
|
||||
auto box = this->builder.CreateNot((this->gen_ext(0, 128, false)));
|
||||
return this->gen_ext((this->builder.CreateOr(this->builder.CreateShl(this->gen_ext(box, traits::FLEN), 64), this->gen_ext(NaNBox64_val, traits::FLEN))), traits::FLEN, false);
|
||||
}
|
||||
|
||||
<%}%>
|
||||
private:
|
||||
/****************************************************************************
|
||||
* start opcode definitions
|
||||
@ -198,7 +227,7 @@ private:
|
||||
};
|
||||
this->builder.CreateCall(this->mod->getFunction("print_disass"), args);
|
||||
}
|
||||
this->gen_sync(iss::PRE_SYNC, instr_descr.size());
|
||||
this->gen_sync(iss::PRE_SYNC, instr_descr.size());
|
||||
this->builder.CreateStore(this->builder.CreateLoad(this->get_typeptr(traits::NEXT_PC), get_reg_ptr(traits::NEXT_PC), true),
|
||||
get_reg_ptr(traits::PC), true);
|
||||
this->builder.CreateStore(
|
||||
@ -212,7 +241,7 @@ private:
|
||||
bb = this->leave_blk;
|
||||
this->gen_instr_epilogue(bb);
|
||||
this->builder.CreateBr(bb);
|
||||
return std::make_tuple(BRANCH, nullptr);
|
||||
return std::make_tuple(ILLEGAL_INSTR, nullptr);
|
||||
}
|
||||
};
|
||||
|
||||
@ -238,29 +267,20 @@ vm_impl<ARCH>::vm_impl(ARCH &core, unsigned core_id, unsigned cluster_id)
|
||||
|
||||
template <typename ARCH>
|
||||
std::tuple<continuation_e, BasicBlock *>
|
||||
vm_impl<ARCH>::gen_single_inst_behavior(virt_addr_t &pc, unsigned int &inst_cnt, BasicBlock *this_block) {
|
||||
vm_impl<ARCH>::gen_single_inst_behavior(virt_addr_t &pc, BasicBlock *this_block) {
|
||||
// we fetch at max 4 byte, alignment is 2
|
||||
enum {TRAP_ID=1<<16};
|
||||
code_word_t instr = 0;
|
||||
// const typename traits::addr_t upper_bits = ~traits::PGMASK;
|
||||
phys_addr_t paddr(pc);
|
||||
auto *const data = (uint8_t *)&instr;
|
||||
if(this->core.has_mmu())
|
||||
paddr = this->core.virt2phys(pc);
|
||||
//TODO: re-add page handling
|
||||
// if ((pc.val & upper_bits) != ((pc.val + 2) & upper_bits)) { // we may cross a page boundary
|
||||
// auto res = this->core.read(paddr, 2, data);
|
||||
// if (res != iss::Ok) throw trap_access(TRAP_ID, pc.val);
|
||||
// if ((instr & 0x3) == 0x3) { // this is a 32bit instruction
|
||||
// res = this->core.read(this->core.v2p(pc + 2), 2, data + 2);
|
||||
// }
|
||||
// } else {
|
||||
auto res = this->core.read(paddr, 4, data);
|
||||
if (res != iss::Ok) throw trap_access(TRAP_ID, pc.val);
|
||||
// }
|
||||
if (instr == 0x0000006f || (instr&0xffff)==0xa001) throw simulation_stopped(0); // 'J 0' or 'C.J 0'
|
||||
// curr pc on stack
|
||||
++inst_cnt;
|
||||
if (res != iss::Ok)
|
||||
return std::make_tuple(ILLEGAL_FETCH, nullptr);
|
||||
if (instr == 0x0000006f || (instr&0xffff)==0xa001){
|
||||
this->builder.CreateBr(this->leave_blk);
|
||||
return std::make_tuple(JUMP_TO_SELF, nullptr);
|
||||
}
|
||||
uint32_t inst_index = instr_decoder.decode_instr(instr);
|
||||
compile_func f = nullptr;
|
||||
if(inst_index < instr_descr.size())
|
||||
@ -281,6 +301,7 @@ template <typename ARCH>
|
||||
void vm_impl<ARCH>::gen_raise_trap(uint16_t trap_id, uint16_t cause) {
|
||||
auto *TRAP_val = this->gen_const(32, 0x80 << 24 | (cause << 16) | trap_id);
|
||||
this->builder.CreateStore(TRAP_val, get_reg_ptr(traits::TRAP_STATE), true);
|
||||
this->builder.CreateBr(this->trap_blk);
|
||||
}
|
||||
|
||||
template <typename ARCH>
|
||||
@ -341,6 +362,10 @@ void vm_impl<ARCH>::gen_instr_epilogue(BasicBlock *bb) {
|
||||
auto* icount_val = this->builder.CreateAdd(
|
||||
this->builder.CreateLoad(this->get_typeptr(arch::traits<ARCH>::ICOUNT), get_reg_ptr(arch::traits<ARCH>::ICOUNT)), this->gen_const(64U, 1));
|
||||
this->builder.CreateStore(icount_val, get_reg_ptr(arch::traits<ARCH>::ICOUNT), false);
|
||||
//increment cyclecount
|
||||
auto* cycle_val = this->builder.CreateAdd(
|
||||
this->builder.CreateLoad(this->get_typeptr(arch::traits<ARCH>::CYCLE), get_reg_ptr(arch::traits<ARCH>::CYCLE)), this->gen_const(64U, 1));
|
||||
this->builder.CreateStore(cycle_val, get_reg_ptr(arch::traits<ARCH>::CYCLE), false);
|
||||
}
|
||||
|
||||
} // namespace ${coreDef.name.toLowerCase()}
|
||||
@ -383,4 +408,4 @@ volatile std::array<bool, 2> dummy = {
|
||||
};
|
||||
}
|
||||
}
|
||||
// clang-format on
|
||||
// clang-format on
|
||||
|
@ -38,7 +38,9 @@
|
||||
#include <util/logging.h>
|
||||
#include <sstream>
|
||||
#include <iss/instruction_decoder.h>
|
||||
|
||||
<%def fcsr = registers.find {it.name=='FCSR'}
|
||||
if(fcsr != null) {%>
|
||||
#include <vm/fp_functions.h><%}%>
|
||||
#ifndef FMT_HEADER_ONLY
|
||||
#define FMT_HEADER_ONLY
|
||||
#endif
|
||||
@ -81,16 +83,21 @@ protected:
|
||||
using vm_base<ARCH>::get_reg_ptr;
|
||||
|
||||
using this_class = vm_impl<ARCH>;
|
||||
using compile_ret_t = std::tuple<continuation_e>;
|
||||
using compile_ret_t = continuation_e;
|
||||
using compile_func = compile_ret_t (this_class::*)(virt_addr_t &pc, code_word_t instr, tu_builder&);
|
||||
|
||||
inline const char *name(size_t index){return traits::reg_aliases.at(index);}
|
||||
<%
|
||||
if(fcsr != null) {%>
|
||||
inline const char *fname(size_t index){return index < 32?name(index+traits::F0):"illegal";}
|
||||
<%}%>
|
||||
void add_prologue(tu_builder& tu) override;
|
||||
|
||||
void setup_module(std::string m) override {
|
||||
super::setup_module(m);
|
||||
}
|
||||
|
||||
compile_ret_t gen_single_inst_behavior(virt_addr_t &, unsigned int &, tu_builder&) override;
|
||||
compile_ret_t gen_single_inst_behavior(virt_addr_t &, tu_builder&) override;
|
||||
|
||||
void gen_trap_behavior(tu_builder& tu) override;
|
||||
|
||||
@ -98,8 +105,6 @@ protected:
|
||||
|
||||
void gen_leave_trap(tu_builder& tu, unsigned lvl);
|
||||
|
||||
void gen_wait(tu_builder& tu, unsigned type);
|
||||
|
||||
inline void gen_set_tval(tu_builder& tu, uint64_t new_tval);
|
||||
|
||||
inline void gen_set_tval(tu_builder& tu, value new_tval);
|
||||
@ -133,6 +138,36 @@ protected:
|
||||
return (from & mask) | ((from & sign_mask) ? ~mask : 0);
|
||||
}
|
||||
|
||||
<%functions.each{ it.eachLine { %>
|
||||
${it}<%}
|
||||
}
|
||||
if(fcsr != null) {%>
|
||||
value NaNBox16(tu_builder& tu, value NaNBox16_val){
|
||||
if(static_cast<uint32_t>(traits::FLEN) == 16)
|
||||
return tu.ext(NaNBox16_val, traits::FLEN, false);
|
||||
else {
|
||||
auto box = tu.assignment(tu.logical_neg((tu.ext(0, 32, false))), traits::FLEN) ;
|
||||
return tu.ext((tu.bitwise_or(tu.shl(box, 16), NaNBox16_val)), traits::FLEN, false);
|
||||
}
|
||||
}
|
||||
value NaNBox32(tu_builder& tu, value NaNBox32_val){
|
||||
if(static_cast<uint32_t>(traits::FLEN) == 32)
|
||||
return tu.ext(NaNBox32_val, traits::FLEN, false);
|
||||
else {
|
||||
auto box = tu.assignment(tu.logical_neg((tu.ext(0, 64, false))), traits::FLEN) ;
|
||||
return tu.ext((tu.bitwise_or(tu.shl(box, 32), NaNBox32_val)), traits::FLEN, false);
|
||||
}
|
||||
}
|
||||
value NaNBox64(tu_builder& tu, value NaNBox64_val){
|
||||
if(static_cast<uint32_t>(traits::FLEN) == 64)
|
||||
return tu.ext(NaNBox64_val, traits::FLEN, false);
|
||||
else {
|
||||
throw new std::runtime_error("tcc does not support Registers wider than 64 bits");
|
||||
auto box = tu.assignment(tu.logical_neg((tu.ext(0, 128, false))), traits::FLEN) ;
|
||||
return tu.ext((tu.bitwise_or(tu.shl(box, 64), NaNBox64_val)), traits::FLEN, false);
|
||||
}
|
||||
}
|
||||
<%}%>
|
||||
private:
|
||||
/****************************************************************************
|
||||
* start opcode definitions
|
||||
@ -163,14 +198,18 @@ private:
|
||||
<%}%>if(this->disass_enabled){
|
||||
/* generate console output when executing the command */<%instr.disass.eachLine{%>
|
||||
${it}<%}%>
|
||||
tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
|
||||
}
|
||||
auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
|
||||
pc=pc+ ${instr.length/8};
|
||||
gen_set_pc(tu, pc, traits::NEXT_PC);
|
||||
tu("(*cycle)++;");
|
||||
tu.open_scope();
|
||||
this->gen_set_tval(tu, instr);
|
||||
<%instr.behavior.eachLine{%>${it}
|
||||
<%}%>
|
||||
tu("(*icount)++;");
|
||||
tu("(*instret)++;");
|
||||
tu.close_scope();
|
||||
vm_base<ARCH>::gen_sync(tu, POST_SYNC,${idx});
|
||||
gen_trap_check(tu);
|
||||
@ -187,11 +226,11 @@ private:
|
||||
tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, std::string("illegal_instruction"));
|
||||
}
|
||||
pc = pc + ((instr & 3) == 3 ? 4 : 2);
|
||||
gen_raise_trap(tu, 0, 2); // illegal instruction trap
|
||||
gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
|
||||
this->gen_set_tval(tu, instr);
|
||||
vm_impl::gen_sync(tu, iss::POST_SYNC, instr_descr.size());
|
||||
vm_impl::gen_trap_check(tu);
|
||||
return BRANCH;
|
||||
return ILLEGAL_INSTR;
|
||||
}
|
||||
};
|
||||
|
||||
@ -216,28 +255,17 @@ vm_impl<ARCH>::vm_impl(ARCH &core, unsigned core_id, unsigned cluster_id)
|
||||
}()) {}
|
||||
|
||||
template <typename ARCH>
|
||||
std::tuple<continuation_e>
|
||||
vm_impl<ARCH>::gen_single_inst_behavior(virt_addr_t &pc, unsigned int &inst_cnt, tu_builder& tu) {
|
||||
continuation_e
|
||||
vm_impl<ARCH>::gen_single_inst_behavior(virt_addr_t &pc, tu_builder& tu) {
|
||||
// we fetch at max 4 byte, alignment is 2
|
||||
enum {TRAP_ID=1<<16};
|
||||
code_word_t instr = 0;
|
||||
phys_addr_t paddr(pc);
|
||||
if(this->core.has_mmu())
|
||||
paddr = this->core.virt2phys(pc);
|
||||
//TODO: re-add page handling
|
||||
// if ((pc.val & upper_bits) != ((pc.val + 2) & upper_bits)) { // we may cross a page boundary
|
||||
// auto res = this->core.read(paddr, 2, data);
|
||||
// if (res != iss::Ok) throw trap_access(TRAP_ID, pc.val);
|
||||
// if ((insn & 0x3) == 0x3) { // this is a 32bit instruction
|
||||
// res = this->core.read(this->core.v2p(pc + 2), 2, data + 2);
|
||||
// }
|
||||
// } else {
|
||||
auto res = this->core.read(paddr, 4, reinterpret_cast<uint8_t*>(&instr));
|
||||
if (res != iss::Ok) throw trap_access(TRAP_ID, pc.val);
|
||||
// }
|
||||
if (instr == 0x0000006f || (instr&0xffff)==0xa001) throw simulation_stopped(0); // 'J 0' or 'C.J 0'
|
||||
// curr pc on stack
|
||||
++inst_cnt;
|
||||
if (res != iss::Ok)
|
||||
return ILLEGAL_FETCH;
|
||||
if (instr == 0x0000006f || (instr&0xffff)==0xa001)
|
||||
return JUMP_TO_SELF;
|
||||
uint32_t inst_index = instr_decoder.decode_instr(instr);
|
||||
compile_func f = nullptr;
|
||||
if(inst_index < instr_descr.size())
|
||||
@ -258,9 +286,6 @@ template <typename ARCH> void vm_impl<ARCH>::gen_leave_trap(tu_builder& tu, unsi
|
||||
tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(UNKNOWN_JUMP), 32));
|
||||
}
|
||||
|
||||
template <typename ARCH> void vm_impl<ARCH>::gen_wait(tu_builder& tu, unsigned type) {
|
||||
}
|
||||
|
||||
template <typename ARCH> void vm_impl<ARCH>::gen_set_tval(tu_builder& tu, uint64_t new_tval) {
|
||||
tu(fmt::format("tval = {};", new_tval));
|
||||
}
|
||||
@ -275,6 +300,82 @@ template <typename ARCH> void vm_impl<ARCH>::gen_trap_behavior(tu_builder& tu) {
|
||||
tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(UNKNOWN_JUMP),32));
|
||||
tu("return *next_pc;");
|
||||
}
|
||||
template <typename ARCH> void vm_impl<ARCH>::add_prologue(tu_builder& tu){
|
||||
std::ostringstream os;
|
||||
os << tu.add_reg_ptr("trap_state", arch::traits<ARCH>::TRAP_STATE, this->regs_base_ptr);
|
||||
os << tu.add_reg_ptr("pending_trap", arch::traits<ARCH>::PENDING_TRAP, this->regs_base_ptr);
|
||||
os << tu.add_reg_ptr("cycle", arch::traits<ARCH>::CYCLE, this->regs_base_ptr);
|
||||
<%if(fcsr != null) {
|
||||
def flen = constants.find { it.name == 'FLEN' }?.value ?: 0
|
||||
%>
|
||||
os << "uint32_t (*fget_flags)()=" << (uintptr_t)&fget_flags << ";\\n";
|
||||
|
||||
os << "uint16_t (*fadd_h)(uint16_t v1, uint16_t v2, uint8_t mode)=" << (uintptr_t)&fadd_h << ";\\n";
|
||||
os << "uint16_t (*fsub_h)(uint16_t v1, uint16_t v2, uint8_t mode)=" << (uintptr_t)&fsub_h << ";\\n";
|
||||
os << "uint16_t (*fmul_h)(uint16_t v1, uint16_t v2, uint8_t mode)=" << (uintptr_t)&fmul_h << ";\\n";
|
||||
os << "uint16_t (*fdiv_h)(uint16_t v1, uint16_t v2, uint8_t mode)=" << (uintptr_t)&fdiv_h << ";\\n";
|
||||
os << "uint16_t (*fsqrt_h)(uint16_t v1, uint8_t mode)=" << (uintptr_t)&fsqrt_h << ";\\n";
|
||||
os << "uint16_t (*fcmp_h)(uint16_t v1, uint16_t v2, uint16_t op)=" << (uintptr_t)&fcmp_h << ";\\n";
|
||||
os << "uint16_t (*fmadd_h)(uint16_t v1, uint16_t v2, uint16_t v3, uint16_t op, uint8_t mode)=" << (uintptr_t)&fmadd_h << ";\\n";
|
||||
os << "uint16_t (*fsel_h)(uint16_t v1, uint16_t v2, uint16_t op)=" << (uintptr_t)&fsel_h << ";\\n";
|
||||
os << "uint16_t (*fclass_h)(uint16_t v1)=" << (uintptr_t)&fclass_h << ";\\n";
|
||||
os << "uint16_t (*unbox_h)(uint8_t FLEN, uint64_t v)=" << (uintptr_t)&unbox_h << ";\\n";
|
||||
|
||||
os << "uint32_t (*f16toi32)(uint32_t v1, uint8_t mode)=" << (uintptr_t)&f16toi32 << ";\\n";
|
||||
os << "uint32_t (*f16toui32)(uint32_t v1, uint8_t mode)=" << (uintptr_t)&f16toui32 << ";\\n";
|
||||
os << "uint16_t (*i32tof16)(uint32_t v1, uint8_t mode)=" << (uintptr_t)&i32tof16 << ";\\n";
|
||||
os << "uint16_t (*ui32tof16)(uint32_t v1, uint8_t mode)=" << (uintptr_t)&ui32tof16 << ";\\n";
|
||||
os << "uint64_t (*f16toi64)(uint32_t v1, uint8_t mode)=" << (uintptr_t)&f16toi64 <<";\\n";
|
||||
os << "uint64_t (*f16toui64)(uint32_t v1, uint8_t mode)=" << (uintptr_t)&f16toui64 <<";\\n";
|
||||
os << "uint16_t (*i64tof16)(uint64_t v1, uint8_t mode)=" << (uintptr_t)&i64tof16 <<";\\n";
|
||||
os << "uint16_t (*ui64tof16)(uint64_t v1, uint8_t mode)=" << (uintptr_t)&ui64tof16 <<";\\n";
|
||||
|
||||
os << "uint32_t (*fadd_s)(uint32_t v1, uint32_t v2, uint8_t mode)=" << (uintptr_t)&fadd_s << ";\\n";
|
||||
os << "uint32_t (*fsub_s)(uint32_t v1, uint32_t v2, uint8_t mode)=" << (uintptr_t)&fsub_s << ";\\n";
|
||||
os << "uint32_t (*fmul_s)(uint32_t v1, uint32_t v2, uint8_t mode)=" << (uintptr_t)&fmul_s << ";\\n";
|
||||
os << "uint32_t (*fdiv_s)(uint32_t v1, uint32_t v2, uint8_t mode)=" << (uintptr_t)&fdiv_s << ";\\n";
|
||||
os << "uint32_t (*fsqrt_s)(uint32_t v1, uint8_t mode)=" << (uintptr_t)&fsqrt_s << ";\\n";
|
||||
os << "uint32_t (*fcmp_s)(uint32_t v1, uint32_t v2, uint32_t op)=" << (uintptr_t)&fcmp_s << ";\\n";
|
||||
os << "uint32_t (*fmadd_s)(uint32_t v1, uint32_t v2, uint32_t v3, uint32_t op, uint8_t mode)=" << (uintptr_t)&fmadd_s << ";\\n";
|
||||
os << "uint32_t (*fsel_s)(uint32_t v1, uint32_t v2, uint32_t op)=" << (uintptr_t)&fsel_s << ";\\n";
|
||||
os << "uint32_t (*fclass_s)( uint32_t v1 )=" << (uintptr_t)&fclass_s << ";\\n";
|
||||
os << "uint32_t (*unbox_s)(uint8_t FLEN, uint64_t v)=" << (uintptr_t)&unbox_s << ";\\n";
|
||||
|
||||
os << "uint32_t (*f32toi32)(uint32_t v1, uint8_t mode)=" << (uintptr_t)&f32toi32 << ";\\n";
|
||||
os << "uint32_t (*f32toui32)(uint32_t v1, uint8_t mode)=" << (uintptr_t)&f32toui32 << ";\\n";
|
||||
os << "uint32_t (*i32tof32)(uint32_t v1, uint8_t mode)=" << (uintptr_t)&i32tof32 << ";\\n";
|
||||
os << "uint32_t (*ui32tof32)(uint32_t v1, uint8_t mode)=" << (uintptr_t)&ui32tof32 << ";\\n";
|
||||
os << "uint64_t (*f32toi64)(uint32_t v1, uint8_t mode)=" << (uintptr_t)&f32toi64 <<";\\n";
|
||||
os << "uint64_t (*f32toui64)(uint32_t v1, uint8_t mode)=" << (uintptr_t)&f32toui64 <<";\\n";
|
||||
os << "uint32_t (*i64tof32)(uint64_t v1, uint8_t mode)=" << (uintptr_t)&i64tof32 <<";\\n";
|
||||
os << "uint32_t (*ui64tof32)(uint64_t v1, uint8_t mode)=" << (uintptr_t)&ui64tof32 <<";\\n";
|
||||
<%if(flen > 32) {%>
|
||||
|
||||
os << "uint64_t (*fadd_d)(uint64_t v1, uint64_t v2, uint8_t mode)=" << (uintptr_t)&fadd_d << ";\\n";
|
||||
os << "uint64_t (*fsub_d)(uint64_t v1, uint64_t v2, uint8_t mode)=" << (uintptr_t)&fsub_d << ";\\n";
|
||||
os << "uint64_t (*fmul_d)(uint64_t v1, uint64_t v2, uint8_t mode)=" << (uintptr_t)&fmul_d << ";\\n";
|
||||
os << "uint64_t (*fdiv_d)(uint64_t v1, uint64_t v2, uint8_t mode)=" << (uintptr_t)&fdiv_d << ";\\n";
|
||||
os << "uint64_t (*fsqrt_d)(uint64_t v1, uint8_t mode)=" << (uintptr_t)&fsqrt_d << ";\\n";
|
||||
os << "uint64_t (*fcmp_d)(uint64_t v1, uint64_t v2, uint32_t op)=" << (uintptr_t)&fcmp_d << ";\\n";
|
||||
os << "uint64_t (*fmadd_d)(uint64_t v1, uint64_t v2, uint64_t v3, uint32_t op, uint8_t mode)=" << (uintptr_t)&fmadd_d << ";\\n";
|
||||
os << "uint64_t (*fsel_d)(uint64_t v1, uint64_t v2, uint32_t op)=" << (uintptr_t)&fsel_d << ";\\n";
|
||||
os << "uint64_t (*fclass_d)(uint64_t v1 )=" << (uintptr_t)&fclass_d << ";\\n";
|
||||
os << "uint64_t (*unbox_d)(uint8_t FLEN, uint64_t v)=" << (uintptr_t)&unbox_d << ";\\n";
|
||||
|
||||
os << "uint32_t (*f64tof32)(uint64_t v1, uint8_t mode)=" << (uintptr_t)&f64tof32 << ";\\n";
|
||||
os << "uint64_t (*f32tof64)(uint32_t v1, uint8_t mode)=" << (uintptr_t)&f32tof64 << ";\\n";
|
||||
os << "uint64_t (*f64toi64)(uint64_t v1, uint8_t mode)=" << (uintptr_t)&f64toi64 <<";\\n";
|
||||
os << "uint64_t (*f64toui64)(uint64_t v1, uint8_t mode)=" << (uintptr_t)&f64toui64 <<";\\n";
|
||||
os << "uint64_t (*i64tof64)(uint64_t v1, uint8_t mode)=" << (uintptr_t)&i64tof64 <<";\\n";
|
||||
os << "uint64_t (*ui64tof64)(uint64_t v1, uint8_t mode)=" << (uintptr_t)&ui64tof64 <<";\\n";
|
||||
os << "uint64_t (*i32tof64)(uint32_t v1, uint8_t mode)=" << (uintptr_t)&i32tof64 <<";\\n";
|
||||
os << "uint64_t (*ui32tof64)(uint32_t v1, uint8_t mode)=" << (uintptr_t)&ui32tof64 <<";\\n";
|
||||
os << "uint32_t (*f64toi32)(uint64_t v1, uint8_t mode)=" << (uintptr_t)&f64toi32 <<";\\n";
|
||||
os << "uint32_t (*f64toui32)(uint64_t v1, uint8_t mode)=" << (uintptr_t)&f64toui32 <<";\\n";
|
||||
<%}
|
||||
}%>
|
||||
tu.add_prologue(os.str());
|
||||
}
|
||||
|
||||
} // namespace ${coreDef.name.toLowerCase()}
|
||||
|
||||
|
2
softfloat/.gitignore
vendored
Normal file
2
softfloat/.gitignore
vendored
Normal file
@ -0,0 +1,2 @@
|
||||
build/*/*.o
|
||||
build/*/*.a
|
@ -1,37 +1,37 @@
|
||||
|
||||
License for Berkeley SoftFloat Release 3e
|
||||
|
||||
John R. Hauser
|
||||
2018 January 20
|
||||
|
||||
The following applies to the whole of SoftFloat Release 3e as well as to
|
||||
each source file individually.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018 The Regents of the
|
||||
University of California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions, and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors
|
||||
may be used to endorse or promote products derived from this software
|
||||
without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
|
||||
License for Berkeley SoftFloat Release 3e
|
||||
|
||||
John R. Hauser
|
||||
2018 January 20
|
||||
|
||||
The following applies to the whole of SoftFloat Release 3e as well as to
|
||||
each source file individually.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018 The Regents of the
|
||||
University of California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions, and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors
|
||||
may be used to endorse or promote products derived from this software
|
||||
without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
|
@ -1,49 +1,49 @@
|
||||
|
||||
<HTML>
|
||||
|
||||
<HEAD>
|
||||
<TITLE>Berkeley SoftFloat Package Overview</TITLE>
|
||||
</HEAD>
|
||||
|
||||
<BODY>
|
||||
|
||||
<H1>Package Overview for Berkeley SoftFloat Release 3e</H1>
|
||||
|
||||
<P>
|
||||
John R. Hauser<BR>
|
||||
2018 January 20<BR>
|
||||
</P>
|
||||
|
||||
<P>
|
||||
Berkeley SoftFloat is a software implementation of binary floating-point that
|
||||
conforms to the IEEE Standard for Floating-Point Arithmetic.
|
||||
SoftFloat is distributed in the form of C source code.
|
||||
Building the SoftFloat sources generates a library file (typically
|
||||
<CODE>softfloat.a</CODE> or <CODE>libsoftfloat.a</CODE>) containing the
|
||||
floating-point subroutines.
|
||||
</P>
|
||||
|
||||
<P>
|
||||
The SoftFloat package is documented in the following files in the
|
||||
<CODE>doc</CODE> subdirectory:
|
||||
<BLOCKQUOTE>
|
||||
<TABLE>
|
||||
<TR>
|
||||
<TD><A HREF="doc/SoftFloat.html"><NOBR><CODE>SoftFloat.html</CODE></NOBR></A></TD>
|
||||
<TD>Documentation for using the SoftFloat functions.</TD>
|
||||
</TR>
|
||||
<TR>
|
||||
<TD><A HREF="doc/SoftFloat-source.html"><NOBR><CODE>SoftFloat-source.html</CODE></NOBR></A></TD>
|
||||
<TD>Documentation for building SoftFloat.</TD>
|
||||
</TR>
|
||||
<TR>
|
||||
<TD><A HREF="doc/SoftFloat-history.html"><NOBR><CODE>SoftFloat-history.html</CODE></A><CODE> </CODE></NOBR></TD>
|
||||
<TD>History of the major changes to SoftFloat.</TD>
|
||||
</TR>
|
||||
</TABLE>
|
||||
</BLOCKQUOTE>
|
||||
Other files in the package comprise the source code for SoftFloat.
|
||||
</P>
|
||||
|
||||
</BODY>
|
||||
|
||||
|
||||
<HTML>
|
||||
|
||||
<HEAD>
|
||||
<TITLE>Berkeley SoftFloat Package Overview</TITLE>
|
||||
</HEAD>
|
||||
|
||||
<BODY>
|
||||
|
||||
<H1>Package Overview for Berkeley SoftFloat Release 3e</H1>
|
||||
|
||||
<P>
|
||||
John R. Hauser<BR>
|
||||
2018 January 20<BR>
|
||||
</P>
|
||||
|
||||
<P>
|
||||
Berkeley SoftFloat is a software implementation of binary floating-point that
|
||||
conforms to the IEEE Standard for Floating-Point Arithmetic.
|
||||
SoftFloat is distributed in the form of C source code.
|
||||
Building the SoftFloat sources generates a library file (typically
|
||||
<CODE>softfloat.a</CODE> or <CODE>libsoftfloat.a</CODE>) containing the
|
||||
floating-point subroutines.
|
||||
</P>
|
||||
|
||||
<P>
|
||||
The SoftFloat package is documented in the following files in the
|
||||
<CODE>doc</CODE> subdirectory:
|
||||
<BLOCKQUOTE>
|
||||
<TABLE>
|
||||
<TR>
|
||||
<TD><A HREF="doc/SoftFloat.html"><NOBR><CODE>SoftFloat.html</CODE></NOBR></A></TD>
|
||||
<TD>Documentation for using the SoftFloat functions.</TD>
|
||||
</TR>
|
||||
<TR>
|
||||
<TD><A HREF="doc/SoftFloat-source.html"><NOBR><CODE>SoftFloat-source.html</CODE></NOBR></A></TD>
|
||||
<TD>Documentation for building SoftFloat.</TD>
|
||||
</TR>
|
||||
<TR>
|
||||
<TD><A HREF="doc/SoftFloat-history.html"><NOBR><CODE>SoftFloat-history.html</CODE></A><CODE> </CODE></NOBR></TD>
|
||||
<TD>History of the major changes to SoftFloat.</TD>
|
||||
</TR>
|
||||
</TABLE>
|
||||
</BLOCKQUOTE>
|
||||
Other files in the package comprise the source code for SoftFloat.
|
||||
</P>
|
||||
|
||||
</BODY>
|
||||
|
||||
|
24
softfloat/README.md
Normal file
24
softfloat/README.md
Normal file
@ -0,0 +1,24 @@
|
||||
|
||||
Package Overview for Berkeley SoftFloat Release 3e
|
||||
==================================================
|
||||
|
||||
John R. Hauser<br>
|
||||
2018 January 20
|
||||
|
||||
|
||||
Berkeley SoftFloat is a software implementation of binary floating-point
|
||||
that conforms to the IEEE Standard for Floating-Point Arithmetic. SoftFloat
|
||||
is distributed in the form of C source code. Building the SoftFloat sources
|
||||
generates a library file (typically `softfloat.a` or `libsoftfloat.a`)
|
||||
containing the floating-point subroutines.
|
||||
|
||||
|
||||
The SoftFloat package is documented in the following files in the `doc`
|
||||
subdirectory:
|
||||
|
||||
* [SoftFloat.html](http://www.jhauser.us/arithmetic/SoftFloat-3/doc/SoftFloat.html) Documentation for using the SoftFloat functions.
|
||||
* [SoftFloat-source.html](http://www.jhauser.us/arithmetic/SoftFloat-3/doc/SoftFloat-source.html) Documentation for building SoftFloat.
|
||||
* [SoftFloat-history.html](http://www.jhauser.us/arithmetic/SoftFloat-3/doc/SoftFloat-history.html) History of the major changes to SoftFloat.
|
||||
|
||||
Other files in the package comprise the source code for SoftFloat.
|
||||
|
@ -1,21 +1,21 @@
|
||||
|
||||
Package Overview for Berkeley SoftFloat Release 3e
|
||||
|
||||
John R. Hauser
|
||||
2018 January 20
|
||||
|
||||
Berkeley SoftFloat is a software implementation of binary floating-point
|
||||
that conforms to the IEEE Standard for Floating-Point Arithmetic. SoftFloat
|
||||
is distributed in the form of C source code. Building the SoftFloat sources
|
||||
generates a library file (typically "softfloat.a" or "libsoftfloat.a")
|
||||
containing the floating-point subroutines.
|
||||
|
||||
The SoftFloat package is documented in the following files in the "doc"
|
||||
subdirectory:
|
||||
|
||||
SoftFloat.html Documentation for using the SoftFloat functions.
|
||||
SoftFloat-source.html Documentation for building SoftFloat.
|
||||
SoftFloat-history.html History of the major changes to SoftFloat.
|
||||
|
||||
Other files in the package comprise the source code for SoftFloat.
|
||||
|
||||
|
||||
Package Overview for Berkeley SoftFloat Release 3e
|
||||
|
||||
John R. Hauser
|
||||
2018 January 20
|
||||
|
||||
Berkeley SoftFloat is a software implementation of binary floating-point
|
||||
that conforms to the IEEE Standard for Floating-Point Arithmetic. SoftFloat
|
||||
is distributed in the form of C source code. Building the SoftFloat sources
|
||||
generates a library file (typically "softfloat.a" or "libsoftfloat.a")
|
||||
containing the floating-point subroutines.
|
||||
|
||||
The SoftFloat package is documented in the following files in the "doc"
|
||||
subdirectory:
|
||||
|
||||
SoftFloat.html Documentation for using the SoftFloat functions.
|
||||
SoftFloat-source.html Documentation for building SoftFloat.
|
||||
SoftFloat-history.html History of the major changes to SoftFloat.
|
||||
|
||||
Other files in the package comprise the source code for SoftFloat.
|
||||
|
||||
|
@ -1,325 +1,325 @@
|
||||
|
||||
#=============================================================================
|
||||
#
|
||||
# This Makefile is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
# Package, Release 3e, by John R. Hauser.
|
||||
#
|
||||
# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
|
||||
# University of California. All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions are met:
|
||||
#
|
||||
# 1. Redistributions of source code must retain the above copyright notice,
|
||||
# this list of conditions, and the following disclaimer.
|
||||
#
|
||||
# 2. Redistributions in binary form must reproduce the above copyright
|
||||
# notice, this list of conditions, and the following disclaimer in the
|
||||
# documentation and/or other materials provided with the distribution.
|
||||
#
|
||||
# 3. Neither the name of the University nor the names of its contributors
|
||||
# may be used to endorse or promote products derived from this software
|
||||
# without specific prior written permission.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
# DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
#
|
||||
#=============================================================================
|
||||
|
||||
SOURCE_DIR ?= ../../source
|
||||
SPECIALIZE_TYPE ?= 8086
|
||||
|
||||
SOFTFLOAT_OPTS ?= \
|
||||
-DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \
|
||||
-DSOFTFLOAT_FAST_DIV64TO32
|
||||
|
||||
DELETE = rm -f
|
||||
C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include
|
||||
COMPILE_C = \
|
||||
gcc -c -Werror-implicit-function-declaration $(SOFTFLOAT_OPTS) \
|
||||
$(C_INCLUDES) -O2 -o $@
|
||||
MAKELIB = ar crs $@
|
||||
|
||||
OBJ = .o
|
||||
LIB = .a
|
||||
|
||||
OTHER_HEADERS =
|
||||
|
||||
.PHONY: all
|
||||
all: softfloat$(LIB)
|
||||
|
||||
OBJS_PRIMITIVES = \
|
||||
s_compare96M$(OBJ) \
|
||||
s_compare128M$(OBJ) \
|
||||
s_shortShiftLeft64To96M$(OBJ) \
|
||||
s_shortShiftLeftM$(OBJ) \
|
||||
s_shiftLeftM$(OBJ) \
|
||||
s_shortShiftRightM$(OBJ) \
|
||||
s_shortShiftRightJam64$(OBJ) \
|
||||
s_shortShiftRightJamM$(OBJ) \
|
||||
s_shiftRightJam32$(OBJ) \
|
||||
s_shiftRightJam64$(OBJ) \
|
||||
s_shiftRightJamM$(OBJ) \
|
||||
s_shiftRightM$(OBJ) \
|
||||
s_countLeadingZeros8$(OBJ) \
|
||||
s_countLeadingZeros16$(OBJ) \
|
||||
s_countLeadingZeros32$(OBJ) \
|
||||
s_countLeadingZeros64$(OBJ) \
|
||||
s_addM$(OBJ) \
|
||||
s_addCarryM$(OBJ) \
|
||||
s_addComplCarryM$(OBJ) \
|
||||
s_negXM$(OBJ) \
|
||||
s_sub1XM$(OBJ) \
|
||||
s_subM$(OBJ) \
|
||||
s_mul64To128M$(OBJ) \
|
||||
s_mul128MTo256M$(OBJ) \
|
||||
s_approxRecip_1Ks$(OBJ) \
|
||||
s_approxRecip32_1$(OBJ) \
|
||||
s_approxRecipSqrt_1Ks$(OBJ) \
|
||||
s_approxRecipSqrt32_1$(OBJ) \
|
||||
s_remStepMBy32$(OBJ) \
|
||||
|
||||
OBJS_SPECIALIZE = \
|
||||
softfloat_raiseFlags$(OBJ) \
|
||||
s_f16UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF16UI$(OBJ) \
|
||||
s_propagateNaNF16UI$(OBJ) \
|
||||
s_f32UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF32UI$(OBJ) \
|
||||
s_propagateNaNF32UI$(OBJ) \
|
||||
s_f64UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF64UI$(OBJ) \
|
||||
s_propagateNaNF64UI$(OBJ) \
|
||||
extF80M_isSignalingNaN$(OBJ) \
|
||||
s_extF80MToCommonNaN$(OBJ) \
|
||||
s_commonNaNToExtF80M$(OBJ) \
|
||||
s_propagateNaNExtF80M$(OBJ) \
|
||||
f128M_isSignalingNaN$(OBJ) \
|
||||
s_f128MToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF128M$(OBJ) \
|
||||
s_propagateNaNF128M$(OBJ) \
|
||||
|
||||
OBJS_OTHERS = \
|
||||
s_roundToUI32$(OBJ) \
|
||||
s_roundMToUI64$(OBJ) \
|
||||
s_roundToI32$(OBJ) \
|
||||
s_roundMToI64$(OBJ) \
|
||||
s_normSubnormalF16Sig$(OBJ) \
|
||||
s_roundPackToF16$(OBJ) \
|
||||
s_normRoundPackToF16$(OBJ) \
|
||||
s_addMagsF16$(OBJ) \
|
||||
s_subMagsF16$(OBJ) \
|
||||
s_mulAddF16$(OBJ) \
|
||||
s_normSubnormalF32Sig$(OBJ) \
|
||||
s_roundPackToF32$(OBJ) \
|
||||
s_normRoundPackToF32$(OBJ) \
|
||||
s_addMagsF32$(OBJ) \
|
||||
s_subMagsF32$(OBJ) \
|
||||
s_mulAddF32$(OBJ) \
|
||||
s_normSubnormalF64Sig$(OBJ) \
|
||||
s_roundPackToF64$(OBJ) \
|
||||
s_normRoundPackToF64$(OBJ) \
|
||||
s_addMagsF64$(OBJ) \
|
||||
s_subMagsF64$(OBJ) \
|
||||
s_mulAddF64$(OBJ) \
|
||||
s_tryPropagateNaNExtF80M$(OBJ) \
|
||||
s_invalidExtF80M$(OBJ) \
|
||||
s_normExtF80SigM$(OBJ) \
|
||||
s_roundPackMToExtF80M$(OBJ) \
|
||||
s_normRoundPackMToExtF80M$(OBJ) \
|
||||
s_addExtF80M$(OBJ) \
|
||||
s_compareNonnormExtF80M$(OBJ) \
|
||||
s_isNaNF128M$(OBJ) \
|
||||
s_tryPropagateNaNF128M$(OBJ) \
|
||||
s_invalidF128M$(OBJ) \
|
||||
s_shiftNormSigF128M$(OBJ) \
|
||||
s_roundPackMToF128M$(OBJ) \
|
||||
s_normRoundPackMToF128M$(OBJ) \
|
||||
s_addF128M$(OBJ) \
|
||||
s_mulAddF128M$(OBJ) \
|
||||
softfloat_state$(OBJ) \
|
||||
ui32_to_f16$(OBJ) \
|
||||
ui32_to_f32$(OBJ) \
|
||||
ui32_to_f64$(OBJ) \
|
||||
ui32_to_extF80M$(OBJ) \
|
||||
ui32_to_f128M$(OBJ) \
|
||||
ui64_to_f16$(OBJ) \
|
||||
ui64_to_f32$(OBJ) \
|
||||
ui64_to_f64$(OBJ) \
|
||||
ui64_to_extF80M$(OBJ) \
|
||||
ui64_to_f128M$(OBJ) \
|
||||
i32_to_f16$(OBJ) \
|
||||
i32_to_f32$(OBJ) \
|
||||
i32_to_f64$(OBJ) \
|
||||
i32_to_extF80M$(OBJ) \
|
||||
i32_to_f128M$(OBJ) \
|
||||
i64_to_f16$(OBJ) \
|
||||
i64_to_f32$(OBJ) \
|
||||
i64_to_f64$(OBJ) \
|
||||
i64_to_extF80M$(OBJ) \
|
||||
i64_to_f128M$(OBJ) \
|
||||
f16_to_ui32$(OBJ) \
|
||||
f16_to_ui64$(OBJ) \
|
||||
f16_to_i32$(OBJ) \
|
||||
f16_to_i64$(OBJ) \
|
||||
f16_to_ui32_r_minMag$(OBJ) \
|
||||
f16_to_ui64_r_minMag$(OBJ) \
|
||||
f16_to_i32_r_minMag$(OBJ) \
|
||||
f16_to_i64_r_minMag$(OBJ) \
|
||||
f16_to_f32$(OBJ) \
|
||||
f16_to_f64$(OBJ) \
|
||||
f16_to_extF80M$(OBJ) \
|
||||
f16_to_f128M$(OBJ) \
|
||||
f16_roundToInt$(OBJ) \
|
||||
f16_add$(OBJ) \
|
||||
f16_sub$(OBJ) \
|
||||
f16_mul$(OBJ) \
|
||||
f16_mulAdd$(OBJ) \
|
||||
f16_div$(OBJ) \
|
||||
f16_rem$(OBJ) \
|
||||
f16_sqrt$(OBJ) \
|
||||
f16_eq$(OBJ) \
|
||||
f16_le$(OBJ) \
|
||||
f16_lt$(OBJ) \
|
||||
f16_eq_signaling$(OBJ) \
|
||||
f16_le_quiet$(OBJ) \
|
||||
f16_lt_quiet$(OBJ) \
|
||||
f16_isSignalingNaN$(OBJ) \
|
||||
f32_to_ui32$(OBJ) \
|
||||
f32_to_ui64$(OBJ) \
|
||||
f32_to_i32$(OBJ) \
|
||||
f32_to_i64$(OBJ) \
|
||||
f32_to_ui32_r_minMag$(OBJ) \
|
||||
f32_to_ui64_r_minMag$(OBJ) \
|
||||
f32_to_i32_r_minMag$(OBJ) \
|
||||
f32_to_i64_r_minMag$(OBJ) \
|
||||
f32_to_f16$(OBJ) \
|
||||
f32_to_f64$(OBJ) \
|
||||
f32_to_extF80M$(OBJ) \
|
||||
f32_to_f128M$(OBJ) \
|
||||
f32_roundToInt$(OBJ) \
|
||||
f32_add$(OBJ) \
|
||||
f32_sub$(OBJ) \
|
||||
f32_mul$(OBJ) \
|
||||
f32_mulAdd$(OBJ) \
|
||||
f32_div$(OBJ) \
|
||||
f32_rem$(OBJ) \
|
||||
f32_sqrt$(OBJ) \
|
||||
f32_eq$(OBJ) \
|
||||
f32_le$(OBJ) \
|
||||
f32_lt$(OBJ) \
|
||||
f32_eq_signaling$(OBJ) \
|
||||
f32_le_quiet$(OBJ) \
|
||||
f32_lt_quiet$(OBJ) \
|
||||
f32_isSignalingNaN$(OBJ) \
|
||||
f64_to_ui32$(OBJ) \
|
||||
f64_to_ui64$(OBJ) \
|
||||
f64_to_i32$(OBJ) \
|
||||
f64_to_i64$(OBJ) \
|
||||
f64_to_ui32_r_minMag$(OBJ) \
|
||||
f64_to_ui64_r_minMag$(OBJ) \
|
||||
f64_to_i32_r_minMag$(OBJ) \
|
||||
f64_to_i64_r_minMag$(OBJ) \
|
||||
f64_to_f16$(OBJ) \
|
||||
f64_to_f32$(OBJ) \
|
||||
f64_to_extF80M$(OBJ) \
|
||||
f64_to_f128M$(OBJ) \
|
||||
f64_roundToInt$(OBJ) \
|
||||
f64_add$(OBJ) \
|
||||
f64_sub$(OBJ) \
|
||||
f64_mul$(OBJ) \
|
||||
f64_mulAdd$(OBJ) \
|
||||
f64_div$(OBJ) \
|
||||
f64_rem$(OBJ) \
|
||||
f64_sqrt$(OBJ) \
|
||||
f64_eq$(OBJ) \
|
||||
f64_le$(OBJ) \
|
||||
f64_lt$(OBJ) \
|
||||
f64_eq_signaling$(OBJ) \
|
||||
f64_le_quiet$(OBJ) \
|
||||
f64_lt_quiet$(OBJ) \
|
||||
f64_isSignalingNaN$(OBJ) \
|
||||
extF80M_to_ui32$(OBJ) \
|
||||
extF80M_to_ui64$(OBJ) \
|
||||
extF80M_to_i32$(OBJ) \
|
||||
extF80M_to_i64$(OBJ) \
|
||||
extF80M_to_ui32_r_minMag$(OBJ) \
|
||||
extF80M_to_ui64_r_minMag$(OBJ) \
|
||||
extF80M_to_i32_r_minMag$(OBJ) \
|
||||
extF80M_to_i64_r_minMag$(OBJ) \
|
||||
extF80M_to_f16$(OBJ) \
|
||||
extF80M_to_f32$(OBJ) \
|
||||
extF80M_to_f64$(OBJ) \
|
||||
extF80M_to_f128M$(OBJ) \
|
||||
extF80M_roundToInt$(OBJ) \
|
||||
extF80M_add$(OBJ) \
|
||||
extF80M_sub$(OBJ) \
|
||||
extF80M_mul$(OBJ) \
|
||||
extF80M_div$(OBJ) \
|
||||
extF80M_rem$(OBJ) \
|
||||
extF80M_sqrt$(OBJ) \
|
||||
extF80M_eq$(OBJ) \
|
||||
extF80M_le$(OBJ) \
|
||||
extF80M_lt$(OBJ) \
|
||||
extF80M_eq_signaling$(OBJ) \
|
||||
extF80M_le_quiet$(OBJ) \
|
||||
extF80M_lt_quiet$(OBJ) \
|
||||
f128M_to_ui32$(OBJ) \
|
||||
f128M_to_ui64$(OBJ) \
|
||||
f128M_to_i32$(OBJ) \
|
||||
f128M_to_i64$(OBJ) \
|
||||
f128M_to_ui32_r_minMag$(OBJ) \
|
||||
f128M_to_ui64_r_minMag$(OBJ) \
|
||||
f128M_to_i32_r_minMag$(OBJ) \
|
||||
f128M_to_i64_r_minMag$(OBJ) \
|
||||
f128M_to_f16$(OBJ) \
|
||||
f128M_to_f32$(OBJ) \
|
||||
f128M_to_f64$(OBJ) \
|
||||
f128M_to_extF80M$(OBJ) \
|
||||
f128M_roundToInt$(OBJ) \
|
||||
f128M_add$(OBJ) \
|
||||
f128M_sub$(OBJ) \
|
||||
f128M_mul$(OBJ) \
|
||||
f128M_mulAdd$(OBJ) \
|
||||
f128M_div$(OBJ) \
|
||||
f128M_rem$(OBJ) \
|
||||
f128M_sqrt$(OBJ) \
|
||||
f128M_eq$(OBJ) \
|
||||
f128M_le$(OBJ) \
|
||||
f128M_lt$(OBJ) \
|
||||
f128M_eq_signaling$(OBJ) \
|
||||
f128M_le_quiet$(OBJ) \
|
||||
f128M_lt_quiet$(OBJ) \
|
||||
|
||||
OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS)
|
||||
|
||||
$(OBJS_ALL): \
|
||||
$(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \
|
||||
$(SOURCE_DIR)/include/primitives.h
|
||||
$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \
|
||||
$(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \
|
||||
$(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \
|
||||
$(SOURCE_DIR)/include/softfloat.h
|
||||
|
||||
$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c
|
||||
$(COMPILE_C) $(SOURCE_DIR)/$*.c
|
||||
|
||||
$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c
|
||||
$(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c
|
||||
|
||||
softfloat$(LIB): $(OBJS_ALL)
|
||||
$(DELETE) $@
|
||||
$(MAKELIB) $^
|
||||
|
||||
.PHONY: clean
|
||||
clean:
|
||||
$(DELETE) $(OBJS_ALL) softfloat$(LIB)
|
||||
|
||||
|
||||
#=============================================================================
|
||||
#
|
||||
# This Makefile is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
# Package, Release 3e, by John R. Hauser.
|
||||
#
|
||||
# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
|
||||
# University of California. All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions are met:
|
||||
#
|
||||
# 1. Redistributions of source code must retain the above copyright notice,
|
||||
# this list of conditions, and the following disclaimer.
|
||||
#
|
||||
# 2. Redistributions in binary form must reproduce the above copyright
|
||||
# notice, this list of conditions, and the following disclaimer in the
|
||||
# documentation and/or other materials provided with the distribution.
|
||||
#
|
||||
# 3. Neither the name of the University nor the names of its contributors
|
||||
# may be used to endorse or promote products derived from this software
|
||||
# without specific prior written permission.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
# DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
#
|
||||
#=============================================================================
|
||||
|
||||
SOURCE_DIR ?= ../../source
|
||||
SPECIALIZE_TYPE ?= 8086
|
||||
|
||||
SOFTFLOAT_OPTS ?= \
|
||||
-DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \
|
||||
-DSOFTFLOAT_FAST_DIV64TO32
|
||||
|
||||
DELETE = rm -f
|
||||
C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include
|
||||
COMPILE_C = \
|
||||
gcc -c -Werror-implicit-function-declaration $(SOFTFLOAT_OPTS) \
|
||||
$(C_INCLUDES) -O2 -o $@
|
||||
MAKELIB = ar crs $@
|
||||
|
||||
OBJ = .o
|
||||
LIB = .a
|
||||
|
||||
OTHER_HEADERS =
|
||||
|
||||
.PHONY: all
|
||||
all: softfloat$(LIB)
|
||||
|
||||
OBJS_PRIMITIVES = \
|
||||
s_compare96M$(OBJ) \
|
||||
s_compare128M$(OBJ) \
|
||||
s_shortShiftLeft64To96M$(OBJ) \
|
||||
s_shortShiftLeftM$(OBJ) \
|
||||
s_shiftLeftM$(OBJ) \
|
||||
s_shortShiftRightM$(OBJ) \
|
||||
s_shortShiftRightJam64$(OBJ) \
|
||||
s_shortShiftRightJamM$(OBJ) \
|
||||
s_shiftRightJam32$(OBJ) \
|
||||
s_shiftRightJam64$(OBJ) \
|
||||
s_shiftRightJamM$(OBJ) \
|
||||
s_shiftRightM$(OBJ) \
|
||||
s_countLeadingZeros8$(OBJ) \
|
||||
s_countLeadingZeros16$(OBJ) \
|
||||
s_countLeadingZeros32$(OBJ) \
|
||||
s_countLeadingZeros64$(OBJ) \
|
||||
s_addM$(OBJ) \
|
||||
s_addCarryM$(OBJ) \
|
||||
s_addComplCarryM$(OBJ) \
|
||||
s_negXM$(OBJ) \
|
||||
s_sub1XM$(OBJ) \
|
||||
s_subM$(OBJ) \
|
||||
s_mul64To128M$(OBJ) \
|
||||
s_mul128MTo256M$(OBJ) \
|
||||
s_approxRecip_1Ks$(OBJ) \
|
||||
s_approxRecip32_1$(OBJ) \
|
||||
s_approxRecipSqrt_1Ks$(OBJ) \
|
||||
s_approxRecipSqrt32_1$(OBJ) \
|
||||
s_remStepMBy32$(OBJ) \
|
||||
|
||||
OBJS_SPECIALIZE = \
|
||||
softfloat_raiseFlags$(OBJ) \
|
||||
s_f16UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF16UI$(OBJ) \
|
||||
s_propagateNaNF16UI$(OBJ) \
|
||||
s_f32UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF32UI$(OBJ) \
|
||||
s_propagateNaNF32UI$(OBJ) \
|
||||
s_f64UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF64UI$(OBJ) \
|
||||
s_propagateNaNF64UI$(OBJ) \
|
||||
extF80M_isSignalingNaN$(OBJ) \
|
||||
s_extF80MToCommonNaN$(OBJ) \
|
||||
s_commonNaNToExtF80M$(OBJ) \
|
||||
s_propagateNaNExtF80M$(OBJ) \
|
||||
f128M_isSignalingNaN$(OBJ) \
|
||||
s_f128MToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF128M$(OBJ) \
|
||||
s_propagateNaNF128M$(OBJ) \
|
||||
|
||||
OBJS_OTHERS = \
|
||||
s_roundToUI32$(OBJ) \
|
||||
s_roundMToUI64$(OBJ) \
|
||||
s_roundToI32$(OBJ) \
|
||||
s_roundMToI64$(OBJ) \
|
||||
s_normSubnormalF16Sig$(OBJ) \
|
||||
s_roundPackToF16$(OBJ) \
|
||||
s_normRoundPackToF16$(OBJ) \
|
||||
s_addMagsF16$(OBJ) \
|
||||
s_subMagsF16$(OBJ) \
|
||||
s_mulAddF16$(OBJ) \
|
||||
s_normSubnormalF32Sig$(OBJ) \
|
||||
s_roundPackToF32$(OBJ) \
|
||||
s_normRoundPackToF32$(OBJ) \
|
||||
s_addMagsF32$(OBJ) \
|
||||
s_subMagsF32$(OBJ) \
|
||||
s_mulAddF32$(OBJ) \
|
||||
s_normSubnormalF64Sig$(OBJ) \
|
||||
s_roundPackToF64$(OBJ) \
|
||||
s_normRoundPackToF64$(OBJ) \
|
||||
s_addMagsF64$(OBJ) \
|
||||
s_subMagsF64$(OBJ) \
|
||||
s_mulAddF64$(OBJ) \
|
||||
s_tryPropagateNaNExtF80M$(OBJ) \
|
||||
s_invalidExtF80M$(OBJ) \
|
||||
s_normExtF80SigM$(OBJ) \
|
||||
s_roundPackMToExtF80M$(OBJ) \
|
||||
s_normRoundPackMToExtF80M$(OBJ) \
|
||||
s_addExtF80M$(OBJ) \
|
||||
s_compareNonnormExtF80M$(OBJ) \
|
||||
s_isNaNF128M$(OBJ) \
|
||||
s_tryPropagateNaNF128M$(OBJ) \
|
||||
s_invalidF128M$(OBJ) \
|
||||
s_shiftNormSigF128M$(OBJ) \
|
||||
s_roundPackMToF128M$(OBJ) \
|
||||
s_normRoundPackMToF128M$(OBJ) \
|
||||
s_addF128M$(OBJ) \
|
||||
s_mulAddF128M$(OBJ) \
|
||||
softfloat_state$(OBJ) \
|
||||
ui32_to_f16$(OBJ) \
|
||||
ui32_to_f32$(OBJ) \
|
||||
ui32_to_f64$(OBJ) \
|
||||
ui32_to_extF80M$(OBJ) \
|
||||
ui32_to_f128M$(OBJ) \
|
||||
ui64_to_f16$(OBJ) \
|
||||
ui64_to_f32$(OBJ) \
|
||||
ui64_to_f64$(OBJ) \
|
||||
ui64_to_extF80M$(OBJ) \
|
||||
ui64_to_f128M$(OBJ) \
|
||||
i32_to_f16$(OBJ) \
|
||||
i32_to_f32$(OBJ) \
|
||||
i32_to_f64$(OBJ) \
|
||||
i32_to_extF80M$(OBJ) \
|
||||
i32_to_f128M$(OBJ) \
|
||||
i64_to_f16$(OBJ) \
|
||||
i64_to_f32$(OBJ) \
|
||||
i64_to_f64$(OBJ) \
|
||||
i64_to_extF80M$(OBJ) \
|
||||
i64_to_f128M$(OBJ) \
|
||||
f16_to_ui32$(OBJ) \
|
||||
f16_to_ui64$(OBJ) \
|
||||
f16_to_i32$(OBJ) \
|
||||
f16_to_i64$(OBJ) \
|
||||
f16_to_ui32_r_minMag$(OBJ) \
|
||||
f16_to_ui64_r_minMag$(OBJ) \
|
||||
f16_to_i32_r_minMag$(OBJ) \
|
||||
f16_to_i64_r_minMag$(OBJ) \
|
||||
f16_to_f32$(OBJ) \
|
||||
f16_to_f64$(OBJ) \
|
||||
f16_to_extF80M$(OBJ) \
|
||||
f16_to_f128M$(OBJ) \
|
||||
f16_roundToInt$(OBJ) \
|
||||
f16_add$(OBJ) \
|
||||
f16_sub$(OBJ) \
|
||||
f16_mul$(OBJ) \
|
||||
f16_mulAdd$(OBJ) \
|
||||
f16_div$(OBJ) \
|
||||
f16_rem$(OBJ) \
|
||||
f16_sqrt$(OBJ) \
|
||||
f16_eq$(OBJ) \
|
||||
f16_le$(OBJ) \
|
||||
f16_lt$(OBJ) \
|
||||
f16_eq_signaling$(OBJ) \
|
||||
f16_le_quiet$(OBJ) \
|
||||
f16_lt_quiet$(OBJ) \
|
||||
f16_isSignalingNaN$(OBJ) \
|
||||
f32_to_ui32$(OBJ) \
|
||||
f32_to_ui64$(OBJ) \
|
||||
f32_to_i32$(OBJ) \
|
||||
f32_to_i64$(OBJ) \
|
||||
f32_to_ui32_r_minMag$(OBJ) \
|
||||
f32_to_ui64_r_minMag$(OBJ) \
|
||||
f32_to_i32_r_minMag$(OBJ) \
|
||||
f32_to_i64_r_minMag$(OBJ) \
|
||||
f32_to_f16$(OBJ) \
|
||||
f32_to_f64$(OBJ) \
|
||||
f32_to_extF80M$(OBJ) \
|
||||
f32_to_f128M$(OBJ) \
|
||||
f32_roundToInt$(OBJ) \
|
||||
f32_add$(OBJ) \
|
||||
f32_sub$(OBJ) \
|
||||
f32_mul$(OBJ) \
|
||||
f32_mulAdd$(OBJ) \
|
||||
f32_div$(OBJ) \
|
||||
f32_rem$(OBJ) \
|
||||
f32_sqrt$(OBJ) \
|
||||
f32_eq$(OBJ) \
|
||||
f32_le$(OBJ) \
|
||||
f32_lt$(OBJ) \
|
||||
f32_eq_signaling$(OBJ) \
|
||||
f32_le_quiet$(OBJ) \
|
||||
f32_lt_quiet$(OBJ) \
|
||||
f32_isSignalingNaN$(OBJ) \
|
||||
f64_to_ui32$(OBJ) \
|
||||
f64_to_ui64$(OBJ) \
|
||||
f64_to_i32$(OBJ) \
|
||||
f64_to_i64$(OBJ) \
|
||||
f64_to_ui32_r_minMag$(OBJ) \
|
||||
f64_to_ui64_r_minMag$(OBJ) \
|
||||
f64_to_i32_r_minMag$(OBJ) \
|
||||
f64_to_i64_r_minMag$(OBJ) \
|
||||
f64_to_f16$(OBJ) \
|
||||
f64_to_f32$(OBJ) \
|
||||
f64_to_extF80M$(OBJ) \
|
||||
f64_to_f128M$(OBJ) \
|
||||
f64_roundToInt$(OBJ) \
|
||||
f64_add$(OBJ) \
|
||||
f64_sub$(OBJ) \
|
||||
f64_mul$(OBJ) \
|
||||
f64_mulAdd$(OBJ) \
|
||||
f64_div$(OBJ) \
|
||||
f64_rem$(OBJ) \
|
||||
f64_sqrt$(OBJ) \
|
||||
f64_eq$(OBJ) \
|
||||
f64_le$(OBJ) \
|
||||
f64_lt$(OBJ) \
|
||||
f64_eq_signaling$(OBJ) \
|
||||
f64_le_quiet$(OBJ) \
|
||||
f64_lt_quiet$(OBJ) \
|
||||
f64_isSignalingNaN$(OBJ) \
|
||||
extF80M_to_ui32$(OBJ) \
|
||||
extF80M_to_ui64$(OBJ) \
|
||||
extF80M_to_i32$(OBJ) \
|
||||
extF80M_to_i64$(OBJ) \
|
||||
extF80M_to_ui32_r_minMag$(OBJ) \
|
||||
extF80M_to_ui64_r_minMag$(OBJ) \
|
||||
extF80M_to_i32_r_minMag$(OBJ) \
|
||||
extF80M_to_i64_r_minMag$(OBJ) \
|
||||
extF80M_to_f16$(OBJ) \
|
||||
extF80M_to_f32$(OBJ) \
|
||||
extF80M_to_f64$(OBJ) \
|
||||
extF80M_to_f128M$(OBJ) \
|
||||
extF80M_roundToInt$(OBJ) \
|
||||
extF80M_add$(OBJ) \
|
||||
extF80M_sub$(OBJ) \
|
||||
extF80M_mul$(OBJ) \
|
||||
extF80M_div$(OBJ) \
|
||||
extF80M_rem$(OBJ) \
|
||||
extF80M_sqrt$(OBJ) \
|
||||
extF80M_eq$(OBJ) \
|
||||
extF80M_le$(OBJ) \
|
||||
extF80M_lt$(OBJ) \
|
||||
extF80M_eq_signaling$(OBJ) \
|
||||
extF80M_le_quiet$(OBJ) \
|
||||
extF80M_lt_quiet$(OBJ) \
|
||||
f128M_to_ui32$(OBJ) \
|
||||
f128M_to_ui64$(OBJ) \
|
||||
f128M_to_i32$(OBJ) \
|
||||
f128M_to_i64$(OBJ) \
|
||||
f128M_to_ui32_r_minMag$(OBJ) \
|
||||
f128M_to_ui64_r_minMag$(OBJ) \
|
||||
f128M_to_i32_r_minMag$(OBJ) \
|
||||
f128M_to_i64_r_minMag$(OBJ) \
|
||||
f128M_to_f16$(OBJ) \
|
||||
f128M_to_f32$(OBJ) \
|
||||
f128M_to_f64$(OBJ) \
|
||||
f128M_to_extF80M$(OBJ) \
|
||||
f128M_roundToInt$(OBJ) \
|
||||
f128M_add$(OBJ) \
|
||||
f128M_sub$(OBJ) \
|
||||
f128M_mul$(OBJ) \
|
||||
f128M_mulAdd$(OBJ) \
|
||||
f128M_div$(OBJ) \
|
||||
f128M_rem$(OBJ) \
|
||||
f128M_sqrt$(OBJ) \
|
||||
f128M_eq$(OBJ) \
|
||||
f128M_le$(OBJ) \
|
||||
f128M_lt$(OBJ) \
|
||||
f128M_eq_signaling$(OBJ) \
|
||||
f128M_le_quiet$(OBJ) \
|
||||
f128M_lt_quiet$(OBJ) \
|
||||
|
||||
OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS)
|
||||
|
||||
$(OBJS_ALL): \
|
||||
$(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \
|
||||
$(SOURCE_DIR)/include/primitives.h
|
||||
$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \
|
||||
$(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \
|
||||
$(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \
|
||||
$(SOURCE_DIR)/include/softfloat.h
|
||||
|
||||
$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c
|
||||
$(COMPILE_C) $(SOURCE_DIR)/$*.c
|
||||
|
||||
$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c
|
||||
$(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c
|
||||
|
||||
softfloat$(LIB): $(OBJS_ALL)
|
||||
$(DELETE) $@
|
||||
$(MAKELIB) $^
|
||||
|
||||
.PHONY: clean
|
||||
clean:
|
||||
$(DELETE) $(OBJS_ALL) softfloat$(LIB)
|
||||
|
||||
|
@ -1,52 +1,53 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
|
||||
University of California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define LITTLEENDIAN 1
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#ifdef __GNUC_STDC_INLINE__
|
||||
#define INLINE inline
|
||||
#else
|
||||
#define INLINE extern inline
|
||||
#endif
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define SOFTFLOAT_BUILTIN_CLZ 1
|
||||
#include "opts-GCC.h"
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
|
||||
University of California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define LITTLEENDIAN 1
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#ifdef __GNUC_STDC_INLINE__
|
||||
#define INLINE inline
|
||||
#else
|
||||
#define INLINE extern inline
|
||||
#endif
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define SOFTFLOAT_BUILTIN_CLZ 1
|
||||
#include "opts-GCC.h"
|
||||
|
||||
|
@ -1,325 +1,325 @@
|
||||
|
||||
#=============================================================================
|
||||
#
|
||||
# This Makefile is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
# Package, Release 3e, by John R. Hauser.
|
||||
#
|
||||
# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
|
||||
# University of California. All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions are met:
|
||||
#
|
||||
# 1. Redistributions of source code must retain the above copyright notice,
|
||||
# this list of conditions, and the following disclaimer.
|
||||
#
|
||||
# 2. Redistributions in binary form must reproduce the above copyright
|
||||
# notice, this list of conditions, and the following disclaimer in the
|
||||
# documentation and/or other materials provided with the distribution.
|
||||
#
|
||||
# 3. Neither the name of the University nor the names of its contributors
|
||||
# may be used to endorse or promote products derived from this software
|
||||
# without specific prior written permission.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
# DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
#
|
||||
#=============================================================================
|
||||
|
||||
SOURCE_DIR ?= ../../source
|
||||
SPECIALIZE_TYPE ?= 8086-SSE
|
||||
|
||||
SOFTFLOAT_OPTS ?= \
|
||||
-DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \
|
||||
-DSOFTFLOAT_FAST_DIV64TO32
|
||||
|
||||
DELETE = rm -f
|
||||
C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include
|
||||
COMPILE_C = \
|
||||
gcc -c -Werror-implicit-function-declaration $(SOFTFLOAT_OPTS) \
|
||||
$(C_INCLUDES) -O2 -o $@
|
||||
MAKELIB = ar crs $@
|
||||
|
||||
OBJ = .o
|
||||
LIB = .a
|
||||
|
||||
OTHER_HEADERS =
|
||||
|
||||
.PHONY: all
|
||||
all: softfloat$(LIB)
|
||||
|
||||
OBJS_PRIMITIVES = \
|
||||
s_compare96M$(OBJ) \
|
||||
s_compare128M$(OBJ) \
|
||||
s_shortShiftLeft64To96M$(OBJ) \
|
||||
s_shortShiftLeftM$(OBJ) \
|
||||
s_shiftLeftM$(OBJ) \
|
||||
s_shortShiftRightM$(OBJ) \
|
||||
s_shortShiftRightJam64$(OBJ) \
|
||||
s_shortShiftRightJamM$(OBJ) \
|
||||
s_shiftRightJam32$(OBJ) \
|
||||
s_shiftRightJam64$(OBJ) \
|
||||
s_shiftRightJamM$(OBJ) \
|
||||
s_shiftRightM$(OBJ) \
|
||||
s_countLeadingZeros8$(OBJ) \
|
||||
s_countLeadingZeros16$(OBJ) \
|
||||
s_countLeadingZeros32$(OBJ) \
|
||||
s_countLeadingZeros64$(OBJ) \
|
||||
s_addM$(OBJ) \
|
||||
s_addCarryM$(OBJ) \
|
||||
s_addComplCarryM$(OBJ) \
|
||||
s_negXM$(OBJ) \
|
||||
s_sub1XM$(OBJ) \
|
||||
s_subM$(OBJ) \
|
||||
s_mul64To128M$(OBJ) \
|
||||
s_mul128MTo256M$(OBJ) \
|
||||
s_approxRecip_1Ks$(OBJ) \
|
||||
s_approxRecip32_1$(OBJ) \
|
||||
s_approxRecipSqrt_1Ks$(OBJ) \
|
||||
s_approxRecipSqrt32_1$(OBJ) \
|
||||
s_remStepMBy32$(OBJ) \
|
||||
|
||||
OBJS_SPECIALIZE = \
|
||||
softfloat_raiseFlags$(OBJ) \
|
||||
s_f16UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF16UI$(OBJ) \
|
||||
s_propagateNaNF16UI$(OBJ) \
|
||||
s_f32UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF32UI$(OBJ) \
|
||||
s_propagateNaNF32UI$(OBJ) \
|
||||
s_f64UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF64UI$(OBJ) \
|
||||
s_propagateNaNF64UI$(OBJ) \
|
||||
extF80M_isSignalingNaN$(OBJ) \
|
||||
s_extF80MToCommonNaN$(OBJ) \
|
||||
s_commonNaNToExtF80M$(OBJ) \
|
||||
s_propagateNaNExtF80M$(OBJ) \
|
||||
f128M_isSignalingNaN$(OBJ) \
|
||||
s_f128MToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF128M$(OBJ) \
|
||||
s_propagateNaNF128M$(OBJ) \
|
||||
|
||||
OBJS_OTHERS = \
|
||||
s_roundToUI32$(OBJ) \
|
||||
s_roundMToUI64$(OBJ) \
|
||||
s_roundToI32$(OBJ) \
|
||||
s_roundMToI64$(OBJ) \
|
||||
s_normSubnormalF16Sig$(OBJ) \
|
||||
s_roundPackToF16$(OBJ) \
|
||||
s_normRoundPackToF16$(OBJ) \
|
||||
s_addMagsF16$(OBJ) \
|
||||
s_subMagsF16$(OBJ) \
|
||||
s_mulAddF16$(OBJ) \
|
||||
s_normSubnormalF32Sig$(OBJ) \
|
||||
s_roundPackToF32$(OBJ) \
|
||||
s_normRoundPackToF32$(OBJ) \
|
||||
s_addMagsF32$(OBJ) \
|
||||
s_subMagsF32$(OBJ) \
|
||||
s_mulAddF32$(OBJ) \
|
||||
s_normSubnormalF64Sig$(OBJ) \
|
||||
s_roundPackToF64$(OBJ) \
|
||||
s_normRoundPackToF64$(OBJ) \
|
||||
s_addMagsF64$(OBJ) \
|
||||
s_subMagsF64$(OBJ) \
|
||||
s_mulAddF64$(OBJ) \
|
||||
s_tryPropagateNaNExtF80M$(OBJ) \
|
||||
s_invalidExtF80M$(OBJ) \
|
||||
s_normExtF80SigM$(OBJ) \
|
||||
s_roundPackMToExtF80M$(OBJ) \
|
||||
s_normRoundPackMToExtF80M$(OBJ) \
|
||||
s_addExtF80M$(OBJ) \
|
||||
s_compareNonnormExtF80M$(OBJ) \
|
||||
s_isNaNF128M$(OBJ) \
|
||||
s_tryPropagateNaNF128M$(OBJ) \
|
||||
s_invalidF128M$(OBJ) \
|
||||
s_shiftNormSigF128M$(OBJ) \
|
||||
s_roundPackMToF128M$(OBJ) \
|
||||
s_normRoundPackMToF128M$(OBJ) \
|
||||
s_addF128M$(OBJ) \
|
||||
s_mulAddF128M$(OBJ) \
|
||||
softfloat_state$(OBJ) \
|
||||
ui32_to_f16$(OBJ) \
|
||||
ui32_to_f32$(OBJ) \
|
||||
ui32_to_f64$(OBJ) \
|
||||
ui32_to_extF80M$(OBJ) \
|
||||
ui32_to_f128M$(OBJ) \
|
||||
ui64_to_f16$(OBJ) \
|
||||
ui64_to_f32$(OBJ) \
|
||||
ui64_to_f64$(OBJ) \
|
||||
ui64_to_extF80M$(OBJ) \
|
||||
ui64_to_f128M$(OBJ) \
|
||||
i32_to_f16$(OBJ) \
|
||||
i32_to_f32$(OBJ) \
|
||||
i32_to_f64$(OBJ) \
|
||||
i32_to_extF80M$(OBJ) \
|
||||
i32_to_f128M$(OBJ) \
|
||||
i64_to_f16$(OBJ) \
|
||||
i64_to_f32$(OBJ) \
|
||||
i64_to_f64$(OBJ) \
|
||||
i64_to_extF80M$(OBJ) \
|
||||
i64_to_f128M$(OBJ) \
|
||||
f16_to_ui32$(OBJ) \
|
||||
f16_to_ui64$(OBJ) \
|
||||
f16_to_i32$(OBJ) \
|
||||
f16_to_i64$(OBJ) \
|
||||
f16_to_ui32_r_minMag$(OBJ) \
|
||||
f16_to_ui64_r_minMag$(OBJ) \
|
||||
f16_to_i32_r_minMag$(OBJ) \
|
||||
f16_to_i64_r_minMag$(OBJ) \
|
||||
f16_to_f32$(OBJ) \
|
||||
f16_to_f64$(OBJ) \
|
||||
f16_to_extF80M$(OBJ) \
|
||||
f16_to_f128M$(OBJ) \
|
||||
f16_roundToInt$(OBJ) \
|
||||
f16_add$(OBJ) \
|
||||
f16_sub$(OBJ) \
|
||||
f16_mul$(OBJ) \
|
||||
f16_mulAdd$(OBJ) \
|
||||
f16_div$(OBJ) \
|
||||
f16_rem$(OBJ) \
|
||||
f16_sqrt$(OBJ) \
|
||||
f16_eq$(OBJ) \
|
||||
f16_le$(OBJ) \
|
||||
f16_lt$(OBJ) \
|
||||
f16_eq_signaling$(OBJ) \
|
||||
f16_le_quiet$(OBJ) \
|
||||
f16_lt_quiet$(OBJ) \
|
||||
f16_isSignalingNaN$(OBJ) \
|
||||
f32_to_ui32$(OBJ) \
|
||||
f32_to_ui64$(OBJ) \
|
||||
f32_to_i32$(OBJ) \
|
||||
f32_to_i64$(OBJ) \
|
||||
f32_to_ui32_r_minMag$(OBJ) \
|
||||
f32_to_ui64_r_minMag$(OBJ) \
|
||||
f32_to_i32_r_minMag$(OBJ) \
|
||||
f32_to_i64_r_minMag$(OBJ) \
|
||||
f32_to_f16$(OBJ) \
|
||||
f32_to_f64$(OBJ) \
|
||||
f32_to_extF80M$(OBJ) \
|
||||
f32_to_f128M$(OBJ) \
|
||||
f32_roundToInt$(OBJ) \
|
||||
f32_add$(OBJ) \
|
||||
f32_sub$(OBJ) \
|
||||
f32_mul$(OBJ) \
|
||||
f32_mulAdd$(OBJ) \
|
||||
f32_div$(OBJ) \
|
||||
f32_rem$(OBJ) \
|
||||
f32_sqrt$(OBJ) \
|
||||
f32_eq$(OBJ) \
|
||||
f32_le$(OBJ) \
|
||||
f32_lt$(OBJ) \
|
||||
f32_eq_signaling$(OBJ) \
|
||||
f32_le_quiet$(OBJ) \
|
||||
f32_lt_quiet$(OBJ) \
|
||||
f32_isSignalingNaN$(OBJ) \
|
||||
f64_to_ui32$(OBJ) \
|
||||
f64_to_ui64$(OBJ) \
|
||||
f64_to_i32$(OBJ) \
|
||||
f64_to_i64$(OBJ) \
|
||||
f64_to_ui32_r_minMag$(OBJ) \
|
||||
f64_to_ui64_r_minMag$(OBJ) \
|
||||
f64_to_i32_r_minMag$(OBJ) \
|
||||
f64_to_i64_r_minMag$(OBJ) \
|
||||
f64_to_f16$(OBJ) \
|
||||
f64_to_f32$(OBJ) \
|
||||
f64_to_extF80M$(OBJ) \
|
||||
f64_to_f128M$(OBJ) \
|
||||
f64_roundToInt$(OBJ) \
|
||||
f64_add$(OBJ) \
|
||||
f64_sub$(OBJ) \
|
||||
f64_mul$(OBJ) \
|
||||
f64_mulAdd$(OBJ) \
|
||||
f64_div$(OBJ) \
|
||||
f64_rem$(OBJ) \
|
||||
f64_sqrt$(OBJ) \
|
||||
f64_eq$(OBJ) \
|
||||
f64_le$(OBJ) \
|
||||
f64_lt$(OBJ) \
|
||||
f64_eq_signaling$(OBJ) \
|
||||
f64_le_quiet$(OBJ) \
|
||||
f64_lt_quiet$(OBJ) \
|
||||
f64_isSignalingNaN$(OBJ) \
|
||||
extF80M_to_ui32$(OBJ) \
|
||||
extF80M_to_ui64$(OBJ) \
|
||||
extF80M_to_i32$(OBJ) \
|
||||
extF80M_to_i64$(OBJ) \
|
||||
extF80M_to_ui32_r_minMag$(OBJ) \
|
||||
extF80M_to_ui64_r_minMag$(OBJ) \
|
||||
extF80M_to_i32_r_minMag$(OBJ) \
|
||||
extF80M_to_i64_r_minMag$(OBJ) \
|
||||
extF80M_to_f16$(OBJ) \
|
||||
extF80M_to_f32$(OBJ) \
|
||||
extF80M_to_f64$(OBJ) \
|
||||
extF80M_to_f128M$(OBJ) \
|
||||
extF80M_roundToInt$(OBJ) \
|
||||
extF80M_add$(OBJ) \
|
||||
extF80M_sub$(OBJ) \
|
||||
extF80M_mul$(OBJ) \
|
||||
extF80M_div$(OBJ) \
|
||||
extF80M_rem$(OBJ) \
|
||||
extF80M_sqrt$(OBJ) \
|
||||
extF80M_eq$(OBJ) \
|
||||
extF80M_le$(OBJ) \
|
||||
extF80M_lt$(OBJ) \
|
||||
extF80M_eq_signaling$(OBJ) \
|
||||
extF80M_le_quiet$(OBJ) \
|
||||
extF80M_lt_quiet$(OBJ) \
|
||||
f128M_to_ui32$(OBJ) \
|
||||
f128M_to_ui64$(OBJ) \
|
||||
f128M_to_i32$(OBJ) \
|
||||
f128M_to_i64$(OBJ) \
|
||||
f128M_to_ui32_r_minMag$(OBJ) \
|
||||
f128M_to_ui64_r_minMag$(OBJ) \
|
||||
f128M_to_i32_r_minMag$(OBJ) \
|
||||
f128M_to_i64_r_minMag$(OBJ) \
|
||||
f128M_to_f16$(OBJ) \
|
||||
f128M_to_f32$(OBJ) \
|
||||
f128M_to_f64$(OBJ) \
|
||||
f128M_to_extF80M$(OBJ) \
|
||||
f128M_roundToInt$(OBJ) \
|
||||
f128M_add$(OBJ) \
|
||||
f128M_sub$(OBJ) \
|
||||
f128M_mul$(OBJ) \
|
||||
f128M_mulAdd$(OBJ) \
|
||||
f128M_div$(OBJ) \
|
||||
f128M_rem$(OBJ) \
|
||||
f128M_sqrt$(OBJ) \
|
||||
f128M_eq$(OBJ) \
|
||||
f128M_le$(OBJ) \
|
||||
f128M_lt$(OBJ) \
|
||||
f128M_eq_signaling$(OBJ) \
|
||||
f128M_le_quiet$(OBJ) \
|
||||
f128M_lt_quiet$(OBJ) \
|
||||
|
||||
OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS)
|
||||
|
||||
$(OBJS_ALL): \
|
||||
$(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \
|
||||
$(SOURCE_DIR)/include/primitives.h
|
||||
$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \
|
||||
$(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \
|
||||
$(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \
|
||||
$(SOURCE_DIR)/include/softfloat.h
|
||||
|
||||
$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c
|
||||
$(COMPILE_C) $(SOURCE_DIR)/$*.c
|
||||
|
||||
$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c
|
||||
$(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c
|
||||
|
||||
softfloat$(LIB): $(OBJS_ALL)
|
||||
$(DELETE) $@
|
||||
$(MAKELIB) $^
|
||||
|
||||
.PHONY: clean
|
||||
clean:
|
||||
$(DELETE) $(OBJS_ALL) softfloat$(LIB)
|
||||
|
||||
|
||||
#=============================================================================
|
||||
#
|
||||
# This Makefile is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
# Package, Release 3e, by John R. Hauser.
|
||||
#
|
||||
# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
|
||||
# University of California. All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions are met:
|
||||
#
|
||||
# 1. Redistributions of source code must retain the above copyright notice,
|
||||
# this list of conditions, and the following disclaimer.
|
||||
#
|
||||
# 2. Redistributions in binary form must reproduce the above copyright
|
||||
# notice, this list of conditions, and the following disclaimer in the
|
||||
# documentation and/or other materials provided with the distribution.
|
||||
#
|
||||
# 3. Neither the name of the University nor the names of its contributors
|
||||
# may be used to endorse or promote products derived from this software
|
||||
# without specific prior written permission.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
# DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
#
|
||||
#=============================================================================
|
||||
|
||||
SOURCE_DIR ?= ../../source
|
||||
SPECIALIZE_TYPE ?= 8086-SSE
|
||||
|
||||
SOFTFLOAT_OPTS ?= \
|
||||
-DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \
|
||||
-DSOFTFLOAT_FAST_DIV64TO32
|
||||
|
||||
DELETE = rm -f
|
||||
C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include
|
||||
COMPILE_C = \
|
||||
gcc -c -Werror-implicit-function-declaration $(SOFTFLOAT_OPTS) \
|
||||
$(C_INCLUDES) -O2 -o $@
|
||||
MAKELIB = ar crs $@
|
||||
|
||||
OBJ = .o
|
||||
LIB = .a
|
||||
|
||||
OTHER_HEADERS =
|
||||
|
||||
.PHONY: all
|
||||
all: softfloat$(LIB)
|
||||
|
||||
OBJS_PRIMITIVES = \
|
||||
s_compare96M$(OBJ) \
|
||||
s_compare128M$(OBJ) \
|
||||
s_shortShiftLeft64To96M$(OBJ) \
|
||||
s_shortShiftLeftM$(OBJ) \
|
||||
s_shiftLeftM$(OBJ) \
|
||||
s_shortShiftRightM$(OBJ) \
|
||||
s_shortShiftRightJam64$(OBJ) \
|
||||
s_shortShiftRightJamM$(OBJ) \
|
||||
s_shiftRightJam32$(OBJ) \
|
||||
s_shiftRightJam64$(OBJ) \
|
||||
s_shiftRightJamM$(OBJ) \
|
||||
s_shiftRightM$(OBJ) \
|
||||
s_countLeadingZeros8$(OBJ) \
|
||||
s_countLeadingZeros16$(OBJ) \
|
||||
s_countLeadingZeros32$(OBJ) \
|
||||
s_countLeadingZeros64$(OBJ) \
|
||||
s_addM$(OBJ) \
|
||||
s_addCarryM$(OBJ) \
|
||||
s_addComplCarryM$(OBJ) \
|
||||
s_negXM$(OBJ) \
|
||||
s_sub1XM$(OBJ) \
|
||||
s_subM$(OBJ) \
|
||||
s_mul64To128M$(OBJ) \
|
||||
s_mul128MTo256M$(OBJ) \
|
||||
s_approxRecip_1Ks$(OBJ) \
|
||||
s_approxRecip32_1$(OBJ) \
|
||||
s_approxRecipSqrt_1Ks$(OBJ) \
|
||||
s_approxRecipSqrt32_1$(OBJ) \
|
||||
s_remStepMBy32$(OBJ) \
|
||||
|
||||
OBJS_SPECIALIZE = \
|
||||
softfloat_raiseFlags$(OBJ) \
|
||||
s_f16UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF16UI$(OBJ) \
|
||||
s_propagateNaNF16UI$(OBJ) \
|
||||
s_f32UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF32UI$(OBJ) \
|
||||
s_propagateNaNF32UI$(OBJ) \
|
||||
s_f64UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF64UI$(OBJ) \
|
||||
s_propagateNaNF64UI$(OBJ) \
|
||||
extF80M_isSignalingNaN$(OBJ) \
|
||||
s_extF80MToCommonNaN$(OBJ) \
|
||||
s_commonNaNToExtF80M$(OBJ) \
|
||||
s_propagateNaNExtF80M$(OBJ) \
|
||||
f128M_isSignalingNaN$(OBJ) \
|
||||
s_f128MToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF128M$(OBJ) \
|
||||
s_propagateNaNF128M$(OBJ) \
|
||||
|
||||
OBJS_OTHERS = \
|
||||
s_roundToUI32$(OBJ) \
|
||||
s_roundMToUI64$(OBJ) \
|
||||
s_roundToI32$(OBJ) \
|
||||
s_roundMToI64$(OBJ) \
|
||||
s_normSubnormalF16Sig$(OBJ) \
|
||||
s_roundPackToF16$(OBJ) \
|
||||
s_normRoundPackToF16$(OBJ) \
|
||||
s_addMagsF16$(OBJ) \
|
||||
s_subMagsF16$(OBJ) \
|
||||
s_mulAddF16$(OBJ) \
|
||||
s_normSubnormalF32Sig$(OBJ) \
|
||||
s_roundPackToF32$(OBJ) \
|
||||
s_normRoundPackToF32$(OBJ) \
|
||||
s_addMagsF32$(OBJ) \
|
||||
s_subMagsF32$(OBJ) \
|
||||
s_mulAddF32$(OBJ) \
|
||||
s_normSubnormalF64Sig$(OBJ) \
|
||||
s_roundPackToF64$(OBJ) \
|
||||
s_normRoundPackToF64$(OBJ) \
|
||||
s_addMagsF64$(OBJ) \
|
||||
s_subMagsF64$(OBJ) \
|
||||
s_mulAddF64$(OBJ) \
|
||||
s_tryPropagateNaNExtF80M$(OBJ) \
|
||||
s_invalidExtF80M$(OBJ) \
|
||||
s_normExtF80SigM$(OBJ) \
|
||||
s_roundPackMToExtF80M$(OBJ) \
|
||||
s_normRoundPackMToExtF80M$(OBJ) \
|
||||
s_addExtF80M$(OBJ) \
|
||||
s_compareNonnormExtF80M$(OBJ) \
|
||||
s_isNaNF128M$(OBJ) \
|
||||
s_tryPropagateNaNF128M$(OBJ) \
|
||||
s_invalidF128M$(OBJ) \
|
||||
s_shiftNormSigF128M$(OBJ) \
|
||||
s_roundPackMToF128M$(OBJ) \
|
||||
s_normRoundPackMToF128M$(OBJ) \
|
||||
s_addF128M$(OBJ) \
|
||||
s_mulAddF128M$(OBJ) \
|
||||
softfloat_state$(OBJ) \
|
||||
ui32_to_f16$(OBJ) \
|
||||
ui32_to_f32$(OBJ) \
|
||||
ui32_to_f64$(OBJ) \
|
||||
ui32_to_extF80M$(OBJ) \
|
||||
ui32_to_f128M$(OBJ) \
|
||||
ui64_to_f16$(OBJ) \
|
||||
ui64_to_f32$(OBJ) \
|
||||
ui64_to_f64$(OBJ) \
|
||||
ui64_to_extF80M$(OBJ) \
|
||||
ui64_to_f128M$(OBJ) \
|
||||
i32_to_f16$(OBJ) \
|
||||
i32_to_f32$(OBJ) \
|
||||
i32_to_f64$(OBJ) \
|
||||
i32_to_extF80M$(OBJ) \
|
||||
i32_to_f128M$(OBJ) \
|
||||
i64_to_f16$(OBJ) \
|
||||
i64_to_f32$(OBJ) \
|
||||
i64_to_f64$(OBJ) \
|
||||
i64_to_extF80M$(OBJ) \
|
||||
i64_to_f128M$(OBJ) \
|
||||
f16_to_ui32$(OBJ) \
|
||||
f16_to_ui64$(OBJ) \
|
||||
f16_to_i32$(OBJ) \
|
||||
f16_to_i64$(OBJ) \
|
||||
f16_to_ui32_r_minMag$(OBJ) \
|
||||
f16_to_ui64_r_minMag$(OBJ) \
|
||||
f16_to_i32_r_minMag$(OBJ) \
|
||||
f16_to_i64_r_minMag$(OBJ) \
|
||||
f16_to_f32$(OBJ) \
|
||||
f16_to_f64$(OBJ) \
|
||||
f16_to_extF80M$(OBJ) \
|
||||
f16_to_f128M$(OBJ) \
|
||||
f16_roundToInt$(OBJ) \
|
||||
f16_add$(OBJ) \
|
||||
f16_sub$(OBJ) \
|
||||
f16_mul$(OBJ) \
|
||||
f16_mulAdd$(OBJ) \
|
||||
f16_div$(OBJ) \
|
||||
f16_rem$(OBJ) \
|
||||
f16_sqrt$(OBJ) \
|
||||
f16_eq$(OBJ) \
|
||||
f16_le$(OBJ) \
|
||||
f16_lt$(OBJ) \
|
||||
f16_eq_signaling$(OBJ) \
|
||||
f16_le_quiet$(OBJ) \
|
||||
f16_lt_quiet$(OBJ) \
|
||||
f16_isSignalingNaN$(OBJ) \
|
||||
f32_to_ui32$(OBJ) \
|
||||
f32_to_ui64$(OBJ) \
|
||||
f32_to_i32$(OBJ) \
|
||||
f32_to_i64$(OBJ) \
|
||||
f32_to_ui32_r_minMag$(OBJ) \
|
||||
f32_to_ui64_r_minMag$(OBJ) \
|
||||
f32_to_i32_r_minMag$(OBJ) \
|
||||
f32_to_i64_r_minMag$(OBJ) \
|
||||
f32_to_f16$(OBJ) \
|
||||
f32_to_f64$(OBJ) \
|
||||
f32_to_extF80M$(OBJ) \
|
||||
f32_to_f128M$(OBJ) \
|
||||
f32_roundToInt$(OBJ) \
|
||||
f32_add$(OBJ) \
|
||||
f32_sub$(OBJ) \
|
||||
f32_mul$(OBJ) \
|
||||
f32_mulAdd$(OBJ) \
|
||||
f32_div$(OBJ) \
|
||||
f32_rem$(OBJ) \
|
||||
f32_sqrt$(OBJ) \
|
||||
f32_eq$(OBJ) \
|
||||
f32_le$(OBJ) \
|
||||
f32_lt$(OBJ) \
|
||||
f32_eq_signaling$(OBJ) \
|
||||
f32_le_quiet$(OBJ) \
|
||||
f32_lt_quiet$(OBJ) \
|
||||
f32_isSignalingNaN$(OBJ) \
|
||||
f64_to_ui32$(OBJ) \
|
||||
f64_to_ui64$(OBJ) \
|
||||
f64_to_i32$(OBJ) \
|
||||
f64_to_i64$(OBJ) \
|
||||
f64_to_ui32_r_minMag$(OBJ) \
|
||||
f64_to_ui64_r_minMag$(OBJ) \
|
||||
f64_to_i32_r_minMag$(OBJ) \
|
||||
f64_to_i64_r_minMag$(OBJ) \
|
||||
f64_to_f16$(OBJ) \
|
||||
f64_to_f32$(OBJ) \
|
||||
f64_to_extF80M$(OBJ) \
|
||||
f64_to_f128M$(OBJ) \
|
||||
f64_roundToInt$(OBJ) \
|
||||
f64_add$(OBJ) \
|
||||
f64_sub$(OBJ) \
|
||||
f64_mul$(OBJ) \
|
||||
f64_mulAdd$(OBJ) \
|
||||
f64_div$(OBJ) \
|
||||
f64_rem$(OBJ) \
|
||||
f64_sqrt$(OBJ) \
|
||||
f64_eq$(OBJ) \
|
||||
f64_le$(OBJ) \
|
||||
f64_lt$(OBJ) \
|
||||
f64_eq_signaling$(OBJ) \
|
||||
f64_le_quiet$(OBJ) \
|
||||
f64_lt_quiet$(OBJ) \
|
||||
f64_isSignalingNaN$(OBJ) \
|
||||
extF80M_to_ui32$(OBJ) \
|
||||
extF80M_to_ui64$(OBJ) \
|
||||
extF80M_to_i32$(OBJ) \
|
||||
extF80M_to_i64$(OBJ) \
|
||||
extF80M_to_ui32_r_minMag$(OBJ) \
|
||||
extF80M_to_ui64_r_minMag$(OBJ) \
|
||||
extF80M_to_i32_r_minMag$(OBJ) \
|
||||
extF80M_to_i64_r_minMag$(OBJ) \
|
||||
extF80M_to_f16$(OBJ) \
|
||||
extF80M_to_f32$(OBJ) \
|
||||
extF80M_to_f64$(OBJ) \
|
||||
extF80M_to_f128M$(OBJ) \
|
||||
extF80M_roundToInt$(OBJ) \
|
||||
extF80M_add$(OBJ) \
|
||||
extF80M_sub$(OBJ) \
|
||||
extF80M_mul$(OBJ) \
|
||||
extF80M_div$(OBJ) \
|
||||
extF80M_rem$(OBJ) \
|
||||
extF80M_sqrt$(OBJ) \
|
||||
extF80M_eq$(OBJ) \
|
||||
extF80M_le$(OBJ) \
|
||||
extF80M_lt$(OBJ) \
|
||||
extF80M_eq_signaling$(OBJ) \
|
||||
extF80M_le_quiet$(OBJ) \
|
||||
extF80M_lt_quiet$(OBJ) \
|
||||
f128M_to_ui32$(OBJ) \
|
||||
f128M_to_ui64$(OBJ) \
|
||||
f128M_to_i32$(OBJ) \
|
||||
f128M_to_i64$(OBJ) \
|
||||
f128M_to_ui32_r_minMag$(OBJ) \
|
||||
f128M_to_ui64_r_minMag$(OBJ) \
|
||||
f128M_to_i32_r_minMag$(OBJ) \
|
||||
f128M_to_i64_r_minMag$(OBJ) \
|
||||
f128M_to_f16$(OBJ) \
|
||||
f128M_to_f32$(OBJ) \
|
||||
f128M_to_f64$(OBJ) \
|
||||
f128M_to_extF80M$(OBJ) \
|
||||
f128M_roundToInt$(OBJ) \
|
||||
f128M_add$(OBJ) \
|
||||
f128M_sub$(OBJ) \
|
||||
f128M_mul$(OBJ) \
|
||||
f128M_mulAdd$(OBJ) \
|
||||
f128M_div$(OBJ) \
|
||||
f128M_rem$(OBJ) \
|
||||
f128M_sqrt$(OBJ) \
|
||||
f128M_eq$(OBJ) \
|
||||
f128M_le$(OBJ) \
|
||||
f128M_lt$(OBJ) \
|
||||
f128M_eq_signaling$(OBJ) \
|
||||
f128M_le_quiet$(OBJ) \
|
||||
f128M_lt_quiet$(OBJ) \
|
||||
|
||||
OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS)
|
||||
|
||||
$(OBJS_ALL): \
|
||||
$(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \
|
||||
$(SOURCE_DIR)/include/primitives.h
|
||||
$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \
|
||||
$(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \
|
||||
$(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \
|
||||
$(SOURCE_DIR)/include/softfloat.h
|
||||
|
||||
$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c
|
||||
$(COMPILE_C) $(SOURCE_DIR)/$*.c
|
||||
|
||||
$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c
|
||||
$(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c
|
||||
|
||||
softfloat$(LIB): $(OBJS_ALL)
|
||||
$(DELETE) $@
|
||||
$(MAKELIB) $^
|
||||
|
||||
.PHONY: clean
|
||||
clean:
|
||||
$(DELETE) $(OBJS_ALL) softfloat$(LIB)
|
||||
|
||||
|
@ -1,52 +1,53 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
|
||||
University of California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define LITTLEENDIAN 1
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#ifdef __GNUC_STDC_INLINE__
|
||||
#define INLINE inline
|
||||
#else
|
||||
#define INLINE extern inline
|
||||
#endif
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define SOFTFLOAT_BUILTIN_CLZ 1
|
||||
#include "opts-GCC.h"
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
|
||||
University of California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define LITTLEENDIAN 1
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#ifdef __GNUC_STDC_INLINE__
|
||||
#define INLINE inline
|
||||
#else
|
||||
#define INLINE extern inline
|
||||
#endif
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define SOFTFLOAT_BUILTIN_CLZ 1
|
||||
#include "opts-GCC.h"
|
||||
|
||||
|
@ -1,323 +1,323 @@
|
||||
|
||||
#=============================================================================
|
||||
#
|
||||
# This Makefile is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
# Package, Release 3e, by John R. Hauser.
|
||||
#
|
||||
# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
|
||||
# University of California. All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions are met:
|
||||
#
|
||||
# 1. Redistributions of source code must retain the above copyright notice,
|
||||
# this list of conditions, and the following disclaimer.
|
||||
#
|
||||
# 2. Redistributions in binary form must reproduce the above copyright
|
||||
# notice, this list of conditions, and the following disclaimer in the
|
||||
# documentation and/or other materials provided with the distribution.
|
||||
#
|
||||
# 3. Neither the name of the University nor the names of its contributors
|
||||
# may be used to endorse or promote products derived from this software
|
||||
# without specific prior written permission.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
# DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
#
|
||||
#=============================================================================
|
||||
|
||||
SOURCE_DIR ?= ../../source
|
||||
SPECIALIZE_TYPE ?= ARM-VFPv2
|
||||
|
||||
SOFTFLOAT_OPTS ?= -DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5
|
||||
|
||||
DELETE = rm -f
|
||||
C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include
|
||||
COMPILE_C = \
|
||||
gcc -c -Werror-implicit-function-declaration $(SOFTFLOAT_OPTS) \
|
||||
$(C_INCLUDES) -O2 -o $@
|
||||
MAKELIB = ar crs $@
|
||||
|
||||
OBJ = .o
|
||||
LIB = .a
|
||||
|
||||
OTHER_HEADERS =
|
||||
|
||||
.PHONY: all
|
||||
all: softfloat$(LIB)
|
||||
|
||||
OBJS_PRIMITIVES = \
|
||||
s_compare96M$(OBJ) \
|
||||
s_compare128M$(OBJ) \
|
||||
s_shortShiftLeft64To96M$(OBJ) \
|
||||
s_shortShiftLeftM$(OBJ) \
|
||||
s_shiftLeftM$(OBJ) \
|
||||
s_shortShiftRightM$(OBJ) \
|
||||
s_shortShiftRightJam64$(OBJ) \
|
||||
s_shortShiftRightJamM$(OBJ) \
|
||||
s_shiftRightJam32$(OBJ) \
|
||||
s_shiftRightJam64$(OBJ) \
|
||||
s_shiftRightJamM$(OBJ) \
|
||||
s_shiftRightM$(OBJ) \
|
||||
s_countLeadingZeros8$(OBJ) \
|
||||
s_countLeadingZeros16$(OBJ) \
|
||||
s_countLeadingZeros32$(OBJ) \
|
||||
s_countLeadingZeros64$(OBJ) \
|
||||
s_addM$(OBJ) \
|
||||
s_addCarryM$(OBJ) \
|
||||
s_addComplCarryM$(OBJ) \
|
||||
s_negXM$(OBJ) \
|
||||
s_sub1XM$(OBJ) \
|
||||
s_subM$(OBJ) \
|
||||
s_mul64To128M$(OBJ) \
|
||||
s_mul128MTo256M$(OBJ) \
|
||||
s_approxRecip_1Ks$(OBJ) \
|
||||
s_approxRecip32_1$(OBJ) \
|
||||
s_approxRecipSqrt_1Ks$(OBJ) \
|
||||
s_approxRecipSqrt32_1$(OBJ) \
|
||||
s_remStepMBy32$(OBJ) \
|
||||
|
||||
OBJS_SPECIALIZE = \
|
||||
softfloat_raiseFlags$(OBJ) \
|
||||
s_f16UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF16UI$(OBJ) \
|
||||
s_propagateNaNF16UI$(OBJ) \
|
||||
s_f32UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF32UI$(OBJ) \
|
||||
s_propagateNaNF32UI$(OBJ) \
|
||||
s_f64UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF64UI$(OBJ) \
|
||||
s_propagateNaNF64UI$(OBJ) \
|
||||
extF80M_isSignalingNaN$(OBJ) \
|
||||
s_extF80MToCommonNaN$(OBJ) \
|
||||
s_commonNaNToExtF80M$(OBJ) \
|
||||
s_propagateNaNExtF80M$(OBJ) \
|
||||
f128M_isSignalingNaN$(OBJ) \
|
||||
s_f128MToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF128M$(OBJ) \
|
||||
s_propagateNaNF128M$(OBJ) \
|
||||
|
||||
OBJS_OTHERS = \
|
||||
s_roundToUI32$(OBJ) \
|
||||
s_roundMToUI64$(OBJ) \
|
||||
s_roundToI32$(OBJ) \
|
||||
s_roundMToI64$(OBJ) \
|
||||
s_normSubnormalF16Sig$(OBJ) \
|
||||
s_roundPackToF16$(OBJ) \
|
||||
s_normRoundPackToF16$(OBJ) \
|
||||
s_addMagsF16$(OBJ) \
|
||||
s_subMagsF16$(OBJ) \
|
||||
s_mulAddF16$(OBJ) \
|
||||
s_normSubnormalF32Sig$(OBJ) \
|
||||
s_roundPackToF32$(OBJ) \
|
||||
s_normRoundPackToF32$(OBJ) \
|
||||
s_addMagsF32$(OBJ) \
|
||||
s_subMagsF32$(OBJ) \
|
||||
s_mulAddF32$(OBJ) \
|
||||
s_normSubnormalF64Sig$(OBJ) \
|
||||
s_roundPackToF64$(OBJ) \
|
||||
s_normRoundPackToF64$(OBJ) \
|
||||
s_addMagsF64$(OBJ) \
|
||||
s_subMagsF64$(OBJ) \
|
||||
s_mulAddF64$(OBJ) \
|
||||
s_tryPropagateNaNExtF80M$(OBJ) \
|
||||
s_invalidExtF80M$(OBJ) \
|
||||
s_normExtF80SigM$(OBJ) \
|
||||
s_roundPackMToExtF80M$(OBJ) \
|
||||
s_normRoundPackMToExtF80M$(OBJ) \
|
||||
s_addExtF80M$(OBJ) \
|
||||
s_compareNonnormExtF80M$(OBJ) \
|
||||
s_isNaNF128M$(OBJ) \
|
||||
s_tryPropagateNaNF128M$(OBJ) \
|
||||
s_invalidF128M$(OBJ) \
|
||||
s_shiftNormSigF128M$(OBJ) \
|
||||
s_roundPackMToF128M$(OBJ) \
|
||||
s_normRoundPackMToF128M$(OBJ) \
|
||||
s_addF128M$(OBJ) \
|
||||
s_mulAddF128M$(OBJ) \
|
||||
softfloat_state$(OBJ) \
|
||||
ui32_to_f16$(OBJ) \
|
||||
ui32_to_f32$(OBJ) \
|
||||
ui32_to_f64$(OBJ) \
|
||||
ui32_to_extF80M$(OBJ) \
|
||||
ui32_to_f128M$(OBJ) \
|
||||
ui64_to_f16$(OBJ) \
|
||||
ui64_to_f32$(OBJ) \
|
||||
ui64_to_f64$(OBJ) \
|
||||
ui64_to_extF80M$(OBJ) \
|
||||
ui64_to_f128M$(OBJ) \
|
||||
i32_to_f16$(OBJ) \
|
||||
i32_to_f32$(OBJ) \
|
||||
i32_to_f64$(OBJ) \
|
||||
i32_to_extF80M$(OBJ) \
|
||||
i32_to_f128M$(OBJ) \
|
||||
i64_to_f16$(OBJ) \
|
||||
i64_to_f32$(OBJ) \
|
||||
i64_to_f64$(OBJ) \
|
||||
i64_to_extF80M$(OBJ) \
|
||||
i64_to_f128M$(OBJ) \
|
||||
f16_to_ui32$(OBJ) \
|
||||
f16_to_ui64$(OBJ) \
|
||||
f16_to_i32$(OBJ) \
|
||||
f16_to_i64$(OBJ) \
|
||||
f16_to_ui32_r_minMag$(OBJ) \
|
||||
f16_to_ui64_r_minMag$(OBJ) \
|
||||
f16_to_i32_r_minMag$(OBJ) \
|
||||
f16_to_i64_r_minMag$(OBJ) \
|
||||
f16_to_f32$(OBJ) \
|
||||
f16_to_f64$(OBJ) \
|
||||
f16_to_extF80M$(OBJ) \
|
||||
f16_to_f128M$(OBJ) \
|
||||
f16_roundToInt$(OBJ) \
|
||||
f16_add$(OBJ) \
|
||||
f16_sub$(OBJ) \
|
||||
f16_mul$(OBJ) \
|
||||
f16_mulAdd$(OBJ) \
|
||||
f16_div$(OBJ) \
|
||||
f16_rem$(OBJ) \
|
||||
f16_sqrt$(OBJ) \
|
||||
f16_eq$(OBJ) \
|
||||
f16_le$(OBJ) \
|
||||
f16_lt$(OBJ) \
|
||||
f16_eq_signaling$(OBJ) \
|
||||
f16_le_quiet$(OBJ) \
|
||||
f16_lt_quiet$(OBJ) \
|
||||
f16_isSignalingNaN$(OBJ) \
|
||||
f32_to_ui32$(OBJ) \
|
||||
f32_to_ui64$(OBJ) \
|
||||
f32_to_i32$(OBJ) \
|
||||
f32_to_i64$(OBJ) \
|
||||
f32_to_ui32_r_minMag$(OBJ) \
|
||||
f32_to_ui64_r_minMag$(OBJ) \
|
||||
f32_to_i32_r_minMag$(OBJ) \
|
||||
f32_to_i64_r_minMag$(OBJ) \
|
||||
f32_to_f16$(OBJ) \
|
||||
f32_to_f64$(OBJ) \
|
||||
f32_to_extF80M$(OBJ) \
|
||||
f32_to_f128M$(OBJ) \
|
||||
f32_roundToInt$(OBJ) \
|
||||
f32_add$(OBJ) \
|
||||
f32_sub$(OBJ) \
|
||||
f32_mul$(OBJ) \
|
||||
f32_mulAdd$(OBJ) \
|
||||
f32_div$(OBJ) \
|
||||
f32_rem$(OBJ) \
|
||||
f32_sqrt$(OBJ) \
|
||||
f32_eq$(OBJ) \
|
||||
f32_le$(OBJ) \
|
||||
f32_lt$(OBJ) \
|
||||
f32_eq_signaling$(OBJ) \
|
||||
f32_le_quiet$(OBJ) \
|
||||
f32_lt_quiet$(OBJ) \
|
||||
f32_isSignalingNaN$(OBJ) \
|
||||
f64_to_ui32$(OBJ) \
|
||||
f64_to_ui64$(OBJ) \
|
||||
f64_to_i32$(OBJ) \
|
||||
f64_to_i64$(OBJ) \
|
||||
f64_to_ui32_r_minMag$(OBJ) \
|
||||
f64_to_ui64_r_minMag$(OBJ) \
|
||||
f64_to_i32_r_minMag$(OBJ) \
|
||||
f64_to_i64_r_minMag$(OBJ) \
|
||||
f64_to_f16$(OBJ) \
|
||||
f64_to_f32$(OBJ) \
|
||||
f64_to_extF80M$(OBJ) \
|
||||
f64_to_f128M$(OBJ) \
|
||||
f64_roundToInt$(OBJ) \
|
||||
f64_add$(OBJ) \
|
||||
f64_sub$(OBJ) \
|
||||
f64_mul$(OBJ) \
|
||||
f64_mulAdd$(OBJ) \
|
||||
f64_div$(OBJ) \
|
||||
f64_rem$(OBJ) \
|
||||
f64_sqrt$(OBJ) \
|
||||
f64_eq$(OBJ) \
|
||||
f64_le$(OBJ) \
|
||||
f64_lt$(OBJ) \
|
||||
f64_eq_signaling$(OBJ) \
|
||||
f64_le_quiet$(OBJ) \
|
||||
f64_lt_quiet$(OBJ) \
|
||||
f64_isSignalingNaN$(OBJ) \
|
||||
extF80M_to_ui32$(OBJ) \
|
||||
extF80M_to_ui64$(OBJ) \
|
||||
extF80M_to_i32$(OBJ) \
|
||||
extF80M_to_i64$(OBJ) \
|
||||
extF80M_to_ui32_r_minMag$(OBJ) \
|
||||
extF80M_to_ui64_r_minMag$(OBJ) \
|
||||
extF80M_to_i32_r_minMag$(OBJ) \
|
||||
extF80M_to_i64_r_minMag$(OBJ) \
|
||||
extF80M_to_f16$(OBJ) \
|
||||
extF80M_to_f32$(OBJ) \
|
||||
extF80M_to_f64$(OBJ) \
|
||||
extF80M_to_f128M$(OBJ) \
|
||||
extF80M_roundToInt$(OBJ) \
|
||||
extF80M_add$(OBJ) \
|
||||
extF80M_sub$(OBJ) \
|
||||
extF80M_mul$(OBJ) \
|
||||
extF80M_div$(OBJ) \
|
||||
extF80M_rem$(OBJ) \
|
||||
extF80M_sqrt$(OBJ) \
|
||||
extF80M_eq$(OBJ) \
|
||||
extF80M_le$(OBJ) \
|
||||
extF80M_lt$(OBJ) \
|
||||
extF80M_eq_signaling$(OBJ) \
|
||||
extF80M_le_quiet$(OBJ) \
|
||||
extF80M_lt_quiet$(OBJ) \
|
||||
f128M_to_ui32$(OBJ) \
|
||||
f128M_to_ui64$(OBJ) \
|
||||
f128M_to_i32$(OBJ) \
|
||||
f128M_to_i64$(OBJ) \
|
||||
f128M_to_ui32_r_minMag$(OBJ) \
|
||||
f128M_to_ui64_r_minMag$(OBJ) \
|
||||
f128M_to_i32_r_minMag$(OBJ) \
|
||||
f128M_to_i64_r_minMag$(OBJ) \
|
||||
f128M_to_f16$(OBJ) \
|
||||
f128M_to_f32$(OBJ) \
|
||||
f128M_to_f64$(OBJ) \
|
||||
f128M_to_extF80M$(OBJ) \
|
||||
f128M_roundToInt$(OBJ) \
|
||||
f128M_add$(OBJ) \
|
||||
f128M_sub$(OBJ) \
|
||||
f128M_mul$(OBJ) \
|
||||
f128M_mulAdd$(OBJ) \
|
||||
f128M_div$(OBJ) \
|
||||
f128M_rem$(OBJ) \
|
||||
f128M_sqrt$(OBJ) \
|
||||
f128M_eq$(OBJ) \
|
||||
f128M_le$(OBJ) \
|
||||
f128M_lt$(OBJ) \
|
||||
f128M_eq_signaling$(OBJ) \
|
||||
f128M_le_quiet$(OBJ) \
|
||||
f128M_lt_quiet$(OBJ) \
|
||||
|
||||
OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS)
|
||||
|
||||
$(OBJS_ALL): \
|
||||
$(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \
|
||||
$(SOURCE_DIR)/include/primitives.h
|
||||
$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \
|
||||
$(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \
|
||||
$(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \
|
||||
$(SOURCE_DIR)/include/softfloat.h
|
||||
|
||||
$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c
|
||||
$(COMPILE_C) $(SOURCE_DIR)/$*.c
|
||||
|
||||
$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c
|
||||
$(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c
|
||||
|
||||
softfloat$(LIB): $(OBJS_ALL)
|
||||
$(DELETE) $@
|
||||
$(MAKELIB) $^
|
||||
|
||||
.PHONY: clean
|
||||
clean:
|
||||
$(DELETE) $(OBJS_ALL) softfloat$(LIB)
|
||||
|
||||
|
||||
#=============================================================================
|
||||
#
|
||||
# This Makefile is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
# Package, Release 3e, by John R. Hauser.
|
||||
#
|
||||
# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
|
||||
# University of California. All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions are met:
|
||||
#
|
||||
# 1. Redistributions of source code must retain the above copyright notice,
|
||||
# this list of conditions, and the following disclaimer.
|
||||
#
|
||||
# 2. Redistributions in binary form must reproduce the above copyright
|
||||
# notice, this list of conditions, and the following disclaimer in the
|
||||
# documentation and/or other materials provided with the distribution.
|
||||
#
|
||||
# 3. Neither the name of the University nor the names of its contributors
|
||||
# may be used to endorse or promote products derived from this software
|
||||
# without specific prior written permission.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
# DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
#
|
||||
#=============================================================================
|
||||
|
||||
SOURCE_DIR ?= ../../source
|
||||
SPECIALIZE_TYPE ?= ARM-VFPv2
|
||||
|
||||
SOFTFLOAT_OPTS ?= -DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5
|
||||
|
||||
DELETE = rm -f
|
||||
C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include
|
||||
COMPILE_C = \
|
||||
gcc -c -Werror-implicit-function-declaration $(SOFTFLOAT_OPTS) \
|
||||
$(C_INCLUDES) -O2 -o $@
|
||||
MAKELIB = ar crs $@
|
||||
|
||||
OBJ = .o
|
||||
LIB = .a
|
||||
|
||||
OTHER_HEADERS =
|
||||
|
||||
.PHONY: all
|
||||
all: softfloat$(LIB)
|
||||
|
||||
OBJS_PRIMITIVES = \
|
||||
s_compare96M$(OBJ) \
|
||||
s_compare128M$(OBJ) \
|
||||
s_shortShiftLeft64To96M$(OBJ) \
|
||||
s_shortShiftLeftM$(OBJ) \
|
||||
s_shiftLeftM$(OBJ) \
|
||||
s_shortShiftRightM$(OBJ) \
|
||||
s_shortShiftRightJam64$(OBJ) \
|
||||
s_shortShiftRightJamM$(OBJ) \
|
||||
s_shiftRightJam32$(OBJ) \
|
||||
s_shiftRightJam64$(OBJ) \
|
||||
s_shiftRightJamM$(OBJ) \
|
||||
s_shiftRightM$(OBJ) \
|
||||
s_countLeadingZeros8$(OBJ) \
|
||||
s_countLeadingZeros16$(OBJ) \
|
||||
s_countLeadingZeros32$(OBJ) \
|
||||
s_countLeadingZeros64$(OBJ) \
|
||||
s_addM$(OBJ) \
|
||||
s_addCarryM$(OBJ) \
|
||||
s_addComplCarryM$(OBJ) \
|
||||
s_negXM$(OBJ) \
|
||||
s_sub1XM$(OBJ) \
|
||||
s_subM$(OBJ) \
|
||||
s_mul64To128M$(OBJ) \
|
||||
s_mul128MTo256M$(OBJ) \
|
||||
s_approxRecip_1Ks$(OBJ) \
|
||||
s_approxRecip32_1$(OBJ) \
|
||||
s_approxRecipSqrt_1Ks$(OBJ) \
|
||||
s_approxRecipSqrt32_1$(OBJ) \
|
||||
s_remStepMBy32$(OBJ) \
|
||||
|
||||
OBJS_SPECIALIZE = \
|
||||
softfloat_raiseFlags$(OBJ) \
|
||||
s_f16UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF16UI$(OBJ) \
|
||||
s_propagateNaNF16UI$(OBJ) \
|
||||
s_f32UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF32UI$(OBJ) \
|
||||
s_propagateNaNF32UI$(OBJ) \
|
||||
s_f64UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF64UI$(OBJ) \
|
||||
s_propagateNaNF64UI$(OBJ) \
|
||||
extF80M_isSignalingNaN$(OBJ) \
|
||||
s_extF80MToCommonNaN$(OBJ) \
|
||||
s_commonNaNToExtF80M$(OBJ) \
|
||||
s_propagateNaNExtF80M$(OBJ) \
|
||||
f128M_isSignalingNaN$(OBJ) \
|
||||
s_f128MToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF128M$(OBJ) \
|
||||
s_propagateNaNF128M$(OBJ) \
|
||||
|
||||
OBJS_OTHERS = \
|
||||
s_roundToUI32$(OBJ) \
|
||||
s_roundMToUI64$(OBJ) \
|
||||
s_roundToI32$(OBJ) \
|
||||
s_roundMToI64$(OBJ) \
|
||||
s_normSubnormalF16Sig$(OBJ) \
|
||||
s_roundPackToF16$(OBJ) \
|
||||
s_normRoundPackToF16$(OBJ) \
|
||||
s_addMagsF16$(OBJ) \
|
||||
s_subMagsF16$(OBJ) \
|
||||
s_mulAddF16$(OBJ) \
|
||||
s_normSubnormalF32Sig$(OBJ) \
|
||||
s_roundPackToF32$(OBJ) \
|
||||
s_normRoundPackToF32$(OBJ) \
|
||||
s_addMagsF32$(OBJ) \
|
||||
s_subMagsF32$(OBJ) \
|
||||
s_mulAddF32$(OBJ) \
|
||||
s_normSubnormalF64Sig$(OBJ) \
|
||||
s_roundPackToF64$(OBJ) \
|
||||
s_normRoundPackToF64$(OBJ) \
|
||||
s_addMagsF64$(OBJ) \
|
||||
s_subMagsF64$(OBJ) \
|
||||
s_mulAddF64$(OBJ) \
|
||||
s_tryPropagateNaNExtF80M$(OBJ) \
|
||||
s_invalidExtF80M$(OBJ) \
|
||||
s_normExtF80SigM$(OBJ) \
|
||||
s_roundPackMToExtF80M$(OBJ) \
|
||||
s_normRoundPackMToExtF80M$(OBJ) \
|
||||
s_addExtF80M$(OBJ) \
|
||||
s_compareNonnormExtF80M$(OBJ) \
|
||||
s_isNaNF128M$(OBJ) \
|
||||
s_tryPropagateNaNF128M$(OBJ) \
|
||||
s_invalidF128M$(OBJ) \
|
||||
s_shiftNormSigF128M$(OBJ) \
|
||||
s_roundPackMToF128M$(OBJ) \
|
||||
s_normRoundPackMToF128M$(OBJ) \
|
||||
s_addF128M$(OBJ) \
|
||||
s_mulAddF128M$(OBJ) \
|
||||
softfloat_state$(OBJ) \
|
||||
ui32_to_f16$(OBJ) \
|
||||
ui32_to_f32$(OBJ) \
|
||||
ui32_to_f64$(OBJ) \
|
||||
ui32_to_extF80M$(OBJ) \
|
||||
ui32_to_f128M$(OBJ) \
|
||||
ui64_to_f16$(OBJ) \
|
||||
ui64_to_f32$(OBJ) \
|
||||
ui64_to_f64$(OBJ) \
|
||||
ui64_to_extF80M$(OBJ) \
|
||||
ui64_to_f128M$(OBJ) \
|
||||
i32_to_f16$(OBJ) \
|
||||
i32_to_f32$(OBJ) \
|
||||
i32_to_f64$(OBJ) \
|
||||
i32_to_extF80M$(OBJ) \
|
||||
i32_to_f128M$(OBJ) \
|
||||
i64_to_f16$(OBJ) \
|
||||
i64_to_f32$(OBJ) \
|
||||
i64_to_f64$(OBJ) \
|
||||
i64_to_extF80M$(OBJ) \
|
||||
i64_to_f128M$(OBJ) \
|
||||
f16_to_ui32$(OBJ) \
|
||||
f16_to_ui64$(OBJ) \
|
||||
f16_to_i32$(OBJ) \
|
||||
f16_to_i64$(OBJ) \
|
||||
f16_to_ui32_r_minMag$(OBJ) \
|
||||
f16_to_ui64_r_minMag$(OBJ) \
|
||||
f16_to_i32_r_minMag$(OBJ) \
|
||||
f16_to_i64_r_minMag$(OBJ) \
|
||||
f16_to_f32$(OBJ) \
|
||||
f16_to_f64$(OBJ) \
|
||||
f16_to_extF80M$(OBJ) \
|
||||
f16_to_f128M$(OBJ) \
|
||||
f16_roundToInt$(OBJ) \
|
||||
f16_add$(OBJ) \
|
||||
f16_sub$(OBJ) \
|
||||
f16_mul$(OBJ) \
|
||||
f16_mulAdd$(OBJ) \
|
||||
f16_div$(OBJ) \
|
||||
f16_rem$(OBJ) \
|
||||
f16_sqrt$(OBJ) \
|
||||
f16_eq$(OBJ) \
|
||||
f16_le$(OBJ) \
|
||||
f16_lt$(OBJ) \
|
||||
f16_eq_signaling$(OBJ) \
|
||||
f16_le_quiet$(OBJ) \
|
||||
f16_lt_quiet$(OBJ) \
|
||||
f16_isSignalingNaN$(OBJ) \
|
||||
f32_to_ui32$(OBJ) \
|
||||
f32_to_ui64$(OBJ) \
|
||||
f32_to_i32$(OBJ) \
|
||||
f32_to_i64$(OBJ) \
|
||||
f32_to_ui32_r_minMag$(OBJ) \
|
||||
f32_to_ui64_r_minMag$(OBJ) \
|
||||
f32_to_i32_r_minMag$(OBJ) \
|
||||
f32_to_i64_r_minMag$(OBJ) \
|
||||
f32_to_f16$(OBJ) \
|
||||
f32_to_f64$(OBJ) \
|
||||
f32_to_extF80M$(OBJ) \
|
||||
f32_to_f128M$(OBJ) \
|
||||
f32_roundToInt$(OBJ) \
|
||||
f32_add$(OBJ) \
|
||||
f32_sub$(OBJ) \
|
||||
f32_mul$(OBJ) \
|
||||
f32_mulAdd$(OBJ) \
|
||||
f32_div$(OBJ) \
|
||||
f32_rem$(OBJ) \
|
||||
f32_sqrt$(OBJ) \
|
||||
f32_eq$(OBJ) \
|
||||
f32_le$(OBJ) \
|
||||
f32_lt$(OBJ) \
|
||||
f32_eq_signaling$(OBJ) \
|
||||
f32_le_quiet$(OBJ) \
|
||||
f32_lt_quiet$(OBJ) \
|
||||
f32_isSignalingNaN$(OBJ) \
|
||||
f64_to_ui32$(OBJ) \
|
||||
f64_to_ui64$(OBJ) \
|
||||
f64_to_i32$(OBJ) \
|
||||
f64_to_i64$(OBJ) \
|
||||
f64_to_ui32_r_minMag$(OBJ) \
|
||||
f64_to_ui64_r_minMag$(OBJ) \
|
||||
f64_to_i32_r_minMag$(OBJ) \
|
||||
f64_to_i64_r_minMag$(OBJ) \
|
||||
f64_to_f16$(OBJ) \
|
||||
f64_to_f32$(OBJ) \
|
||||
f64_to_extF80M$(OBJ) \
|
||||
f64_to_f128M$(OBJ) \
|
||||
f64_roundToInt$(OBJ) \
|
||||
f64_add$(OBJ) \
|
||||
f64_sub$(OBJ) \
|
||||
f64_mul$(OBJ) \
|
||||
f64_mulAdd$(OBJ) \
|
||||
f64_div$(OBJ) \
|
||||
f64_rem$(OBJ) \
|
||||
f64_sqrt$(OBJ) \
|
||||
f64_eq$(OBJ) \
|
||||
f64_le$(OBJ) \
|
||||
f64_lt$(OBJ) \
|
||||
f64_eq_signaling$(OBJ) \
|
||||
f64_le_quiet$(OBJ) \
|
||||
f64_lt_quiet$(OBJ) \
|
||||
f64_isSignalingNaN$(OBJ) \
|
||||
extF80M_to_ui32$(OBJ) \
|
||||
extF80M_to_ui64$(OBJ) \
|
||||
extF80M_to_i32$(OBJ) \
|
||||
extF80M_to_i64$(OBJ) \
|
||||
extF80M_to_ui32_r_minMag$(OBJ) \
|
||||
extF80M_to_ui64_r_minMag$(OBJ) \
|
||||
extF80M_to_i32_r_minMag$(OBJ) \
|
||||
extF80M_to_i64_r_minMag$(OBJ) \
|
||||
extF80M_to_f16$(OBJ) \
|
||||
extF80M_to_f32$(OBJ) \
|
||||
extF80M_to_f64$(OBJ) \
|
||||
extF80M_to_f128M$(OBJ) \
|
||||
extF80M_roundToInt$(OBJ) \
|
||||
extF80M_add$(OBJ) \
|
||||
extF80M_sub$(OBJ) \
|
||||
extF80M_mul$(OBJ) \
|
||||
extF80M_div$(OBJ) \
|
||||
extF80M_rem$(OBJ) \
|
||||
extF80M_sqrt$(OBJ) \
|
||||
extF80M_eq$(OBJ) \
|
||||
extF80M_le$(OBJ) \
|
||||
extF80M_lt$(OBJ) \
|
||||
extF80M_eq_signaling$(OBJ) \
|
||||
extF80M_le_quiet$(OBJ) \
|
||||
extF80M_lt_quiet$(OBJ) \
|
||||
f128M_to_ui32$(OBJ) \
|
||||
f128M_to_ui64$(OBJ) \
|
||||
f128M_to_i32$(OBJ) \
|
||||
f128M_to_i64$(OBJ) \
|
||||
f128M_to_ui32_r_minMag$(OBJ) \
|
||||
f128M_to_ui64_r_minMag$(OBJ) \
|
||||
f128M_to_i32_r_minMag$(OBJ) \
|
||||
f128M_to_i64_r_minMag$(OBJ) \
|
||||
f128M_to_f16$(OBJ) \
|
||||
f128M_to_f32$(OBJ) \
|
||||
f128M_to_f64$(OBJ) \
|
||||
f128M_to_extF80M$(OBJ) \
|
||||
f128M_roundToInt$(OBJ) \
|
||||
f128M_add$(OBJ) \
|
||||
f128M_sub$(OBJ) \
|
||||
f128M_mul$(OBJ) \
|
||||
f128M_mulAdd$(OBJ) \
|
||||
f128M_div$(OBJ) \
|
||||
f128M_rem$(OBJ) \
|
||||
f128M_sqrt$(OBJ) \
|
||||
f128M_eq$(OBJ) \
|
||||
f128M_le$(OBJ) \
|
||||
f128M_lt$(OBJ) \
|
||||
f128M_eq_signaling$(OBJ) \
|
||||
f128M_le_quiet$(OBJ) \
|
||||
f128M_lt_quiet$(OBJ) \
|
||||
|
||||
OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS)
|
||||
|
||||
$(OBJS_ALL): \
|
||||
$(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \
|
||||
$(SOURCE_DIR)/include/primitives.h
|
||||
$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \
|
||||
$(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \
|
||||
$(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \
|
||||
$(SOURCE_DIR)/include/softfloat.h
|
||||
|
||||
$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c
|
||||
$(COMPILE_C) $(SOURCE_DIR)/$*.c
|
||||
|
||||
$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c
|
||||
$(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c
|
||||
|
||||
softfloat$(LIB): $(OBJS_ALL)
|
||||
$(DELETE) $@
|
||||
$(MAKELIB) $^
|
||||
|
||||
.PHONY: clean
|
||||
clean:
|
||||
$(DELETE) $(OBJS_ALL) softfloat$(LIB)
|
||||
|
||||
|
@ -1,52 +1,53 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
|
||||
University of California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define LITTLEENDIAN 1
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#ifdef __GNUC_STDC_INLINE__
|
||||
#define INLINE inline
|
||||
#else
|
||||
#define INLINE extern inline
|
||||
#endif
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define SOFTFLOAT_BUILTIN_CLZ 1
|
||||
#include "opts-GCC.h"
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
|
||||
University of California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define LITTLEENDIAN 1
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#ifdef __GNUC_STDC_INLINE__
|
||||
#define INLINE inline
|
||||
#else
|
||||
#define INLINE extern inline
|
||||
#endif
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define SOFTFLOAT_BUILTIN_CLZ 1
|
||||
#include "opts-GCC.h"
|
||||
|
||||
|
399
softfloat/build/Linux-RISCV64-GCC/Makefile
Normal file
399
softfloat/build/Linux-RISCV64-GCC/Makefile
Normal file
@ -0,0 +1,399 @@
|
||||
|
||||
#=============================================================================
|
||||
#
|
||||
# This Makefile is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
# Package, Release 3e, by John R. Hauser.
|
||||
#
|
||||
# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
|
||||
# University of California. All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions are met:
|
||||
#
|
||||
# 1. Redistributions of source code must retain the above copyright notice,
|
||||
# this list of conditions, and the following disclaimer.
|
||||
#
|
||||
# 2. Redistributions in binary form must reproduce the above copyright
|
||||
# notice, this list of conditions, and the following disclaimer in the
|
||||
# documentation and/or other materials provided with the distribution.
|
||||
#
|
||||
# 3. Neither the name of the University nor the names of its contributors
|
||||
# may be used to endorse or promote products derived from this software
|
||||
# without specific prior written permission.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
# DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
#
|
||||
#=============================================================================
|
||||
|
||||
SOURCE_DIR ?= ../../source
|
||||
SPECIALIZE_TYPE ?= RISCV
|
||||
MARCH ?= rv64gcv_zfh_zfhmin
|
||||
MABI ?= lp64d
|
||||
|
||||
SOFTFLOAT_OPTS ?= \
|
||||
-DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \
|
||||
-DSOFTFLOAT_FAST_DIV64TO32
|
||||
|
||||
DELETE = rm -f
|
||||
C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include
|
||||
COMPILE_C = \
|
||||
riscv64-unknown-linux-gnu-gcc -c -march=$(MARCH) -mabi=$(MABI) -Werror-implicit-function-declaration -DSOFTFLOAT_FAST_INT64 \
|
||||
$(SOFTFLOAT_OPTS) $(C_INCLUDES) -O2 -o $@
|
||||
MAKELIB = ar crs $@
|
||||
|
||||
OBJ = .o
|
||||
LIB = .a
|
||||
|
||||
OTHER_HEADERS = $(SOURCE_DIR)/include/opts-GCC.h
|
||||
|
||||
.PHONY: all
|
||||
all: softfloat$(LIB)
|
||||
|
||||
OBJS_PRIMITIVES = \
|
||||
s_eq128$(OBJ) \
|
||||
s_le128$(OBJ) \
|
||||
s_lt128$(OBJ) \
|
||||
s_shortShiftLeft128$(OBJ) \
|
||||
s_shortShiftRight128$(OBJ) \
|
||||
s_shortShiftRightJam64$(OBJ) \
|
||||
s_shortShiftRightJam64Extra$(OBJ) \
|
||||
s_shortShiftRightJam128$(OBJ) \
|
||||
s_shortShiftRightJam128Extra$(OBJ) \
|
||||
s_shiftRightJam32$(OBJ) \
|
||||
s_shiftRightJam64$(OBJ) \
|
||||
s_shiftRightJam64Extra$(OBJ) \
|
||||
s_shiftRightJam128$(OBJ) \
|
||||
s_shiftRightJam128Extra$(OBJ) \
|
||||
s_shiftRightJam256M$(OBJ) \
|
||||
s_countLeadingZeros8$(OBJ) \
|
||||
s_countLeadingZeros16$(OBJ) \
|
||||
s_countLeadingZeros32$(OBJ) \
|
||||
s_countLeadingZeros64$(OBJ) \
|
||||
s_add128$(OBJ) \
|
||||
s_add256M$(OBJ) \
|
||||
s_sub128$(OBJ) \
|
||||
s_sub256M$(OBJ) \
|
||||
s_mul64ByShifted32To128$(OBJ) \
|
||||
s_mul64To128$(OBJ) \
|
||||
s_mul128By32$(OBJ) \
|
||||
s_mul128To256M$(OBJ) \
|
||||
s_approxRecip_1Ks$(OBJ) \
|
||||
s_approxRecip32_1$(OBJ) \
|
||||
s_approxRecipSqrt_1Ks$(OBJ) \
|
||||
s_approxRecipSqrt32_1$(OBJ) \
|
||||
|
||||
OBJS_SPECIALIZE = \
|
||||
softfloat_raiseFlags$(OBJ) \
|
||||
s_f16UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF16UI$(OBJ) \
|
||||
s_propagateNaNF16UI$(OBJ) \
|
||||
s_bf16UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToBF16UI$(OBJ) \
|
||||
s_f32UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF32UI$(OBJ) \
|
||||
s_propagateNaNF32UI$(OBJ) \
|
||||
s_f64UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF64UI$(OBJ) \
|
||||
s_propagateNaNF64UI$(OBJ) \
|
||||
extF80M_isSignalingNaN$(OBJ) \
|
||||
s_extF80UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToExtF80UI$(OBJ) \
|
||||
s_propagateNaNExtF80UI$(OBJ) \
|
||||
f128M_isSignalingNaN$(OBJ) \
|
||||
s_f128UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF128UI$(OBJ) \
|
||||
s_propagateNaNF128UI$(OBJ) \
|
||||
|
||||
OBJS_OTHERS = \
|
||||
s_roundToUI32$(OBJ) \
|
||||
s_roundToUI64$(OBJ) \
|
||||
s_roundToI32$(OBJ) \
|
||||
s_roundToI64$(OBJ) \
|
||||
s_normSubnormalBF16Sig$(OBJ) \
|
||||
s_roundPackToBF16$(OBJ) \
|
||||
s_normSubnormalF16Sig$(OBJ) \
|
||||
s_roundPackToF16$(OBJ) \
|
||||
s_normRoundPackToF16$(OBJ) \
|
||||
s_addMagsF16$(OBJ) \
|
||||
s_subMagsF16$(OBJ) \
|
||||
s_mulAddF16$(OBJ) \
|
||||
s_normSubnormalF32Sig$(OBJ) \
|
||||
s_roundPackToF32$(OBJ) \
|
||||
s_normRoundPackToF32$(OBJ) \
|
||||
s_addMagsF32$(OBJ) \
|
||||
s_subMagsF32$(OBJ) \
|
||||
s_mulAddF32$(OBJ) \
|
||||
s_normSubnormalF64Sig$(OBJ) \
|
||||
s_roundPackToF64$(OBJ) \
|
||||
s_normRoundPackToF64$(OBJ) \
|
||||
s_addMagsF64$(OBJ) \
|
||||
s_subMagsF64$(OBJ) \
|
||||
s_mulAddF64$(OBJ) \
|
||||
s_normSubnormalExtF80Sig$(OBJ) \
|
||||
s_roundPackToExtF80$(OBJ) \
|
||||
s_normRoundPackToExtF80$(OBJ) \
|
||||
s_addMagsExtF80$(OBJ) \
|
||||
s_subMagsExtF80$(OBJ) \
|
||||
s_normSubnormalF128Sig$(OBJ) \
|
||||
s_roundPackToF128$(OBJ) \
|
||||
s_normRoundPackToF128$(OBJ) \
|
||||
s_addMagsF128$(OBJ) \
|
||||
s_subMagsF128$(OBJ) \
|
||||
s_mulAddF128$(OBJ) \
|
||||
softfloat_state$(OBJ) \
|
||||
ui32_to_f16$(OBJ) \
|
||||
ui32_to_f32$(OBJ) \
|
||||
ui32_to_f64$(OBJ) \
|
||||
ui32_to_extF80$(OBJ) \
|
||||
ui32_to_extF80M$(OBJ) \
|
||||
ui32_to_f128$(OBJ) \
|
||||
ui32_to_f128M$(OBJ) \
|
||||
ui64_to_f16$(OBJ) \
|
||||
ui64_to_f32$(OBJ) \
|
||||
ui64_to_f64$(OBJ) \
|
||||
ui64_to_extF80$(OBJ) \
|
||||
ui64_to_extF80M$(OBJ) \
|
||||
ui64_to_f128$(OBJ) \
|
||||
ui64_to_f128M$(OBJ) \
|
||||
i32_to_f16$(OBJ) \
|
||||
i32_to_f32$(OBJ) \
|
||||
i32_to_f64$(OBJ) \
|
||||
i32_to_extF80$(OBJ) \
|
||||
i32_to_extF80M$(OBJ) \
|
||||
i32_to_f128$(OBJ) \
|
||||
i32_to_f128M$(OBJ) \
|
||||
i64_to_f16$(OBJ) \
|
||||
i64_to_f32$(OBJ) \
|
||||
i64_to_f64$(OBJ) \
|
||||
i64_to_extF80$(OBJ) \
|
||||
i64_to_extF80M$(OBJ) \
|
||||
i64_to_f128$(OBJ) \
|
||||
i64_to_f128M$(OBJ) \
|
||||
bf16_isSignalingNaN$(OBJ) \
|
||||
bf16_to_f32$(OBJ) \
|
||||
f16_to_ui32$(OBJ) \
|
||||
f16_to_ui64$(OBJ) \
|
||||
f16_to_i32$(OBJ) \
|
||||
f16_to_i64$(OBJ) \
|
||||
f16_to_ui32_r_minMag$(OBJ) \
|
||||
f16_to_ui64_r_minMag$(OBJ) \
|
||||
f16_to_i32_r_minMag$(OBJ) \
|
||||
f16_to_i64_r_minMag$(OBJ) \
|
||||
f16_to_f32$(OBJ) \
|
||||
f16_to_f64$(OBJ) \
|
||||
f16_to_extF80$(OBJ) \
|
||||
f16_to_extF80M$(OBJ) \
|
||||
f16_to_f128$(OBJ) \
|
||||
f16_to_f128M$(OBJ) \
|
||||
f16_roundToInt$(OBJ) \
|
||||
f16_add$(OBJ) \
|
||||
f16_sub$(OBJ) \
|
||||
f16_mul$(OBJ) \
|
||||
f16_mulAdd$(OBJ) \
|
||||
f16_div$(OBJ) \
|
||||
f16_rem$(OBJ) \
|
||||
f16_sqrt$(OBJ) \
|
||||
f16_eq$(OBJ) \
|
||||
f16_le$(OBJ) \
|
||||
f16_lt$(OBJ) \
|
||||
f16_eq_signaling$(OBJ) \
|
||||
f16_le_quiet$(OBJ) \
|
||||
f16_lt_quiet$(OBJ) \
|
||||
f16_isSignalingNaN$(OBJ) \
|
||||
f32_to_ui32$(OBJ) \
|
||||
f32_to_ui64$(OBJ) \
|
||||
f32_to_i32$(OBJ) \
|
||||
f32_to_i64$(OBJ) \
|
||||
f32_to_ui32_r_minMag$(OBJ) \
|
||||
f32_to_ui64_r_minMag$(OBJ) \
|
||||
f32_to_i32_r_minMag$(OBJ) \
|
||||
f32_to_i64_r_minMag$(OBJ) \
|
||||
f32_to_bf16$(OBJ) \
|
||||
f32_to_f16$(OBJ) \
|
||||
f32_to_f64$(OBJ) \
|
||||
f32_to_extF80$(OBJ) \
|
||||
f32_to_extF80M$(OBJ) \
|
||||
f32_to_f128$(OBJ) \
|
||||
f32_to_f128M$(OBJ) \
|
||||
f32_roundToInt$(OBJ) \
|
||||
f32_add$(OBJ) \
|
||||
f32_sub$(OBJ) \
|
||||
f32_mul$(OBJ) \
|
||||
f32_mulAdd$(OBJ) \
|
||||
f32_div$(OBJ) \
|
||||
f32_rem$(OBJ) \
|
||||
f32_sqrt$(OBJ) \
|
||||
f32_eq$(OBJ) \
|
||||
f32_le$(OBJ) \
|
||||
f32_lt$(OBJ) \
|
||||
f32_eq_signaling$(OBJ) \
|
||||
f32_le_quiet$(OBJ) \
|
||||
f32_lt_quiet$(OBJ) \
|
||||
f32_isSignalingNaN$(OBJ) \
|
||||
f64_to_ui32$(OBJ) \
|
||||
f64_to_ui64$(OBJ) \
|
||||
f64_to_i32$(OBJ) \
|
||||
f64_to_i64$(OBJ) \
|
||||
f64_to_ui32_r_minMag$(OBJ) \
|
||||
f64_to_ui64_r_minMag$(OBJ) \
|
||||
f64_to_i32_r_minMag$(OBJ) \
|
||||
f64_to_i64_r_minMag$(OBJ) \
|
||||
f64_to_f16$(OBJ) \
|
||||
f64_to_f32$(OBJ) \
|
||||
f64_to_extF80$(OBJ) \
|
||||
f64_to_extF80M$(OBJ) \
|
||||
f64_to_f128$(OBJ) \
|
||||
f64_to_f128M$(OBJ) \
|
||||
f64_roundToInt$(OBJ) \
|
||||
f64_add$(OBJ) \
|
||||
f64_sub$(OBJ) \
|
||||
f64_mul$(OBJ) \
|
||||
f64_mulAdd$(OBJ) \
|
||||
f64_div$(OBJ) \
|
||||
f64_rem$(OBJ) \
|
||||
f64_sqrt$(OBJ) \
|
||||
f64_eq$(OBJ) \
|
||||
f64_le$(OBJ) \
|
||||
f64_lt$(OBJ) \
|
||||
f64_eq_signaling$(OBJ) \
|
||||
f64_le_quiet$(OBJ) \
|
||||
f64_lt_quiet$(OBJ) \
|
||||
f64_isSignalingNaN$(OBJ) \
|
||||
extF80_to_ui32$(OBJ) \
|
||||
extF80_to_ui64$(OBJ) \
|
||||
extF80_to_i32$(OBJ) \
|
||||
extF80_to_i64$(OBJ) \
|
||||
extF80_to_ui32_r_minMag$(OBJ) \
|
||||
extF80_to_ui64_r_minMag$(OBJ) \
|
||||
extF80_to_i32_r_minMag$(OBJ) \
|
||||
extF80_to_i64_r_minMag$(OBJ) \
|
||||
extF80_to_f16$(OBJ) \
|
||||
extF80_to_f32$(OBJ) \
|
||||
extF80_to_f64$(OBJ) \
|
||||
extF80_to_f128$(OBJ) \
|
||||
extF80_roundToInt$(OBJ) \
|
||||
extF80_add$(OBJ) \
|
||||
extF80_sub$(OBJ) \
|
||||
extF80_mul$(OBJ) \
|
||||
extF80_div$(OBJ) \
|
||||
extF80_rem$(OBJ) \
|
||||
extF80_sqrt$(OBJ) \
|
||||
extF80_eq$(OBJ) \
|
||||
extF80_le$(OBJ) \
|
||||
extF80_lt$(OBJ) \
|
||||
extF80_eq_signaling$(OBJ) \
|
||||
extF80_le_quiet$(OBJ) \
|
||||
extF80_lt_quiet$(OBJ) \
|
||||
extF80_isSignalingNaN$(OBJ) \
|
||||
extF80M_to_ui32$(OBJ) \
|
||||
extF80M_to_ui64$(OBJ) \
|
||||
extF80M_to_i32$(OBJ) \
|
||||
extF80M_to_i64$(OBJ) \
|
||||
extF80M_to_ui32_r_minMag$(OBJ) \
|
||||
extF80M_to_ui64_r_minMag$(OBJ) \
|
||||
extF80M_to_i32_r_minMag$(OBJ) \
|
||||
extF80M_to_i64_r_minMag$(OBJ) \
|
||||
extF80M_to_f16$(OBJ) \
|
||||
extF80M_to_f32$(OBJ) \
|
||||
extF80M_to_f64$(OBJ) \
|
||||
extF80M_to_f128M$(OBJ) \
|
||||
extF80M_roundToInt$(OBJ) \
|
||||
extF80M_add$(OBJ) \
|
||||
extF80M_sub$(OBJ) \
|
||||
extF80M_mul$(OBJ) \
|
||||
extF80M_div$(OBJ) \
|
||||
extF80M_rem$(OBJ) \
|
||||
extF80M_sqrt$(OBJ) \
|
||||
extF80M_eq$(OBJ) \
|
||||
extF80M_le$(OBJ) \
|
||||
extF80M_lt$(OBJ) \
|
||||
extF80M_eq_signaling$(OBJ) \
|
||||
extF80M_le_quiet$(OBJ) \
|
||||
extF80M_lt_quiet$(OBJ) \
|
||||
f128_to_ui32$(OBJ) \
|
||||
f128_to_ui64$(OBJ) \
|
||||
f128_to_i32$(OBJ) \
|
||||
f128_to_i64$(OBJ) \
|
||||
f128_to_ui32_r_minMag$(OBJ) \
|
||||
f128_to_ui64_r_minMag$(OBJ) \
|
||||
f128_to_i32_r_minMag$(OBJ) \
|
||||
f128_to_i64_r_minMag$(OBJ) \
|
||||
f128_to_f16$(OBJ) \
|
||||
f128_to_f32$(OBJ) \
|
||||
f128_to_extF80$(OBJ) \
|
||||
f128_to_f64$(OBJ) \
|
||||
f128_roundToInt$(OBJ) \
|
||||
f128_add$(OBJ) \
|
||||
f128_sub$(OBJ) \
|
||||
f128_mul$(OBJ) \
|
||||
f128_mulAdd$(OBJ) \
|
||||
f128_div$(OBJ) \
|
||||
f128_rem$(OBJ) \
|
||||
f128_sqrt$(OBJ) \
|
||||
f128_eq$(OBJ) \
|
||||
f128_le$(OBJ) \
|
||||
f128_lt$(OBJ) \
|
||||
f128_eq_signaling$(OBJ) \
|
||||
f128_le_quiet$(OBJ) \
|
||||
f128_lt_quiet$(OBJ) \
|
||||
f128_isSignalingNaN$(OBJ) \
|
||||
f128M_to_ui32$(OBJ) \
|
||||
f128M_to_ui64$(OBJ) \
|
||||
f128M_to_i32$(OBJ) \
|
||||
f128M_to_i64$(OBJ) \
|
||||
f128M_to_ui32_r_minMag$(OBJ) \
|
||||
f128M_to_ui64_r_minMag$(OBJ) \
|
||||
f128M_to_i32_r_minMag$(OBJ) \
|
||||
f128M_to_i64_r_minMag$(OBJ) \
|
||||
f128M_to_f16$(OBJ) \
|
||||
f128M_to_f32$(OBJ) \
|
||||
f128M_to_extF80M$(OBJ) \
|
||||
f128M_to_f64$(OBJ) \
|
||||
f128M_roundToInt$(OBJ) \
|
||||
f128M_add$(OBJ) \
|
||||
f128M_sub$(OBJ) \
|
||||
f128M_mul$(OBJ) \
|
||||
f128M_mulAdd$(OBJ) \
|
||||
f128M_div$(OBJ) \
|
||||
f128M_rem$(OBJ) \
|
||||
f128M_sqrt$(OBJ) \
|
||||
f128M_eq$(OBJ) \
|
||||
f128M_le$(OBJ) \
|
||||
f128M_lt$(OBJ) \
|
||||
f128M_eq_signaling$(OBJ) \
|
||||
f128M_le_quiet$(OBJ) \
|
||||
f128M_lt_quiet$(OBJ) \
|
||||
|
||||
OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS)
|
||||
|
||||
$(OBJS_ALL): \
|
||||
$(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \
|
||||
$(SOURCE_DIR)/include/primitives.h
|
||||
$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \
|
||||
$(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \
|
||||
$(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \
|
||||
$(SOURCE_DIR)/include/softfloat.h
|
||||
|
||||
$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c
|
||||
$(COMPILE_C) $(SOURCE_DIR)/$*.c
|
||||
|
||||
$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c
|
||||
$(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c
|
||||
|
||||
softfloat$(LIB): $(OBJS_ALL)
|
||||
$(DELETE) $@
|
||||
$(MAKELIB) $^
|
||||
|
||||
.PHONY: clean
|
||||
clean:
|
||||
$(DELETE) $(OBJS_ALL) softfloat$(LIB)
|
||||
|
54
softfloat/build/Linux-RISCV64-GCC/platform.h
Normal file
54
softfloat/build/Linux-RISCV64-GCC/platform.h
Normal file
@ -0,0 +1,54 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
|
||||
University of California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define LITTLEENDIAN 1
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#ifdef __GNUC_STDC_INLINE__
|
||||
#define INLINE inline
|
||||
#else
|
||||
#define INLINE extern inline
|
||||
#endif
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define SOFTFLOAT_BUILTIN_CLZ 1
|
||||
#define SOFTFLOAT_INTRINSIC_INT128 1
|
||||
#include "opts-GCC.h"
|
||||
|
@ -1,390 +1,397 @@
|
||||
|
||||
#=============================================================================
|
||||
#
|
||||
# This Makefile is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
# Package, Release 3e, by John R. Hauser.
|
||||
#
|
||||
# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
|
||||
# University of California. All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions are met:
|
||||
#
|
||||
# 1. Redistributions of source code must retain the above copyright notice,
|
||||
# this list of conditions, and the following disclaimer.
|
||||
#
|
||||
# 2. Redistributions in binary form must reproduce the above copyright
|
||||
# notice, this list of conditions, and the following disclaimer in the
|
||||
# documentation and/or other materials provided with the distribution.
|
||||
#
|
||||
# 3. Neither the name of the University nor the names of its contributors
|
||||
# may be used to endorse or promote products derived from this software
|
||||
# without specific prior written permission.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
# DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
#
|
||||
#=============================================================================
|
||||
|
||||
SOURCE_DIR ?= ../../source
|
||||
SPECIALIZE_TYPE ?= 8086-SSE
|
||||
|
||||
SOFTFLOAT_OPTS ?= \
|
||||
-DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \
|
||||
-DSOFTFLOAT_FAST_DIV64TO32
|
||||
|
||||
DELETE = rm -f
|
||||
C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include
|
||||
COMPILE_C = \
|
||||
gcc -c -Werror-implicit-function-declaration -DSOFTFLOAT_FAST_INT64 \
|
||||
$(SOFTFLOAT_OPTS) $(C_INCLUDES) -O2 -o $@
|
||||
MAKELIB = ar crs $@
|
||||
|
||||
OBJ = .o
|
||||
LIB = .a
|
||||
|
||||
OTHER_HEADERS = $(SOURCE_DIR)/include/opts-GCC.h
|
||||
|
||||
.PHONY: all
|
||||
all: softfloat$(LIB)
|
||||
|
||||
OBJS_PRIMITIVES = \
|
||||
s_eq128$(OBJ) \
|
||||
s_le128$(OBJ) \
|
||||
s_lt128$(OBJ) \
|
||||
s_shortShiftLeft128$(OBJ) \
|
||||
s_shortShiftRight128$(OBJ) \
|
||||
s_shortShiftRightJam64$(OBJ) \
|
||||
s_shortShiftRightJam64Extra$(OBJ) \
|
||||
s_shortShiftRightJam128$(OBJ) \
|
||||
s_shortShiftRightJam128Extra$(OBJ) \
|
||||
s_shiftRightJam32$(OBJ) \
|
||||
s_shiftRightJam64$(OBJ) \
|
||||
s_shiftRightJam64Extra$(OBJ) \
|
||||
s_shiftRightJam128$(OBJ) \
|
||||
s_shiftRightJam128Extra$(OBJ) \
|
||||
s_shiftRightJam256M$(OBJ) \
|
||||
s_countLeadingZeros8$(OBJ) \
|
||||
s_countLeadingZeros16$(OBJ) \
|
||||
s_countLeadingZeros32$(OBJ) \
|
||||
s_countLeadingZeros64$(OBJ) \
|
||||
s_add128$(OBJ) \
|
||||
s_add256M$(OBJ) \
|
||||
s_sub128$(OBJ) \
|
||||
s_sub256M$(OBJ) \
|
||||
s_mul64ByShifted32To128$(OBJ) \
|
||||
s_mul64To128$(OBJ) \
|
||||
s_mul128By32$(OBJ) \
|
||||
s_mul128To256M$(OBJ) \
|
||||
s_approxRecip_1Ks$(OBJ) \
|
||||
s_approxRecip32_1$(OBJ) \
|
||||
s_approxRecipSqrt_1Ks$(OBJ) \
|
||||
s_approxRecipSqrt32_1$(OBJ) \
|
||||
|
||||
OBJS_SPECIALIZE = \
|
||||
softfloat_raiseFlags$(OBJ) \
|
||||
s_f16UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF16UI$(OBJ) \
|
||||
s_propagateNaNF16UI$(OBJ) \
|
||||
s_f32UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF32UI$(OBJ) \
|
||||
s_propagateNaNF32UI$(OBJ) \
|
||||
s_f64UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF64UI$(OBJ) \
|
||||
s_propagateNaNF64UI$(OBJ) \
|
||||
extF80M_isSignalingNaN$(OBJ) \
|
||||
s_extF80UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToExtF80UI$(OBJ) \
|
||||
s_propagateNaNExtF80UI$(OBJ) \
|
||||
f128M_isSignalingNaN$(OBJ) \
|
||||
s_f128UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF128UI$(OBJ) \
|
||||
s_propagateNaNF128UI$(OBJ) \
|
||||
|
||||
OBJS_OTHERS = \
|
||||
s_roundToUI32$(OBJ) \
|
||||
s_roundToUI64$(OBJ) \
|
||||
s_roundToI32$(OBJ) \
|
||||
s_roundToI64$(OBJ) \
|
||||
s_normSubnormalF16Sig$(OBJ) \
|
||||
s_roundPackToF16$(OBJ) \
|
||||
s_normRoundPackToF16$(OBJ) \
|
||||
s_addMagsF16$(OBJ) \
|
||||
s_subMagsF16$(OBJ) \
|
||||
s_mulAddF16$(OBJ) \
|
||||
s_normSubnormalF32Sig$(OBJ) \
|
||||
s_roundPackToF32$(OBJ) \
|
||||
s_normRoundPackToF32$(OBJ) \
|
||||
s_addMagsF32$(OBJ) \
|
||||
s_subMagsF32$(OBJ) \
|
||||
s_mulAddF32$(OBJ) \
|
||||
s_normSubnormalF64Sig$(OBJ) \
|
||||
s_roundPackToF64$(OBJ) \
|
||||
s_normRoundPackToF64$(OBJ) \
|
||||
s_addMagsF64$(OBJ) \
|
||||
s_subMagsF64$(OBJ) \
|
||||
s_mulAddF64$(OBJ) \
|
||||
s_normSubnormalExtF80Sig$(OBJ) \
|
||||
s_roundPackToExtF80$(OBJ) \
|
||||
s_normRoundPackToExtF80$(OBJ) \
|
||||
s_addMagsExtF80$(OBJ) \
|
||||
s_subMagsExtF80$(OBJ) \
|
||||
s_normSubnormalF128Sig$(OBJ) \
|
||||
s_roundPackToF128$(OBJ) \
|
||||
s_normRoundPackToF128$(OBJ) \
|
||||
s_addMagsF128$(OBJ) \
|
||||
s_subMagsF128$(OBJ) \
|
||||
s_mulAddF128$(OBJ) \
|
||||
softfloat_state$(OBJ) \
|
||||
ui32_to_f16$(OBJ) \
|
||||
ui32_to_f32$(OBJ) \
|
||||
ui32_to_f64$(OBJ) \
|
||||
ui32_to_extF80$(OBJ) \
|
||||
ui32_to_extF80M$(OBJ) \
|
||||
ui32_to_f128$(OBJ) \
|
||||
ui32_to_f128M$(OBJ) \
|
||||
ui64_to_f16$(OBJ) \
|
||||
ui64_to_f32$(OBJ) \
|
||||
ui64_to_f64$(OBJ) \
|
||||
ui64_to_extF80$(OBJ) \
|
||||
ui64_to_extF80M$(OBJ) \
|
||||
ui64_to_f128$(OBJ) \
|
||||
ui64_to_f128M$(OBJ) \
|
||||
i32_to_f16$(OBJ) \
|
||||
i32_to_f32$(OBJ) \
|
||||
i32_to_f64$(OBJ) \
|
||||
i32_to_extF80$(OBJ) \
|
||||
i32_to_extF80M$(OBJ) \
|
||||
i32_to_f128$(OBJ) \
|
||||
i32_to_f128M$(OBJ) \
|
||||
i64_to_f16$(OBJ) \
|
||||
i64_to_f32$(OBJ) \
|
||||
i64_to_f64$(OBJ) \
|
||||
i64_to_extF80$(OBJ) \
|
||||
i64_to_extF80M$(OBJ) \
|
||||
i64_to_f128$(OBJ) \
|
||||
i64_to_f128M$(OBJ) \
|
||||
f16_to_ui32$(OBJ) \
|
||||
f16_to_ui64$(OBJ) \
|
||||
f16_to_i32$(OBJ) \
|
||||
f16_to_i64$(OBJ) \
|
||||
f16_to_ui32_r_minMag$(OBJ) \
|
||||
f16_to_ui64_r_minMag$(OBJ) \
|
||||
f16_to_i32_r_minMag$(OBJ) \
|
||||
f16_to_i64_r_minMag$(OBJ) \
|
||||
f16_to_f32$(OBJ) \
|
||||
f16_to_f64$(OBJ) \
|
||||
f16_to_extF80$(OBJ) \
|
||||
f16_to_extF80M$(OBJ) \
|
||||
f16_to_f128$(OBJ) \
|
||||
f16_to_f128M$(OBJ) \
|
||||
f16_roundToInt$(OBJ) \
|
||||
f16_add$(OBJ) \
|
||||
f16_sub$(OBJ) \
|
||||
f16_mul$(OBJ) \
|
||||
f16_mulAdd$(OBJ) \
|
||||
f16_div$(OBJ) \
|
||||
f16_rem$(OBJ) \
|
||||
f16_sqrt$(OBJ) \
|
||||
f16_eq$(OBJ) \
|
||||
f16_le$(OBJ) \
|
||||
f16_lt$(OBJ) \
|
||||
f16_eq_signaling$(OBJ) \
|
||||
f16_le_quiet$(OBJ) \
|
||||
f16_lt_quiet$(OBJ) \
|
||||
f16_isSignalingNaN$(OBJ) \
|
||||
f32_to_ui32$(OBJ) \
|
||||
f32_to_ui64$(OBJ) \
|
||||
f32_to_i32$(OBJ) \
|
||||
f32_to_i64$(OBJ) \
|
||||
f32_to_ui32_r_minMag$(OBJ) \
|
||||
f32_to_ui64_r_minMag$(OBJ) \
|
||||
f32_to_i32_r_minMag$(OBJ) \
|
||||
f32_to_i64_r_minMag$(OBJ) \
|
||||
f32_to_f16$(OBJ) \
|
||||
f32_to_f64$(OBJ) \
|
||||
f32_to_extF80$(OBJ) \
|
||||
f32_to_extF80M$(OBJ) \
|
||||
f32_to_f128$(OBJ) \
|
||||
f32_to_f128M$(OBJ) \
|
||||
f32_roundToInt$(OBJ) \
|
||||
f32_add$(OBJ) \
|
||||
f32_sub$(OBJ) \
|
||||
f32_mul$(OBJ) \
|
||||
f32_mulAdd$(OBJ) \
|
||||
f32_div$(OBJ) \
|
||||
f32_rem$(OBJ) \
|
||||
f32_sqrt$(OBJ) \
|
||||
f32_eq$(OBJ) \
|
||||
f32_le$(OBJ) \
|
||||
f32_lt$(OBJ) \
|
||||
f32_eq_signaling$(OBJ) \
|
||||
f32_le_quiet$(OBJ) \
|
||||
f32_lt_quiet$(OBJ) \
|
||||
f32_isSignalingNaN$(OBJ) \
|
||||
f64_to_ui32$(OBJ) \
|
||||
f64_to_ui64$(OBJ) \
|
||||
f64_to_i32$(OBJ) \
|
||||
f64_to_i64$(OBJ) \
|
||||
f64_to_ui32_r_minMag$(OBJ) \
|
||||
f64_to_ui64_r_minMag$(OBJ) \
|
||||
f64_to_i32_r_minMag$(OBJ) \
|
||||
f64_to_i64_r_minMag$(OBJ) \
|
||||
f64_to_f16$(OBJ) \
|
||||
f64_to_f32$(OBJ) \
|
||||
f64_to_extF80$(OBJ) \
|
||||
f64_to_extF80M$(OBJ) \
|
||||
f64_to_f128$(OBJ) \
|
||||
f64_to_f128M$(OBJ) \
|
||||
f64_roundToInt$(OBJ) \
|
||||
f64_add$(OBJ) \
|
||||
f64_sub$(OBJ) \
|
||||
f64_mul$(OBJ) \
|
||||
f64_mulAdd$(OBJ) \
|
||||
f64_div$(OBJ) \
|
||||
f64_rem$(OBJ) \
|
||||
f64_sqrt$(OBJ) \
|
||||
f64_eq$(OBJ) \
|
||||
f64_le$(OBJ) \
|
||||
f64_lt$(OBJ) \
|
||||
f64_eq_signaling$(OBJ) \
|
||||
f64_le_quiet$(OBJ) \
|
||||
f64_lt_quiet$(OBJ) \
|
||||
f64_isSignalingNaN$(OBJ) \
|
||||
extF80_to_ui32$(OBJ) \
|
||||
extF80_to_ui64$(OBJ) \
|
||||
extF80_to_i32$(OBJ) \
|
||||
extF80_to_i64$(OBJ) \
|
||||
extF80_to_ui32_r_minMag$(OBJ) \
|
||||
extF80_to_ui64_r_minMag$(OBJ) \
|
||||
extF80_to_i32_r_minMag$(OBJ) \
|
||||
extF80_to_i64_r_minMag$(OBJ) \
|
||||
extF80_to_f16$(OBJ) \
|
||||
extF80_to_f32$(OBJ) \
|
||||
extF80_to_f64$(OBJ) \
|
||||
extF80_to_f128$(OBJ) \
|
||||
extF80_roundToInt$(OBJ) \
|
||||
extF80_add$(OBJ) \
|
||||
extF80_sub$(OBJ) \
|
||||
extF80_mul$(OBJ) \
|
||||
extF80_div$(OBJ) \
|
||||
extF80_rem$(OBJ) \
|
||||
extF80_sqrt$(OBJ) \
|
||||
extF80_eq$(OBJ) \
|
||||
extF80_le$(OBJ) \
|
||||
extF80_lt$(OBJ) \
|
||||
extF80_eq_signaling$(OBJ) \
|
||||
extF80_le_quiet$(OBJ) \
|
||||
extF80_lt_quiet$(OBJ) \
|
||||
extF80_isSignalingNaN$(OBJ) \
|
||||
extF80M_to_ui32$(OBJ) \
|
||||
extF80M_to_ui64$(OBJ) \
|
||||
extF80M_to_i32$(OBJ) \
|
||||
extF80M_to_i64$(OBJ) \
|
||||
extF80M_to_ui32_r_minMag$(OBJ) \
|
||||
extF80M_to_ui64_r_minMag$(OBJ) \
|
||||
extF80M_to_i32_r_minMag$(OBJ) \
|
||||
extF80M_to_i64_r_minMag$(OBJ) \
|
||||
extF80M_to_f16$(OBJ) \
|
||||
extF80M_to_f32$(OBJ) \
|
||||
extF80M_to_f64$(OBJ) \
|
||||
extF80M_to_f128M$(OBJ) \
|
||||
extF80M_roundToInt$(OBJ) \
|
||||
extF80M_add$(OBJ) \
|
||||
extF80M_sub$(OBJ) \
|
||||
extF80M_mul$(OBJ) \
|
||||
extF80M_div$(OBJ) \
|
||||
extF80M_rem$(OBJ) \
|
||||
extF80M_sqrt$(OBJ) \
|
||||
extF80M_eq$(OBJ) \
|
||||
extF80M_le$(OBJ) \
|
||||
extF80M_lt$(OBJ) \
|
||||
extF80M_eq_signaling$(OBJ) \
|
||||
extF80M_le_quiet$(OBJ) \
|
||||
extF80M_lt_quiet$(OBJ) \
|
||||
f128_to_ui32$(OBJ) \
|
||||
f128_to_ui64$(OBJ) \
|
||||
f128_to_i32$(OBJ) \
|
||||
f128_to_i64$(OBJ) \
|
||||
f128_to_ui32_r_minMag$(OBJ) \
|
||||
f128_to_ui64_r_minMag$(OBJ) \
|
||||
f128_to_i32_r_minMag$(OBJ) \
|
||||
f128_to_i64_r_minMag$(OBJ) \
|
||||
f128_to_f16$(OBJ) \
|
||||
f128_to_f32$(OBJ) \
|
||||
f128_to_extF80$(OBJ) \
|
||||
f128_to_f64$(OBJ) \
|
||||
f128_roundToInt$(OBJ) \
|
||||
f128_add$(OBJ) \
|
||||
f128_sub$(OBJ) \
|
||||
f128_mul$(OBJ) \
|
||||
f128_mulAdd$(OBJ) \
|
||||
f128_div$(OBJ) \
|
||||
f128_rem$(OBJ) \
|
||||
f128_sqrt$(OBJ) \
|
||||
f128_eq$(OBJ) \
|
||||
f128_le$(OBJ) \
|
||||
f128_lt$(OBJ) \
|
||||
f128_eq_signaling$(OBJ) \
|
||||
f128_le_quiet$(OBJ) \
|
||||
f128_lt_quiet$(OBJ) \
|
||||
f128_isSignalingNaN$(OBJ) \
|
||||
f128M_to_ui32$(OBJ) \
|
||||
f128M_to_ui64$(OBJ) \
|
||||
f128M_to_i32$(OBJ) \
|
||||
f128M_to_i64$(OBJ) \
|
||||
f128M_to_ui32_r_minMag$(OBJ) \
|
||||
f128M_to_ui64_r_minMag$(OBJ) \
|
||||
f128M_to_i32_r_minMag$(OBJ) \
|
||||
f128M_to_i64_r_minMag$(OBJ) \
|
||||
f128M_to_f16$(OBJ) \
|
||||
f128M_to_f32$(OBJ) \
|
||||
f128M_to_extF80M$(OBJ) \
|
||||
f128M_to_f64$(OBJ) \
|
||||
f128M_roundToInt$(OBJ) \
|
||||
f128M_add$(OBJ) \
|
||||
f128M_sub$(OBJ) \
|
||||
f128M_mul$(OBJ) \
|
||||
f128M_mulAdd$(OBJ) \
|
||||
f128M_div$(OBJ) \
|
||||
f128M_rem$(OBJ) \
|
||||
f128M_sqrt$(OBJ) \
|
||||
f128M_eq$(OBJ) \
|
||||
f128M_le$(OBJ) \
|
||||
f128M_lt$(OBJ) \
|
||||
f128M_eq_signaling$(OBJ) \
|
||||
f128M_le_quiet$(OBJ) \
|
||||
f128M_lt_quiet$(OBJ) \
|
||||
|
||||
OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS)
|
||||
|
||||
$(OBJS_ALL): \
|
||||
$(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \
|
||||
$(SOURCE_DIR)/include/primitives.h
|
||||
$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \
|
||||
$(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \
|
||||
$(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \
|
||||
$(SOURCE_DIR)/include/softfloat.h
|
||||
|
||||
$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c
|
||||
$(COMPILE_C) $(SOURCE_DIR)/$*.c
|
||||
|
||||
$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c
|
||||
$(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c
|
||||
|
||||
softfloat$(LIB): $(OBJS_ALL)
|
||||
$(DELETE) $@
|
||||
$(MAKELIB) $^
|
||||
|
||||
.PHONY: clean
|
||||
clean:
|
||||
$(DELETE) $(OBJS_ALL) softfloat$(LIB)
|
||||
|
||||
|
||||
#=============================================================================
|
||||
#
|
||||
# This Makefile is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
# Package, Release 3e, by John R. Hauser.
|
||||
#
|
||||
# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
|
||||
# University of California. All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions are met:
|
||||
#
|
||||
# 1. Redistributions of source code must retain the above copyright notice,
|
||||
# this list of conditions, and the following disclaimer.
|
||||
#
|
||||
# 2. Redistributions in binary form must reproduce the above copyright
|
||||
# notice, this list of conditions, and the following disclaimer in the
|
||||
# documentation and/or other materials provided with the distribution.
|
||||
#
|
||||
# 3. Neither the name of the University nor the names of its contributors
|
||||
# may be used to endorse or promote products derived from this software
|
||||
# without specific prior written permission.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
# DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
#
|
||||
#=============================================================================
|
||||
|
||||
SOURCE_DIR ?= ../../source
|
||||
SPECIALIZE_TYPE ?= 8086-SSE
|
||||
|
||||
SOFTFLOAT_OPTS ?= \
|
||||
-DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \
|
||||
-DSOFTFLOAT_FAST_DIV64TO32
|
||||
|
||||
DELETE = rm -f
|
||||
C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include
|
||||
COMPILE_C = \
|
||||
gcc -c -Werror-implicit-function-declaration -DSOFTFLOAT_FAST_INT64 \
|
||||
$(SOFTFLOAT_OPTS) $(C_INCLUDES) -O2 -o $@
|
||||
MAKELIB = ar crs $@
|
||||
|
||||
OBJ = .o
|
||||
LIB = .a
|
||||
|
||||
OTHER_HEADERS = $(SOURCE_DIR)/include/opts-GCC.h
|
||||
|
||||
.PHONY: all
|
||||
all: softfloat$(LIB)
|
||||
|
||||
OBJS_PRIMITIVES = \
|
||||
s_eq128$(OBJ) \
|
||||
s_le128$(OBJ) \
|
||||
s_lt128$(OBJ) \
|
||||
s_shortShiftLeft128$(OBJ) \
|
||||
s_shortShiftRight128$(OBJ) \
|
||||
s_shortShiftRightJam64$(OBJ) \
|
||||
s_shortShiftRightJam64Extra$(OBJ) \
|
||||
s_shortShiftRightJam128$(OBJ) \
|
||||
s_shortShiftRightJam128Extra$(OBJ) \
|
||||
s_shiftRightJam32$(OBJ) \
|
||||
s_shiftRightJam64$(OBJ) \
|
||||
s_shiftRightJam64Extra$(OBJ) \
|
||||
s_shiftRightJam128$(OBJ) \
|
||||
s_shiftRightJam128Extra$(OBJ) \
|
||||
s_shiftRightJam256M$(OBJ) \
|
||||
s_countLeadingZeros8$(OBJ) \
|
||||
s_countLeadingZeros16$(OBJ) \
|
||||
s_countLeadingZeros32$(OBJ) \
|
||||
s_countLeadingZeros64$(OBJ) \
|
||||
s_add128$(OBJ) \
|
||||
s_add256M$(OBJ) \
|
||||
s_sub128$(OBJ) \
|
||||
s_sub256M$(OBJ) \
|
||||
s_mul64ByShifted32To128$(OBJ) \
|
||||
s_mul64To128$(OBJ) \
|
||||
s_mul128By32$(OBJ) \
|
||||
s_mul128To256M$(OBJ) \
|
||||
s_approxRecip_1Ks$(OBJ) \
|
||||
s_approxRecip32_1$(OBJ) \
|
||||
s_approxRecipSqrt_1Ks$(OBJ) \
|
||||
s_approxRecipSqrt32_1$(OBJ) \
|
||||
|
||||
OBJS_SPECIALIZE = \
|
||||
softfloat_raiseFlags$(OBJ) \
|
||||
s_f16UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF16UI$(OBJ) \
|
||||
s_propagateNaNF16UI$(OBJ) \
|
||||
s_bf16UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToBF16UI$(OBJ) \
|
||||
s_f32UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF32UI$(OBJ) \
|
||||
s_propagateNaNF32UI$(OBJ) \
|
||||
s_f64UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF64UI$(OBJ) \
|
||||
s_propagateNaNF64UI$(OBJ) \
|
||||
extF80M_isSignalingNaN$(OBJ) \
|
||||
s_extF80UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToExtF80UI$(OBJ) \
|
||||
s_propagateNaNExtF80UI$(OBJ) \
|
||||
f128M_isSignalingNaN$(OBJ) \
|
||||
s_f128UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF128UI$(OBJ) \
|
||||
s_propagateNaNF128UI$(OBJ) \
|
||||
|
||||
OBJS_OTHERS = \
|
||||
s_roundToUI32$(OBJ) \
|
||||
s_roundToUI64$(OBJ) \
|
||||
s_roundToI32$(OBJ) \
|
||||
s_roundToI64$(OBJ) \
|
||||
s_normSubnormalBF16Sig$(OBJ) \
|
||||
s_roundPackToBF16$(OBJ) \
|
||||
s_normSubnormalF16Sig$(OBJ) \
|
||||
s_roundPackToF16$(OBJ) \
|
||||
s_normRoundPackToF16$(OBJ) \
|
||||
s_addMagsF16$(OBJ) \
|
||||
s_subMagsF16$(OBJ) \
|
||||
s_mulAddF16$(OBJ) \
|
||||
s_normSubnormalF32Sig$(OBJ) \
|
||||
s_roundPackToF32$(OBJ) \
|
||||
s_normRoundPackToF32$(OBJ) \
|
||||
s_addMagsF32$(OBJ) \
|
||||
s_subMagsF32$(OBJ) \
|
||||
s_mulAddF32$(OBJ) \
|
||||
s_normSubnormalF64Sig$(OBJ) \
|
||||
s_roundPackToF64$(OBJ) \
|
||||
s_normRoundPackToF64$(OBJ) \
|
||||
s_addMagsF64$(OBJ) \
|
||||
s_subMagsF64$(OBJ) \
|
||||
s_mulAddF64$(OBJ) \
|
||||
s_normSubnormalExtF80Sig$(OBJ) \
|
||||
s_roundPackToExtF80$(OBJ) \
|
||||
s_normRoundPackToExtF80$(OBJ) \
|
||||
s_addMagsExtF80$(OBJ) \
|
||||
s_subMagsExtF80$(OBJ) \
|
||||
s_normSubnormalF128Sig$(OBJ) \
|
||||
s_roundPackToF128$(OBJ) \
|
||||
s_normRoundPackToF128$(OBJ) \
|
||||
s_addMagsF128$(OBJ) \
|
||||
s_subMagsF128$(OBJ) \
|
||||
s_mulAddF128$(OBJ) \
|
||||
softfloat_state$(OBJ) \
|
||||
ui32_to_f16$(OBJ) \
|
||||
ui32_to_f32$(OBJ) \
|
||||
ui32_to_f64$(OBJ) \
|
||||
ui32_to_extF80$(OBJ) \
|
||||
ui32_to_extF80M$(OBJ) \
|
||||
ui32_to_f128$(OBJ) \
|
||||
ui32_to_f128M$(OBJ) \
|
||||
ui64_to_f16$(OBJ) \
|
||||
ui64_to_f32$(OBJ) \
|
||||
ui64_to_f64$(OBJ) \
|
||||
ui64_to_extF80$(OBJ) \
|
||||
ui64_to_extF80M$(OBJ) \
|
||||
ui64_to_f128$(OBJ) \
|
||||
ui64_to_f128M$(OBJ) \
|
||||
i32_to_f16$(OBJ) \
|
||||
i32_to_f32$(OBJ) \
|
||||
i32_to_f64$(OBJ) \
|
||||
i32_to_extF80$(OBJ) \
|
||||
i32_to_extF80M$(OBJ) \
|
||||
i32_to_f128$(OBJ) \
|
||||
i32_to_f128M$(OBJ) \
|
||||
i64_to_f16$(OBJ) \
|
||||
i64_to_f32$(OBJ) \
|
||||
i64_to_f64$(OBJ) \
|
||||
i64_to_extF80$(OBJ) \
|
||||
i64_to_extF80M$(OBJ) \
|
||||
i64_to_f128$(OBJ) \
|
||||
i64_to_f128M$(OBJ) \
|
||||
bf16_isSignalingNaN$(OBJ) \
|
||||
bf16_to_f32$(OBJ) \
|
||||
f16_to_ui32$(OBJ) \
|
||||
f16_to_ui64$(OBJ) \
|
||||
f16_to_i32$(OBJ) \
|
||||
f16_to_i64$(OBJ) \
|
||||
f16_to_ui32_r_minMag$(OBJ) \
|
||||
f16_to_ui64_r_minMag$(OBJ) \
|
||||
f16_to_i32_r_minMag$(OBJ) \
|
||||
f16_to_i64_r_minMag$(OBJ) \
|
||||
f16_to_f32$(OBJ) \
|
||||
f16_to_f64$(OBJ) \
|
||||
f16_to_extF80$(OBJ) \
|
||||
f16_to_extF80M$(OBJ) \
|
||||
f16_to_f128$(OBJ) \
|
||||
f16_to_f128M$(OBJ) \
|
||||
f16_roundToInt$(OBJ) \
|
||||
f16_add$(OBJ) \
|
||||
f16_sub$(OBJ) \
|
||||
f16_mul$(OBJ) \
|
||||
f16_mulAdd$(OBJ) \
|
||||
f16_div$(OBJ) \
|
||||
f16_rem$(OBJ) \
|
||||
f16_sqrt$(OBJ) \
|
||||
f16_eq$(OBJ) \
|
||||
f16_le$(OBJ) \
|
||||
f16_lt$(OBJ) \
|
||||
f16_eq_signaling$(OBJ) \
|
||||
f16_le_quiet$(OBJ) \
|
||||
f16_lt_quiet$(OBJ) \
|
||||
f16_isSignalingNaN$(OBJ) \
|
||||
f32_to_ui32$(OBJ) \
|
||||
f32_to_ui64$(OBJ) \
|
||||
f32_to_i32$(OBJ) \
|
||||
f32_to_i64$(OBJ) \
|
||||
f32_to_ui32_r_minMag$(OBJ) \
|
||||
f32_to_ui64_r_minMag$(OBJ) \
|
||||
f32_to_i32_r_minMag$(OBJ) \
|
||||
f32_to_i64_r_minMag$(OBJ) \
|
||||
f32_to_bf16$(OBJ) \
|
||||
f32_to_f16$(OBJ) \
|
||||
f32_to_f64$(OBJ) \
|
||||
f32_to_extF80$(OBJ) \
|
||||
f32_to_extF80M$(OBJ) \
|
||||
f32_to_f128$(OBJ) \
|
||||
f32_to_f128M$(OBJ) \
|
||||
f32_roundToInt$(OBJ) \
|
||||
f32_add$(OBJ) \
|
||||
f32_sub$(OBJ) \
|
||||
f32_mul$(OBJ) \
|
||||
f32_mulAdd$(OBJ) \
|
||||
f32_div$(OBJ) \
|
||||
f32_rem$(OBJ) \
|
||||
f32_sqrt$(OBJ) \
|
||||
f32_eq$(OBJ) \
|
||||
f32_le$(OBJ) \
|
||||
f32_lt$(OBJ) \
|
||||
f32_eq_signaling$(OBJ) \
|
||||
f32_le_quiet$(OBJ) \
|
||||
f32_lt_quiet$(OBJ) \
|
||||
f32_isSignalingNaN$(OBJ) \
|
||||
f64_to_ui32$(OBJ) \
|
||||
f64_to_ui64$(OBJ) \
|
||||
f64_to_i32$(OBJ) \
|
||||
f64_to_i64$(OBJ) \
|
||||
f64_to_ui32_r_minMag$(OBJ) \
|
||||
f64_to_ui64_r_minMag$(OBJ) \
|
||||
f64_to_i32_r_minMag$(OBJ) \
|
||||
f64_to_i64_r_minMag$(OBJ) \
|
||||
f64_to_f16$(OBJ) \
|
||||
f64_to_f32$(OBJ) \
|
||||
f64_to_extF80$(OBJ) \
|
||||
f64_to_extF80M$(OBJ) \
|
||||
f64_to_f128$(OBJ) \
|
||||
f64_to_f128M$(OBJ) \
|
||||
f64_roundToInt$(OBJ) \
|
||||
f64_add$(OBJ) \
|
||||
f64_sub$(OBJ) \
|
||||
f64_mul$(OBJ) \
|
||||
f64_mulAdd$(OBJ) \
|
||||
f64_div$(OBJ) \
|
||||
f64_rem$(OBJ) \
|
||||
f64_sqrt$(OBJ) \
|
||||
f64_eq$(OBJ) \
|
||||
f64_le$(OBJ) \
|
||||
f64_lt$(OBJ) \
|
||||
f64_eq_signaling$(OBJ) \
|
||||
f64_le_quiet$(OBJ) \
|
||||
f64_lt_quiet$(OBJ) \
|
||||
f64_isSignalingNaN$(OBJ) \
|
||||
extF80_to_ui32$(OBJ) \
|
||||
extF80_to_ui64$(OBJ) \
|
||||
extF80_to_i32$(OBJ) \
|
||||
extF80_to_i64$(OBJ) \
|
||||
extF80_to_ui32_r_minMag$(OBJ) \
|
||||
extF80_to_ui64_r_minMag$(OBJ) \
|
||||
extF80_to_i32_r_minMag$(OBJ) \
|
||||
extF80_to_i64_r_minMag$(OBJ) \
|
||||
extF80_to_f16$(OBJ) \
|
||||
extF80_to_f32$(OBJ) \
|
||||
extF80_to_f64$(OBJ) \
|
||||
extF80_to_f128$(OBJ) \
|
||||
extF80_roundToInt$(OBJ) \
|
||||
extF80_add$(OBJ) \
|
||||
extF80_sub$(OBJ) \
|
||||
extF80_mul$(OBJ) \
|
||||
extF80_div$(OBJ) \
|
||||
extF80_rem$(OBJ) \
|
||||
extF80_sqrt$(OBJ) \
|
||||
extF80_eq$(OBJ) \
|
||||
extF80_le$(OBJ) \
|
||||
extF80_lt$(OBJ) \
|
||||
extF80_eq_signaling$(OBJ) \
|
||||
extF80_le_quiet$(OBJ) \
|
||||
extF80_lt_quiet$(OBJ) \
|
||||
extF80_isSignalingNaN$(OBJ) \
|
||||
extF80M_to_ui32$(OBJ) \
|
||||
extF80M_to_ui64$(OBJ) \
|
||||
extF80M_to_i32$(OBJ) \
|
||||
extF80M_to_i64$(OBJ) \
|
||||
extF80M_to_ui32_r_minMag$(OBJ) \
|
||||
extF80M_to_ui64_r_minMag$(OBJ) \
|
||||
extF80M_to_i32_r_minMag$(OBJ) \
|
||||
extF80M_to_i64_r_minMag$(OBJ) \
|
||||
extF80M_to_f16$(OBJ) \
|
||||
extF80M_to_f32$(OBJ) \
|
||||
extF80M_to_f64$(OBJ) \
|
||||
extF80M_to_f128M$(OBJ) \
|
||||
extF80M_roundToInt$(OBJ) \
|
||||
extF80M_add$(OBJ) \
|
||||
extF80M_sub$(OBJ) \
|
||||
extF80M_mul$(OBJ) \
|
||||
extF80M_div$(OBJ) \
|
||||
extF80M_rem$(OBJ) \
|
||||
extF80M_sqrt$(OBJ) \
|
||||
extF80M_eq$(OBJ) \
|
||||
extF80M_le$(OBJ) \
|
||||
extF80M_lt$(OBJ) \
|
||||
extF80M_eq_signaling$(OBJ) \
|
||||
extF80M_le_quiet$(OBJ) \
|
||||
extF80M_lt_quiet$(OBJ) \
|
||||
f128_to_ui32$(OBJ) \
|
||||
f128_to_ui64$(OBJ) \
|
||||
f128_to_i32$(OBJ) \
|
||||
f128_to_i64$(OBJ) \
|
||||
f128_to_ui32_r_minMag$(OBJ) \
|
||||
f128_to_ui64_r_minMag$(OBJ) \
|
||||
f128_to_i32_r_minMag$(OBJ) \
|
||||
f128_to_i64_r_minMag$(OBJ) \
|
||||
f128_to_f16$(OBJ) \
|
||||
f128_to_f32$(OBJ) \
|
||||
f128_to_extF80$(OBJ) \
|
||||
f128_to_f64$(OBJ) \
|
||||
f128_roundToInt$(OBJ) \
|
||||
f128_add$(OBJ) \
|
||||
f128_sub$(OBJ) \
|
||||
f128_mul$(OBJ) \
|
||||
f128_mulAdd$(OBJ) \
|
||||
f128_div$(OBJ) \
|
||||
f128_rem$(OBJ) \
|
||||
f128_sqrt$(OBJ) \
|
||||
f128_eq$(OBJ) \
|
||||
f128_le$(OBJ) \
|
||||
f128_lt$(OBJ) \
|
||||
f128_eq_signaling$(OBJ) \
|
||||
f128_le_quiet$(OBJ) \
|
||||
f128_lt_quiet$(OBJ) \
|
||||
f128_isSignalingNaN$(OBJ) \
|
||||
f128M_to_ui32$(OBJ) \
|
||||
f128M_to_ui64$(OBJ) \
|
||||
f128M_to_i32$(OBJ) \
|
||||
f128M_to_i64$(OBJ) \
|
||||
f128M_to_ui32_r_minMag$(OBJ) \
|
||||
f128M_to_ui64_r_minMag$(OBJ) \
|
||||
f128M_to_i32_r_minMag$(OBJ) \
|
||||
f128M_to_i64_r_minMag$(OBJ) \
|
||||
f128M_to_f16$(OBJ) \
|
||||
f128M_to_f32$(OBJ) \
|
||||
f128M_to_extF80M$(OBJ) \
|
||||
f128M_to_f64$(OBJ) \
|
||||
f128M_roundToInt$(OBJ) \
|
||||
f128M_add$(OBJ) \
|
||||
f128M_sub$(OBJ) \
|
||||
f128M_mul$(OBJ) \
|
||||
f128M_mulAdd$(OBJ) \
|
||||
f128M_div$(OBJ) \
|
||||
f128M_rem$(OBJ) \
|
||||
f128M_sqrt$(OBJ) \
|
||||
f128M_eq$(OBJ) \
|
||||
f128M_le$(OBJ) \
|
||||
f128M_lt$(OBJ) \
|
||||
f128M_eq_signaling$(OBJ) \
|
||||
f128M_le_quiet$(OBJ) \
|
||||
f128M_lt_quiet$(OBJ) \
|
||||
|
||||
OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS)
|
||||
|
||||
$(OBJS_ALL): \
|
||||
$(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \
|
||||
$(SOURCE_DIR)/include/primitives.h
|
||||
$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \
|
||||
$(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \
|
||||
$(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \
|
||||
$(SOURCE_DIR)/include/softfloat.h
|
||||
|
||||
$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c
|
||||
$(COMPILE_C) $(SOURCE_DIR)/$*.c
|
||||
|
||||
$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c
|
||||
$(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c
|
||||
|
||||
softfloat$(LIB): $(OBJS_ALL)
|
||||
$(DELETE) $@
|
||||
$(MAKELIB) $^
|
||||
|
||||
.PHONY: clean
|
||||
clean:
|
||||
$(DELETE) $(OBJS_ALL) softfloat$(LIB)
|
||||
|
||||
|
@ -1,56 +1,56 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
|
||||
University of California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define LITTLEENDIAN 1
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#ifdef __GNUC_STDC_INLINE__
|
||||
//#define INLINE inline
|
||||
#define INLINE static
|
||||
#else
|
||||
#define INLINE extern inline
|
||||
#endif
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#ifdef __GNUC__
|
||||
#define SOFTFLOAT_BUILTIN_CLZ 1
|
||||
#define SOFTFLOAT_INTRINSIC_INT128 1
|
||||
#endif
|
||||
#include "opts-GCC.h"
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
|
||||
University of California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define LITTLEENDIAN 1
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#ifdef __GNUC_STDC_INLINE__
|
||||
//#define INLINE inline
|
||||
#define INLINE static
|
||||
#else
|
||||
#define INLINE extern inline
|
||||
#endif
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#ifdef __GNUC__
|
||||
#define SOFTFLOAT_BUILTIN_CLZ 1
|
||||
#define SOFTFLOAT_INTRINSIC_INT128 1
|
||||
#endif
|
||||
#include "opts-GCC.h"
|
||||
|
@ -1,325 +1,325 @@
|
||||
|
||||
#=============================================================================
|
||||
#
|
||||
# This Makefile is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
# Package, Release 3e, by John R. Hauser.
|
||||
#
|
||||
# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
|
||||
# University of California. All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions are met:
|
||||
#
|
||||
# 1. Redistributions of source code must retain the above copyright notice,
|
||||
# this list of conditions, and the following disclaimer.
|
||||
#
|
||||
# 2. Redistributions in binary form must reproduce the above copyright
|
||||
# notice, this list of conditions, and the following disclaimer in the
|
||||
# documentation and/or other materials provided with the distribution.
|
||||
#
|
||||
# 3. Neither the name of the University nor the names of its contributors
|
||||
# may be used to endorse or promote products derived from this software
|
||||
# without specific prior written permission.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
# DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
#
|
||||
#=============================================================================
|
||||
|
||||
SOURCE_DIR ?= ../../source
|
||||
SPECIALIZE_TYPE ?= 8086
|
||||
|
||||
SOFTFLOAT_OPTS ?= \
|
||||
-DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \
|
||||
-DSOFTFLOAT_FAST_DIV64TO32
|
||||
|
||||
DELETE = rm -f
|
||||
C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include
|
||||
COMPILE_C = \
|
||||
gcc -c -Werror-implicit-function-declaration $(SOFTFLOAT_OPTS) \
|
||||
$(C_INCLUDES) -O2 -o $@
|
||||
MAKELIB = ar crs $@
|
||||
|
||||
OBJ = .o
|
||||
LIB = .a
|
||||
|
||||
OTHER_HEADERS =
|
||||
|
||||
.PHONY: all
|
||||
all: softfloat$(LIB)
|
||||
|
||||
OBJS_PRIMITIVES = \
|
||||
s_compare96M$(OBJ) \
|
||||
s_compare128M$(OBJ) \
|
||||
s_shortShiftLeft64To96M$(OBJ) \
|
||||
s_shortShiftLeftM$(OBJ) \
|
||||
s_shiftLeftM$(OBJ) \
|
||||
s_shortShiftRightM$(OBJ) \
|
||||
s_shortShiftRightJam64$(OBJ) \
|
||||
s_shortShiftRightJamM$(OBJ) \
|
||||
s_shiftRightJam32$(OBJ) \
|
||||
s_shiftRightJam64$(OBJ) \
|
||||
s_shiftRightJamM$(OBJ) \
|
||||
s_shiftRightM$(OBJ) \
|
||||
s_countLeadingZeros8$(OBJ) \
|
||||
s_countLeadingZeros16$(OBJ) \
|
||||
s_countLeadingZeros32$(OBJ) \
|
||||
s_countLeadingZeros64$(OBJ) \
|
||||
s_addM$(OBJ) \
|
||||
s_addCarryM$(OBJ) \
|
||||
s_addComplCarryM$(OBJ) \
|
||||
s_negXM$(OBJ) \
|
||||
s_sub1XM$(OBJ) \
|
||||
s_subM$(OBJ) \
|
||||
s_mul64To128M$(OBJ) \
|
||||
s_mul128MTo256M$(OBJ) \
|
||||
s_approxRecip_1Ks$(OBJ) \
|
||||
s_approxRecip32_1$(OBJ) \
|
||||
s_approxRecipSqrt_1Ks$(OBJ) \
|
||||
s_approxRecipSqrt32_1$(OBJ) \
|
||||
s_remStepMBy32$(OBJ) \
|
||||
|
||||
OBJS_SPECIALIZE = \
|
||||
softfloat_raiseFlags$(OBJ) \
|
||||
s_f16UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF16UI$(OBJ) \
|
||||
s_propagateNaNF16UI$(OBJ) \
|
||||
s_f32UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF32UI$(OBJ) \
|
||||
s_propagateNaNF32UI$(OBJ) \
|
||||
s_f64UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF64UI$(OBJ) \
|
||||
s_propagateNaNF64UI$(OBJ) \
|
||||
extF80M_isSignalingNaN$(OBJ) \
|
||||
s_extF80MToCommonNaN$(OBJ) \
|
||||
s_commonNaNToExtF80M$(OBJ) \
|
||||
s_propagateNaNExtF80M$(OBJ) \
|
||||
f128M_isSignalingNaN$(OBJ) \
|
||||
s_f128MToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF128M$(OBJ) \
|
||||
s_propagateNaNF128M$(OBJ) \
|
||||
|
||||
OBJS_OTHERS = \
|
||||
s_roundToUI32$(OBJ) \
|
||||
s_roundMToUI64$(OBJ) \
|
||||
s_roundToI32$(OBJ) \
|
||||
s_roundMToI64$(OBJ) \
|
||||
s_normSubnormalF16Sig$(OBJ) \
|
||||
s_roundPackToF16$(OBJ) \
|
||||
s_normRoundPackToF16$(OBJ) \
|
||||
s_addMagsF16$(OBJ) \
|
||||
s_subMagsF16$(OBJ) \
|
||||
s_mulAddF16$(OBJ) \
|
||||
s_normSubnormalF32Sig$(OBJ) \
|
||||
s_roundPackToF32$(OBJ) \
|
||||
s_normRoundPackToF32$(OBJ) \
|
||||
s_addMagsF32$(OBJ) \
|
||||
s_subMagsF32$(OBJ) \
|
||||
s_mulAddF32$(OBJ) \
|
||||
s_normSubnormalF64Sig$(OBJ) \
|
||||
s_roundPackToF64$(OBJ) \
|
||||
s_normRoundPackToF64$(OBJ) \
|
||||
s_addMagsF64$(OBJ) \
|
||||
s_subMagsF64$(OBJ) \
|
||||
s_mulAddF64$(OBJ) \
|
||||
s_tryPropagateNaNExtF80M$(OBJ) \
|
||||
s_invalidExtF80M$(OBJ) \
|
||||
s_normExtF80SigM$(OBJ) \
|
||||
s_roundPackMToExtF80M$(OBJ) \
|
||||
s_normRoundPackMToExtF80M$(OBJ) \
|
||||
s_addExtF80M$(OBJ) \
|
||||
s_compareNonnormExtF80M$(OBJ) \
|
||||
s_isNaNF128M$(OBJ) \
|
||||
s_tryPropagateNaNF128M$(OBJ) \
|
||||
s_invalidF128M$(OBJ) \
|
||||
s_shiftNormSigF128M$(OBJ) \
|
||||
s_roundPackMToF128M$(OBJ) \
|
||||
s_normRoundPackMToF128M$(OBJ) \
|
||||
s_addF128M$(OBJ) \
|
||||
s_mulAddF128M$(OBJ) \
|
||||
softfloat_state$(OBJ) \
|
||||
ui32_to_f16$(OBJ) \
|
||||
ui32_to_f32$(OBJ) \
|
||||
ui32_to_f64$(OBJ) \
|
||||
ui32_to_extF80M$(OBJ) \
|
||||
ui32_to_f128M$(OBJ) \
|
||||
ui64_to_f16$(OBJ) \
|
||||
ui64_to_f32$(OBJ) \
|
||||
ui64_to_f64$(OBJ) \
|
||||
ui64_to_extF80M$(OBJ) \
|
||||
ui64_to_f128M$(OBJ) \
|
||||
i32_to_f16$(OBJ) \
|
||||
i32_to_f32$(OBJ) \
|
||||
i32_to_f64$(OBJ) \
|
||||
i32_to_extF80M$(OBJ) \
|
||||
i32_to_f128M$(OBJ) \
|
||||
i64_to_f16$(OBJ) \
|
||||
i64_to_f32$(OBJ) \
|
||||
i64_to_f64$(OBJ) \
|
||||
i64_to_extF80M$(OBJ) \
|
||||
i64_to_f128M$(OBJ) \
|
||||
f16_to_ui32$(OBJ) \
|
||||
f16_to_ui64$(OBJ) \
|
||||
f16_to_i32$(OBJ) \
|
||||
f16_to_i64$(OBJ) \
|
||||
f16_to_ui32_r_minMag$(OBJ) \
|
||||
f16_to_ui64_r_minMag$(OBJ) \
|
||||
f16_to_i32_r_minMag$(OBJ) \
|
||||
f16_to_i64_r_minMag$(OBJ) \
|
||||
f16_to_f32$(OBJ) \
|
||||
f16_to_f64$(OBJ) \
|
||||
f16_to_extF80M$(OBJ) \
|
||||
f16_to_f128M$(OBJ) \
|
||||
f16_roundToInt$(OBJ) \
|
||||
f16_add$(OBJ) \
|
||||
f16_sub$(OBJ) \
|
||||
f16_mul$(OBJ) \
|
||||
f16_mulAdd$(OBJ) \
|
||||
f16_div$(OBJ) \
|
||||
f16_rem$(OBJ) \
|
||||
f16_sqrt$(OBJ) \
|
||||
f16_eq$(OBJ) \
|
||||
f16_le$(OBJ) \
|
||||
f16_lt$(OBJ) \
|
||||
f16_eq_signaling$(OBJ) \
|
||||
f16_le_quiet$(OBJ) \
|
||||
f16_lt_quiet$(OBJ) \
|
||||
f16_isSignalingNaN$(OBJ) \
|
||||
f32_to_ui32$(OBJ) \
|
||||
f32_to_ui64$(OBJ) \
|
||||
f32_to_i32$(OBJ) \
|
||||
f32_to_i64$(OBJ) \
|
||||
f32_to_ui32_r_minMag$(OBJ) \
|
||||
f32_to_ui64_r_minMag$(OBJ) \
|
||||
f32_to_i32_r_minMag$(OBJ) \
|
||||
f32_to_i64_r_minMag$(OBJ) \
|
||||
f32_to_f16$(OBJ) \
|
||||
f32_to_f64$(OBJ) \
|
||||
f32_to_extF80M$(OBJ) \
|
||||
f32_to_f128M$(OBJ) \
|
||||
f32_roundToInt$(OBJ) \
|
||||
f32_add$(OBJ) \
|
||||
f32_sub$(OBJ) \
|
||||
f32_mul$(OBJ) \
|
||||
f32_mulAdd$(OBJ) \
|
||||
f32_div$(OBJ) \
|
||||
f32_rem$(OBJ) \
|
||||
f32_sqrt$(OBJ) \
|
||||
f32_eq$(OBJ) \
|
||||
f32_le$(OBJ) \
|
||||
f32_lt$(OBJ) \
|
||||
f32_eq_signaling$(OBJ) \
|
||||
f32_le_quiet$(OBJ) \
|
||||
f32_lt_quiet$(OBJ) \
|
||||
f32_isSignalingNaN$(OBJ) \
|
||||
f64_to_ui32$(OBJ) \
|
||||
f64_to_ui64$(OBJ) \
|
||||
f64_to_i32$(OBJ) \
|
||||
f64_to_i64$(OBJ) \
|
||||
f64_to_ui32_r_minMag$(OBJ) \
|
||||
f64_to_ui64_r_minMag$(OBJ) \
|
||||
f64_to_i32_r_minMag$(OBJ) \
|
||||
f64_to_i64_r_minMag$(OBJ) \
|
||||
f64_to_f16$(OBJ) \
|
||||
f64_to_f32$(OBJ) \
|
||||
f64_to_extF80M$(OBJ) \
|
||||
f64_to_f128M$(OBJ) \
|
||||
f64_roundToInt$(OBJ) \
|
||||
f64_add$(OBJ) \
|
||||
f64_sub$(OBJ) \
|
||||
f64_mul$(OBJ) \
|
||||
f64_mulAdd$(OBJ) \
|
||||
f64_div$(OBJ) \
|
||||
f64_rem$(OBJ) \
|
||||
f64_sqrt$(OBJ) \
|
||||
f64_eq$(OBJ) \
|
||||
f64_le$(OBJ) \
|
||||
f64_lt$(OBJ) \
|
||||
f64_eq_signaling$(OBJ) \
|
||||
f64_le_quiet$(OBJ) \
|
||||
f64_lt_quiet$(OBJ) \
|
||||
f64_isSignalingNaN$(OBJ) \
|
||||
extF80M_to_ui32$(OBJ) \
|
||||
extF80M_to_ui64$(OBJ) \
|
||||
extF80M_to_i32$(OBJ) \
|
||||
extF80M_to_i64$(OBJ) \
|
||||
extF80M_to_ui32_r_minMag$(OBJ) \
|
||||
extF80M_to_ui64_r_minMag$(OBJ) \
|
||||
extF80M_to_i32_r_minMag$(OBJ) \
|
||||
extF80M_to_i64_r_minMag$(OBJ) \
|
||||
extF80M_to_f16$(OBJ) \
|
||||
extF80M_to_f32$(OBJ) \
|
||||
extF80M_to_f64$(OBJ) \
|
||||
extF80M_to_f128M$(OBJ) \
|
||||
extF80M_roundToInt$(OBJ) \
|
||||
extF80M_add$(OBJ) \
|
||||
extF80M_sub$(OBJ) \
|
||||
extF80M_mul$(OBJ) \
|
||||
extF80M_div$(OBJ) \
|
||||
extF80M_rem$(OBJ) \
|
||||
extF80M_sqrt$(OBJ) \
|
||||
extF80M_eq$(OBJ) \
|
||||
extF80M_le$(OBJ) \
|
||||
extF80M_lt$(OBJ) \
|
||||
extF80M_eq_signaling$(OBJ) \
|
||||
extF80M_le_quiet$(OBJ) \
|
||||
extF80M_lt_quiet$(OBJ) \
|
||||
f128M_to_ui32$(OBJ) \
|
||||
f128M_to_ui64$(OBJ) \
|
||||
f128M_to_i32$(OBJ) \
|
||||
f128M_to_i64$(OBJ) \
|
||||
f128M_to_ui32_r_minMag$(OBJ) \
|
||||
f128M_to_ui64_r_minMag$(OBJ) \
|
||||
f128M_to_i32_r_minMag$(OBJ) \
|
||||
f128M_to_i64_r_minMag$(OBJ) \
|
||||
f128M_to_f16$(OBJ) \
|
||||
f128M_to_f32$(OBJ) \
|
||||
f128M_to_f64$(OBJ) \
|
||||
f128M_to_extF80M$(OBJ) \
|
||||
f128M_roundToInt$(OBJ) \
|
||||
f128M_add$(OBJ) \
|
||||
f128M_sub$(OBJ) \
|
||||
f128M_mul$(OBJ) \
|
||||
f128M_mulAdd$(OBJ) \
|
||||
f128M_div$(OBJ) \
|
||||
f128M_rem$(OBJ) \
|
||||
f128M_sqrt$(OBJ) \
|
||||
f128M_eq$(OBJ) \
|
||||
f128M_le$(OBJ) \
|
||||
f128M_lt$(OBJ) \
|
||||
f128M_eq_signaling$(OBJ) \
|
||||
f128M_le_quiet$(OBJ) \
|
||||
f128M_lt_quiet$(OBJ) \
|
||||
|
||||
OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS)
|
||||
|
||||
$(OBJS_ALL): \
|
||||
$(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \
|
||||
$(SOURCE_DIR)/include/primitives.h
|
||||
$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \
|
||||
$(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \
|
||||
$(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \
|
||||
$(SOURCE_DIR)/include/softfloat.h
|
||||
|
||||
$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c
|
||||
$(COMPILE_C) $(SOURCE_DIR)/$*.c
|
||||
|
||||
$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c
|
||||
$(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c
|
||||
|
||||
softfloat$(LIB): $(OBJS_ALL)
|
||||
$(DELETE) $@
|
||||
$(MAKELIB) $^
|
||||
|
||||
.PHONY: clean
|
||||
clean:
|
||||
$(DELETE) $(OBJS_ALL) softfloat$(LIB)
|
||||
|
||||
|
||||
#=============================================================================
|
||||
#
|
||||
# This Makefile is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
# Package, Release 3e, by John R. Hauser.
|
||||
#
|
||||
# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
|
||||
# University of California. All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions are met:
|
||||
#
|
||||
# 1. Redistributions of source code must retain the above copyright notice,
|
||||
# this list of conditions, and the following disclaimer.
|
||||
#
|
||||
# 2. Redistributions in binary form must reproduce the above copyright
|
||||
# notice, this list of conditions, and the following disclaimer in the
|
||||
# documentation and/or other materials provided with the distribution.
|
||||
#
|
||||
# 3. Neither the name of the University nor the names of its contributors
|
||||
# may be used to endorse or promote products derived from this software
|
||||
# without specific prior written permission.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
# DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
#
|
||||
#=============================================================================
|
||||
|
||||
SOURCE_DIR ?= ../../source
|
||||
SPECIALIZE_TYPE ?= 8086
|
||||
|
||||
SOFTFLOAT_OPTS ?= \
|
||||
-DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \
|
||||
-DSOFTFLOAT_FAST_DIV64TO32
|
||||
|
||||
DELETE = rm -f
|
||||
C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include
|
||||
COMPILE_C = \
|
||||
gcc -c -Werror-implicit-function-declaration $(SOFTFLOAT_OPTS) \
|
||||
$(C_INCLUDES) -O2 -o $@
|
||||
MAKELIB = ar crs $@
|
||||
|
||||
OBJ = .o
|
||||
LIB = .a
|
||||
|
||||
OTHER_HEADERS =
|
||||
|
||||
.PHONY: all
|
||||
all: softfloat$(LIB)
|
||||
|
||||
OBJS_PRIMITIVES = \
|
||||
s_compare96M$(OBJ) \
|
||||
s_compare128M$(OBJ) \
|
||||
s_shortShiftLeft64To96M$(OBJ) \
|
||||
s_shortShiftLeftM$(OBJ) \
|
||||
s_shiftLeftM$(OBJ) \
|
||||
s_shortShiftRightM$(OBJ) \
|
||||
s_shortShiftRightJam64$(OBJ) \
|
||||
s_shortShiftRightJamM$(OBJ) \
|
||||
s_shiftRightJam32$(OBJ) \
|
||||
s_shiftRightJam64$(OBJ) \
|
||||
s_shiftRightJamM$(OBJ) \
|
||||
s_shiftRightM$(OBJ) \
|
||||
s_countLeadingZeros8$(OBJ) \
|
||||
s_countLeadingZeros16$(OBJ) \
|
||||
s_countLeadingZeros32$(OBJ) \
|
||||
s_countLeadingZeros64$(OBJ) \
|
||||
s_addM$(OBJ) \
|
||||
s_addCarryM$(OBJ) \
|
||||
s_addComplCarryM$(OBJ) \
|
||||
s_negXM$(OBJ) \
|
||||
s_sub1XM$(OBJ) \
|
||||
s_subM$(OBJ) \
|
||||
s_mul64To128M$(OBJ) \
|
||||
s_mul128MTo256M$(OBJ) \
|
||||
s_approxRecip_1Ks$(OBJ) \
|
||||
s_approxRecip32_1$(OBJ) \
|
||||
s_approxRecipSqrt_1Ks$(OBJ) \
|
||||
s_approxRecipSqrt32_1$(OBJ) \
|
||||
s_remStepMBy32$(OBJ) \
|
||||
|
||||
OBJS_SPECIALIZE = \
|
||||
softfloat_raiseFlags$(OBJ) \
|
||||
s_f16UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF16UI$(OBJ) \
|
||||
s_propagateNaNF16UI$(OBJ) \
|
||||
s_f32UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF32UI$(OBJ) \
|
||||
s_propagateNaNF32UI$(OBJ) \
|
||||
s_f64UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF64UI$(OBJ) \
|
||||
s_propagateNaNF64UI$(OBJ) \
|
||||
extF80M_isSignalingNaN$(OBJ) \
|
||||
s_extF80MToCommonNaN$(OBJ) \
|
||||
s_commonNaNToExtF80M$(OBJ) \
|
||||
s_propagateNaNExtF80M$(OBJ) \
|
||||
f128M_isSignalingNaN$(OBJ) \
|
||||
s_f128MToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF128M$(OBJ) \
|
||||
s_propagateNaNF128M$(OBJ) \
|
||||
|
||||
OBJS_OTHERS = \
|
||||
s_roundToUI32$(OBJ) \
|
||||
s_roundMToUI64$(OBJ) \
|
||||
s_roundToI32$(OBJ) \
|
||||
s_roundMToI64$(OBJ) \
|
||||
s_normSubnormalF16Sig$(OBJ) \
|
||||
s_roundPackToF16$(OBJ) \
|
||||
s_normRoundPackToF16$(OBJ) \
|
||||
s_addMagsF16$(OBJ) \
|
||||
s_subMagsF16$(OBJ) \
|
||||
s_mulAddF16$(OBJ) \
|
||||
s_normSubnormalF32Sig$(OBJ) \
|
||||
s_roundPackToF32$(OBJ) \
|
||||
s_normRoundPackToF32$(OBJ) \
|
||||
s_addMagsF32$(OBJ) \
|
||||
s_subMagsF32$(OBJ) \
|
||||
s_mulAddF32$(OBJ) \
|
||||
s_normSubnormalF64Sig$(OBJ) \
|
||||
s_roundPackToF64$(OBJ) \
|
||||
s_normRoundPackToF64$(OBJ) \
|
||||
s_addMagsF64$(OBJ) \
|
||||
s_subMagsF64$(OBJ) \
|
||||
s_mulAddF64$(OBJ) \
|
||||
s_tryPropagateNaNExtF80M$(OBJ) \
|
||||
s_invalidExtF80M$(OBJ) \
|
||||
s_normExtF80SigM$(OBJ) \
|
||||
s_roundPackMToExtF80M$(OBJ) \
|
||||
s_normRoundPackMToExtF80M$(OBJ) \
|
||||
s_addExtF80M$(OBJ) \
|
||||
s_compareNonnormExtF80M$(OBJ) \
|
||||
s_isNaNF128M$(OBJ) \
|
||||
s_tryPropagateNaNF128M$(OBJ) \
|
||||
s_invalidF128M$(OBJ) \
|
||||
s_shiftNormSigF128M$(OBJ) \
|
||||
s_roundPackMToF128M$(OBJ) \
|
||||
s_normRoundPackMToF128M$(OBJ) \
|
||||
s_addF128M$(OBJ) \
|
||||
s_mulAddF128M$(OBJ) \
|
||||
softfloat_state$(OBJ) \
|
||||
ui32_to_f16$(OBJ) \
|
||||
ui32_to_f32$(OBJ) \
|
||||
ui32_to_f64$(OBJ) \
|
||||
ui32_to_extF80M$(OBJ) \
|
||||
ui32_to_f128M$(OBJ) \
|
||||
ui64_to_f16$(OBJ) \
|
||||
ui64_to_f32$(OBJ) \
|
||||
ui64_to_f64$(OBJ) \
|
||||
ui64_to_extF80M$(OBJ) \
|
||||
ui64_to_f128M$(OBJ) \
|
||||
i32_to_f16$(OBJ) \
|
||||
i32_to_f32$(OBJ) \
|
||||
i32_to_f64$(OBJ) \
|
||||
i32_to_extF80M$(OBJ) \
|
||||
i32_to_f128M$(OBJ) \
|
||||
i64_to_f16$(OBJ) \
|
||||
i64_to_f32$(OBJ) \
|
||||
i64_to_f64$(OBJ) \
|
||||
i64_to_extF80M$(OBJ) \
|
||||
i64_to_f128M$(OBJ) \
|
||||
f16_to_ui32$(OBJ) \
|
||||
f16_to_ui64$(OBJ) \
|
||||
f16_to_i32$(OBJ) \
|
||||
f16_to_i64$(OBJ) \
|
||||
f16_to_ui32_r_minMag$(OBJ) \
|
||||
f16_to_ui64_r_minMag$(OBJ) \
|
||||
f16_to_i32_r_minMag$(OBJ) \
|
||||
f16_to_i64_r_minMag$(OBJ) \
|
||||
f16_to_f32$(OBJ) \
|
||||
f16_to_f64$(OBJ) \
|
||||
f16_to_extF80M$(OBJ) \
|
||||
f16_to_f128M$(OBJ) \
|
||||
f16_roundToInt$(OBJ) \
|
||||
f16_add$(OBJ) \
|
||||
f16_sub$(OBJ) \
|
||||
f16_mul$(OBJ) \
|
||||
f16_mulAdd$(OBJ) \
|
||||
f16_div$(OBJ) \
|
||||
f16_rem$(OBJ) \
|
||||
f16_sqrt$(OBJ) \
|
||||
f16_eq$(OBJ) \
|
||||
f16_le$(OBJ) \
|
||||
f16_lt$(OBJ) \
|
||||
f16_eq_signaling$(OBJ) \
|
||||
f16_le_quiet$(OBJ) \
|
||||
f16_lt_quiet$(OBJ) \
|
||||
f16_isSignalingNaN$(OBJ) \
|
||||
f32_to_ui32$(OBJ) \
|
||||
f32_to_ui64$(OBJ) \
|
||||
f32_to_i32$(OBJ) \
|
||||
f32_to_i64$(OBJ) \
|
||||
f32_to_ui32_r_minMag$(OBJ) \
|
||||
f32_to_ui64_r_minMag$(OBJ) \
|
||||
f32_to_i32_r_minMag$(OBJ) \
|
||||
f32_to_i64_r_minMag$(OBJ) \
|
||||
f32_to_f16$(OBJ) \
|
||||
f32_to_f64$(OBJ) \
|
||||
f32_to_extF80M$(OBJ) \
|
||||
f32_to_f128M$(OBJ) \
|
||||
f32_roundToInt$(OBJ) \
|
||||
f32_add$(OBJ) \
|
||||
f32_sub$(OBJ) \
|
||||
f32_mul$(OBJ) \
|
||||
f32_mulAdd$(OBJ) \
|
||||
f32_div$(OBJ) \
|
||||
f32_rem$(OBJ) \
|
||||
f32_sqrt$(OBJ) \
|
||||
f32_eq$(OBJ) \
|
||||
f32_le$(OBJ) \
|
||||
f32_lt$(OBJ) \
|
||||
f32_eq_signaling$(OBJ) \
|
||||
f32_le_quiet$(OBJ) \
|
||||
f32_lt_quiet$(OBJ) \
|
||||
f32_isSignalingNaN$(OBJ) \
|
||||
f64_to_ui32$(OBJ) \
|
||||
f64_to_ui64$(OBJ) \
|
||||
f64_to_i32$(OBJ) \
|
||||
f64_to_i64$(OBJ) \
|
||||
f64_to_ui32_r_minMag$(OBJ) \
|
||||
f64_to_ui64_r_minMag$(OBJ) \
|
||||
f64_to_i32_r_minMag$(OBJ) \
|
||||
f64_to_i64_r_minMag$(OBJ) \
|
||||
f64_to_f16$(OBJ) \
|
||||
f64_to_f32$(OBJ) \
|
||||
f64_to_extF80M$(OBJ) \
|
||||
f64_to_f128M$(OBJ) \
|
||||
f64_roundToInt$(OBJ) \
|
||||
f64_add$(OBJ) \
|
||||
f64_sub$(OBJ) \
|
||||
f64_mul$(OBJ) \
|
||||
f64_mulAdd$(OBJ) \
|
||||
f64_div$(OBJ) \
|
||||
f64_rem$(OBJ) \
|
||||
f64_sqrt$(OBJ) \
|
||||
f64_eq$(OBJ) \
|
||||
f64_le$(OBJ) \
|
||||
f64_lt$(OBJ) \
|
||||
f64_eq_signaling$(OBJ) \
|
||||
f64_le_quiet$(OBJ) \
|
||||
f64_lt_quiet$(OBJ) \
|
||||
f64_isSignalingNaN$(OBJ) \
|
||||
extF80M_to_ui32$(OBJ) \
|
||||
extF80M_to_ui64$(OBJ) \
|
||||
extF80M_to_i32$(OBJ) \
|
||||
extF80M_to_i64$(OBJ) \
|
||||
extF80M_to_ui32_r_minMag$(OBJ) \
|
||||
extF80M_to_ui64_r_minMag$(OBJ) \
|
||||
extF80M_to_i32_r_minMag$(OBJ) \
|
||||
extF80M_to_i64_r_minMag$(OBJ) \
|
||||
extF80M_to_f16$(OBJ) \
|
||||
extF80M_to_f32$(OBJ) \
|
||||
extF80M_to_f64$(OBJ) \
|
||||
extF80M_to_f128M$(OBJ) \
|
||||
extF80M_roundToInt$(OBJ) \
|
||||
extF80M_add$(OBJ) \
|
||||
extF80M_sub$(OBJ) \
|
||||
extF80M_mul$(OBJ) \
|
||||
extF80M_div$(OBJ) \
|
||||
extF80M_rem$(OBJ) \
|
||||
extF80M_sqrt$(OBJ) \
|
||||
extF80M_eq$(OBJ) \
|
||||
extF80M_le$(OBJ) \
|
||||
extF80M_lt$(OBJ) \
|
||||
extF80M_eq_signaling$(OBJ) \
|
||||
extF80M_le_quiet$(OBJ) \
|
||||
extF80M_lt_quiet$(OBJ) \
|
||||
f128M_to_ui32$(OBJ) \
|
||||
f128M_to_ui64$(OBJ) \
|
||||
f128M_to_i32$(OBJ) \
|
||||
f128M_to_i64$(OBJ) \
|
||||
f128M_to_ui32_r_minMag$(OBJ) \
|
||||
f128M_to_ui64_r_minMag$(OBJ) \
|
||||
f128M_to_i32_r_minMag$(OBJ) \
|
||||
f128M_to_i64_r_minMag$(OBJ) \
|
||||
f128M_to_f16$(OBJ) \
|
||||
f128M_to_f32$(OBJ) \
|
||||
f128M_to_f64$(OBJ) \
|
||||
f128M_to_extF80M$(OBJ) \
|
||||
f128M_roundToInt$(OBJ) \
|
||||
f128M_add$(OBJ) \
|
||||
f128M_sub$(OBJ) \
|
||||
f128M_mul$(OBJ) \
|
||||
f128M_mulAdd$(OBJ) \
|
||||
f128M_div$(OBJ) \
|
||||
f128M_rem$(OBJ) \
|
||||
f128M_sqrt$(OBJ) \
|
||||
f128M_eq$(OBJ) \
|
||||
f128M_le$(OBJ) \
|
||||
f128M_lt$(OBJ) \
|
||||
f128M_eq_signaling$(OBJ) \
|
||||
f128M_le_quiet$(OBJ) \
|
||||
f128M_lt_quiet$(OBJ) \
|
||||
|
||||
OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS)
|
||||
|
||||
$(OBJS_ALL): \
|
||||
$(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \
|
||||
$(SOURCE_DIR)/include/primitives.h
|
||||
$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \
|
||||
$(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \
|
||||
$(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \
|
||||
$(SOURCE_DIR)/include/softfloat.h
|
||||
|
||||
$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c
|
||||
$(COMPILE_C) $(SOURCE_DIR)/$*.c
|
||||
|
||||
$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c
|
||||
$(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c
|
||||
|
||||
softfloat$(LIB): $(OBJS_ALL)
|
||||
$(DELETE) $@
|
||||
$(MAKELIB) $^
|
||||
|
||||
.PHONY: clean
|
||||
clean:
|
||||
$(DELETE) $(OBJS_ALL) softfloat$(LIB)
|
||||
|
||||
|
@ -1,52 +1,53 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
|
||||
University of California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define LITTLEENDIAN 1
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#ifdef __GNUC_STDC_INLINE__
|
||||
#define INLINE inline
|
||||
#else
|
||||
#define INLINE extern inline
|
||||
#endif
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define SOFTFLOAT_BUILTIN_CLZ 1
|
||||
#include "opts-GCC.h"
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
|
||||
University of California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define LITTLEENDIAN 1
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#ifdef __GNUC_STDC_INLINE__
|
||||
#define INLINE inline
|
||||
#else
|
||||
#define INLINE extern inline
|
||||
#endif
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define SOFTFLOAT_BUILTIN_CLZ 1
|
||||
#include "opts-GCC.h"
|
||||
|
||||
|
@ -1,325 +1,325 @@
|
||||
|
||||
#=============================================================================
|
||||
#
|
||||
# This Makefile is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
# Package, Release 3e, by John R. Hauser.
|
||||
#
|
||||
# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
|
||||
# University of California. All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions are met:
|
||||
#
|
||||
# 1. Redistributions of source code must retain the above copyright notice,
|
||||
# this list of conditions, and the following disclaimer.
|
||||
#
|
||||
# 2. Redistributions in binary form must reproduce the above copyright
|
||||
# notice, this list of conditions, and the following disclaimer in the
|
||||
# documentation and/or other materials provided with the distribution.
|
||||
#
|
||||
# 3. Neither the name of the University nor the names of its contributors
|
||||
# may be used to endorse or promote products derived from this software
|
||||
# without specific prior written permission.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
# DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
#
|
||||
#=============================================================================
|
||||
|
||||
SOURCE_DIR ?= ../../source
|
||||
SPECIALIZE_TYPE ?= 8086-SSE
|
||||
|
||||
SOFTFLOAT_OPTS ?= \
|
||||
-DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \
|
||||
-DSOFTFLOAT_FAST_DIV64TO32
|
||||
|
||||
DELETE = rm -f
|
||||
C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include
|
||||
COMPILE_C = \
|
||||
gcc -c -Werror-implicit-function-declaration $(SOFTFLOAT_OPTS) \
|
||||
$(C_INCLUDES) -O2 -o $@
|
||||
MAKELIB = ar crs $@
|
||||
|
||||
OBJ = .o
|
||||
LIB = .a
|
||||
|
||||
OTHER_HEADERS =
|
||||
|
||||
.PHONY: all
|
||||
all: softfloat$(LIB)
|
||||
|
||||
OBJS_PRIMITIVES = \
|
||||
s_compare96M$(OBJ) \
|
||||
s_compare128M$(OBJ) \
|
||||
s_shortShiftLeft64To96M$(OBJ) \
|
||||
s_shortShiftLeftM$(OBJ) \
|
||||
s_shiftLeftM$(OBJ) \
|
||||
s_shortShiftRightM$(OBJ) \
|
||||
s_shortShiftRightJam64$(OBJ) \
|
||||
s_shortShiftRightJamM$(OBJ) \
|
||||
s_shiftRightJam32$(OBJ) \
|
||||
s_shiftRightJam64$(OBJ) \
|
||||
s_shiftRightJamM$(OBJ) \
|
||||
s_shiftRightM$(OBJ) \
|
||||
s_countLeadingZeros8$(OBJ) \
|
||||
s_countLeadingZeros16$(OBJ) \
|
||||
s_countLeadingZeros32$(OBJ) \
|
||||
s_countLeadingZeros64$(OBJ) \
|
||||
s_addM$(OBJ) \
|
||||
s_addCarryM$(OBJ) \
|
||||
s_addComplCarryM$(OBJ) \
|
||||
s_negXM$(OBJ) \
|
||||
s_sub1XM$(OBJ) \
|
||||
s_subM$(OBJ) \
|
||||
s_mul64To128M$(OBJ) \
|
||||
s_mul128MTo256M$(OBJ) \
|
||||
s_approxRecip_1Ks$(OBJ) \
|
||||
s_approxRecip32_1$(OBJ) \
|
||||
s_approxRecipSqrt_1Ks$(OBJ) \
|
||||
s_approxRecipSqrt32_1$(OBJ) \
|
||||
s_remStepMBy32$(OBJ) \
|
||||
|
||||
OBJS_SPECIALIZE = \
|
||||
softfloat_raiseFlags$(OBJ) \
|
||||
s_f16UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF16UI$(OBJ) \
|
||||
s_propagateNaNF16UI$(OBJ) \
|
||||
s_f32UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF32UI$(OBJ) \
|
||||
s_propagateNaNF32UI$(OBJ) \
|
||||
s_f64UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF64UI$(OBJ) \
|
||||
s_propagateNaNF64UI$(OBJ) \
|
||||
extF80M_isSignalingNaN$(OBJ) \
|
||||
s_extF80MToCommonNaN$(OBJ) \
|
||||
s_commonNaNToExtF80M$(OBJ) \
|
||||
s_propagateNaNExtF80M$(OBJ) \
|
||||
f128M_isSignalingNaN$(OBJ) \
|
||||
s_f128MToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF128M$(OBJ) \
|
||||
s_propagateNaNF128M$(OBJ) \
|
||||
|
||||
OBJS_OTHERS = \
|
||||
s_roundToUI32$(OBJ) \
|
||||
s_roundMToUI64$(OBJ) \
|
||||
s_roundToI32$(OBJ) \
|
||||
s_roundMToI64$(OBJ) \
|
||||
s_normSubnormalF16Sig$(OBJ) \
|
||||
s_roundPackToF16$(OBJ) \
|
||||
s_normRoundPackToF16$(OBJ) \
|
||||
s_addMagsF16$(OBJ) \
|
||||
s_subMagsF16$(OBJ) \
|
||||
s_mulAddF16$(OBJ) \
|
||||
s_normSubnormalF32Sig$(OBJ) \
|
||||
s_roundPackToF32$(OBJ) \
|
||||
s_normRoundPackToF32$(OBJ) \
|
||||
s_addMagsF32$(OBJ) \
|
||||
s_subMagsF32$(OBJ) \
|
||||
s_mulAddF32$(OBJ) \
|
||||
s_normSubnormalF64Sig$(OBJ) \
|
||||
s_roundPackToF64$(OBJ) \
|
||||
s_normRoundPackToF64$(OBJ) \
|
||||
s_addMagsF64$(OBJ) \
|
||||
s_subMagsF64$(OBJ) \
|
||||
s_mulAddF64$(OBJ) \
|
||||
s_tryPropagateNaNExtF80M$(OBJ) \
|
||||
s_invalidExtF80M$(OBJ) \
|
||||
s_normExtF80SigM$(OBJ) \
|
||||
s_roundPackMToExtF80M$(OBJ) \
|
||||
s_normRoundPackMToExtF80M$(OBJ) \
|
||||
s_addExtF80M$(OBJ) \
|
||||
s_compareNonnormExtF80M$(OBJ) \
|
||||
s_isNaNF128M$(OBJ) \
|
||||
s_tryPropagateNaNF128M$(OBJ) \
|
||||
s_invalidF128M$(OBJ) \
|
||||
s_shiftNormSigF128M$(OBJ) \
|
||||
s_roundPackMToF128M$(OBJ) \
|
||||
s_normRoundPackMToF128M$(OBJ) \
|
||||
s_addF128M$(OBJ) \
|
||||
s_mulAddF128M$(OBJ) \
|
||||
softfloat_state$(OBJ) \
|
||||
ui32_to_f16$(OBJ) \
|
||||
ui32_to_f32$(OBJ) \
|
||||
ui32_to_f64$(OBJ) \
|
||||
ui32_to_extF80M$(OBJ) \
|
||||
ui32_to_f128M$(OBJ) \
|
||||
ui64_to_f16$(OBJ) \
|
||||
ui64_to_f32$(OBJ) \
|
||||
ui64_to_f64$(OBJ) \
|
||||
ui64_to_extF80M$(OBJ) \
|
||||
ui64_to_f128M$(OBJ) \
|
||||
i32_to_f16$(OBJ) \
|
||||
i32_to_f32$(OBJ) \
|
||||
i32_to_f64$(OBJ) \
|
||||
i32_to_extF80M$(OBJ) \
|
||||
i32_to_f128M$(OBJ) \
|
||||
i64_to_f16$(OBJ) \
|
||||
i64_to_f32$(OBJ) \
|
||||
i64_to_f64$(OBJ) \
|
||||
i64_to_extF80M$(OBJ) \
|
||||
i64_to_f128M$(OBJ) \
|
||||
f16_to_ui32$(OBJ) \
|
||||
f16_to_ui64$(OBJ) \
|
||||
f16_to_i32$(OBJ) \
|
||||
f16_to_i64$(OBJ) \
|
||||
f16_to_ui32_r_minMag$(OBJ) \
|
||||
f16_to_ui64_r_minMag$(OBJ) \
|
||||
f16_to_i32_r_minMag$(OBJ) \
|
||||
f16_to_i64_r_minMag$(OBJ) \
|
||||
f16_to_f32$(OBJ) \
|
||||
f16_to_f64$(OBJ) \
|
||||
f16_to_extF80M$(OBJ) \
|
||||
f16_to_f128M$(OBJ) \
|
||||
f16_roundToInt$(OBJ) \
|
||||
f16_add$(OBJ) \
|
||||
f16_sub$(OBJ) \
|
||||
f16_mul$(OBJ) \
|
||||
f16_mulAdd$(OBJ) \
|
||||
f16_div$(OBJ) \
|
||||
f16_rem$(OBJ) \
|
||||
f16_sqrt$(OBJ) \
|
||||
f16_eq$(OBJ) \
|
||||
f16_le$(OBJ) \
|
||||
f16_lt$(OBJ) \
|
||||
f16_eq_signaling$(OBJ) \
|
||||
f16_le_quiet$(OBJ) \
|
||||
f16_lt_quiet$(OBJ) \
|
||||
f16_isSignalingNaN$(OBJ) \
|
||||
f32_to_ui32$(OBJ) \
|
||||
f32_to_ui64$(OBJ) \
|
||||
f32_to_i32$(OBJ) \
|
||||
f32_to_i64$(OBJ) \
|
||||
f32_to_ui32_r_minMag$(OBJ) \
|
||||
f32_to_ui64_r_minMag$(OBJ) \
|
||||
f32_to_i32_r_minMag$(OBJ) \
|
||||
f32_to_i64_r_minMag$(OBJ) \
|
||||
f32_to_f16$(OBJ) \
|
||||
f32_to_f64$(OBJ) \
|
||||
f32_to_extF80M$(OBJ) \
|
||||
f32_to_f128M$(OBJ) \
|
||||
f32_roundToInt$(OBJ) \
|
||||
f32_add$(OBJ) \
|
||||
f32_sub$(OBJ) \
|
||||
f32_mul$(OBJ) \
|
||||
f32_mulAdd$(OBJ) \
|
||||
f32_div$(OBJ) \
|
||||
f32_rem$(OBJ) \
|
||||
f32_sqrt$(OBJ) \
|
||||
f32_eq$(OBJ) \
|
||||
f32_le$(OBJ) \
|
||||
f32_lt$(OBJ) \
|
||||
f32_eq_signaling$(OBJ) \
|
||||
f32_le_quiet$(OBJ) \
|
||||
f32_lt_quiet$(OBJ) \
|
||||
f32_isSignalingNaN$(OBJ) \
|
||||
f64_to_ui32$(OBJ) \
|
||||
f64_to_ui64$(OBJ) \
|
||||
f64_to_i32$(OBJ) \
|
||||
f64_to_i64$(OBJ) \
|
||||
f64_to_ui32_r_minMag$(OBJ) \
|
||||
f64_to_ui64_r_minMag$(OBJ) \
|
||||
f64_to_i32_r_minMag$(OBJ) \
|
||||
f64_to_i64_r_minMag$(OBJ) \
|
||||
f64_to_f16$(OBJ) \
|
||||
f64_to_f32$(OBJ) \
|
||||
f64_to_extF80M$(OBJ) \
|
||||
f64_to_f128M$(OBJ) \
|
||||
f64_roundToInt$(OBJ) \
|
||||
f64_add$(OBJ) \
|
||||
f64_sub$(OBJ) \
|
||||
f64_mul$(OBJ) \
|
||||
f64_mulAdd$(OBJ) \
|
||||
f64_div$(OBJ) \
|
||||
f64_rem$(OBJ) \
|
||||
f64_sqrt$(OBJ) \
|
||||
f64_eq$(OBJ) \
|
||||
f64_le$(OBJ) \
|
||||
f64_lt$(OBJ) \
|
||||
f64_eq_signaling$(OBJ) \
|
||||
f64_le_quiet$(OBJ) \
|
||||
f64_lt_quiet$(OBJ) \
|
||||
f64_isSignalingNaN$(OBJ) \
|
||||
extF80M_to_ui32$(OBJ) \
|
||||
extF80M_to_ui64$(OBJ) \
|
||||
extF80M_to_i32$(OBJ) \
|
||||
extF80M_to_i64$(OBJ) \
|
||||
extF80M_to_ui32_r_minMag$(OBJ) \
|
||||
extF80M_to_ui64_r_minMag$(OBJ) \
|
||||
extF80M_to_i32_r_minMag$(OBJ) \
|
||||
extF80M_to_i64_r_minMag$(OBJ) \
|
||||
extF80M_to_f16$(OBJ) \
|
||||
extF80M_to_f32$(OBJ) \
|
||||
extF80M_to_f64$(OBJ) \
|
||||
extF80M_to_f128M$(OBJ) \
|
||||
extF80M_roundToInt$(OBJ) \
|
||||
extF80M_add$(OBJ) \
|
||||
extF80M_sub$(OBJ) \
|
||||
extF80M_mul$(OBJ) \
|
||||
extF80M_div$(OBJ) \
|
||||
extF80M_rem$(OBJ) \
|
||||
extF80M_sqrt$(OBJ) \
|
||||
extF80M_eq$(OBJ) \
|
||||
extF80M_le$(OBJ) \
|
||||
extF80M_lt$(OBJ) \
|
||||
extF80M_eq_signaling$(OBJ) \
|
||||
extF80M_le_quiet$(OBJ) \
|
||||
extF80M_lt_quiet$(OBJ) \
|
||||
f128M_to_ui32$(OBJ) \
|
||||
f128M_to_ui64$(OBJ) \
|
||||
f128M_to_i32$(OBJ) \
|
||||
f128M_to_i64$(OBJ) \
|
||||
f128M_to_ui32_r_minMag$(OBJ) \
|
||||
f128M_to_ui64_r_minMag$(OBJ) \
|
||||
f128M_to_i32_r_minMag$(OBJ) \
|
||||
f128M_to_i64_r_minMag$(OBJ) \
|
||||
f128M_to_f16$(OBJ) \
|
||||
f128M_to_f32$(OBJ) \
|
||||
f128M_to_f64$(OBJ) \
|
||||
f128M_to_extF80M$(OBJ) \
|
||||
f128M_roundToInt$(OBJ) \
|
||||
f128M_add$(OBJ) \
|
||||
f128M_sub$(OBJ) \
|
||||
f128M_mul$(OBJ) \
|
||||
f128M_mulAdd$(OBJ) \
|
||||
f128M_div$(OBJ) \
|
||||
f128M_rem$(OBJ) \
|
||||
f128M_sqrt$(OBJ) \
|
||||
f128M_eq$(OBJ) \
|
||||
f128M_le$(OBJ) \
|
||||
f128M_lt$(OBJ) \
|
||||
f128M_eq_signaling$(OBJ) \
|
||||
f128M_le_quiet$(OBJ) \
|
||||
f128M_lt_quiet$(OBJ) \
|
||||
|
||||
OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS)
|
||||
|
||||
$(OBJS_ALL): \
|
||||
$(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \
|
||||
$(SOURCE_DIR)/include/primitives.h
|
||||
$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \
|
||||
$(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \
|
||||
$(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \
|
||||
$(SOURCE_DIR)/include/softfloat.h
|
||||
|
||||
$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c
|
||||
$(COMPILE_C) $(SOURCE_DIR)/$*.c
|
||||
|
||||
$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c
|
||||
$(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c
|
||||
|
||||
softfloat$(LIB): $(OBJS_ALL)
|
||||
$(DELETE) $@
|
||||
$(MAKELIB) $^
|
||||
|
||||
.PHONY: clean
|
||||
clean:
|
||||
$(DELETE) $(OBJS_ALL) softfloat$(LIB)
|
||||
|
||||
|
||||
#=============================================================================
|
||||
#
|
||||
# This Makefile is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
# Package, Release 3e, by John R. Hauser.
|
||||
#
|
||||
# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
|
||||
# University of California. All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions are met:
|
||||
#
|
||||
# 1. Redistributions of source code must retain the above copyright notice,
|
||||
# this list of conditions, and the following disclaimer.
|
||||
#
|
||||
# 2. Redistributions in binary form must reproduce the above copyright
|
||||
# notice, this list of conditions, and the following disclaimer in the
|
||||
# documentation and/or other materials provided with the distribution.
|
||||
#
|
||||
# 3. Neither the name of the University nor the names of its contributors
|
||||
# may be used to endorse or promote products derived from this software
|
||||
# without specific prior written permission.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
# DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
#
|
||||
#=============================================================================
|
||||
|
||||
SOURCE_DIR ?= ../../source
|
||||
SPECIALIZE_TYPE ?= 8086-SSE
|
||||
|
||||
SOFTFLOAT_OPTS ?= \
|
||||
-DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \
|
||||
-DSOFTFLOAT_FAST_DIV64TO32
|
||||
|
||||
DELETE = rm -f
|
||||
C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include
|
||||
COMPILE_C = \
|
||||
gcc -c -Werror-implicit-function-declaration $(SOFTFLOAT_OPTS) \
|
||||
$(C_INCLUDES) -O2 -o $@
|
||||
MAKELIB = ar crs $@
|
||||
|
||||
OBJ = .o
|
||||
LIB = .a
|
||||
|
||||
OTHER_HEADERS =
|
||||
|
||||
.PHONY: all
|
||||
all: softfloat$(LIB)
|
||||
|
||||
OBJS_PRIMITIVES = \
|
||||
s_compare96M$(OBJ) \
|
||||
s_compare128M$(OBJ) \
|
||||
s_shortShiftLeft64To96M$(OBJ) \
|
||||
s_shortShiftLeftM$(OBJ) \
|
||||
s_shiftLeftM$(OBJ) \
|
||||
s_shortShiftRightM$(OBJ) \
|
||||
s_shortShiftRightJam64$(OBJ) \
|
||||
s_shortShiftRightJamM$(OBJ) \
|
||||
s_shiftRightJam32$(OBJ) \
|
||||
s_shiftRightJam64$(OBJ) \
|
||||
s_shiftRightJamM$(OBJ) \
|
||||
s_shiftRightM$(OBJ) \
|
||||
s_countLeadingZeros8$(OBJ) \
|
||||
s_countLeadingZeros16$(OBJ) \
|
||||
s_countLeadingZeros32$(OBJ) \
|
||||
s_countLeadingZeros64$(OBJ) \
|
||||
s_addM$(OBJ) \
|
||||
s_addCarryM$(OBJ) \
|
||||
s_addComplCarryM$(OBJ) \
|
||||
s_negXM$(OBJ) \
|
||||
s_sub1XM$(OBJ) \
|
||||
s_subM$(OBJ) \
|
||||
s_mul64To128M$(OBJ) \
|
||||
s_mul128MTo256M$(OBJ) \
|
||||
s_approxRecip_1Ks$(OBJ) \
|
||||
s_approxRecip32_1$(OBJ) \
|
||||
s_approxRecipSqrt_1Ks$(OBJ) \
|
||||
s_approxRecipSqrt32_1$(OBJ) \
|
||||
s_remStepMBy32$(OBJ) \
|
||||
|
||||
OBJS_SPECIALIZE = \
|
||||
softfloat_raiseFlags$(OBJ) \
|
||||
s_f16UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF16UI$(OBJ) \
|
||||
s_propagateNaNF16UI$(OBJ) \
|
||||
s_f32UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF32UI$(OBJ) \
|
||||
s_propagateNaNF32UI$(OBJ) \
|
||||
s_f64UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF64UI$(OBJ) \
|
||||
s_propagateNaNF64UI$(OBJ) \
|
||||
extF80M_isSignalingNaN$(OBJ) \
|
||||
s_extF80MToCommonNaN$(OBJ) \
|
||||
s_commonNaNToExtF80M$(OBJ) \
|
||||
s_propagateNaNExtF80M$(OBJ) \
|
||||
f128M_isSignalingNaN$(OBJ) \
|
||||
s_f128MToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF128M$(OBJ) \
|
||||
s_propagateNaNF128M$(OBJ) \
|
||||
|
||||
OBJS_OTHERS = \
|
||||
s_roundToUI32$(OBJ) \
|
||||
s_roundMToUI64$(OBJ) \
|
||||
s_roundToI32$(OBJ) \
|
||||
s_roundMToI64$(OBJ) \
|
||||
s_normSubnormalF16Sig$(OBJ) \
|
||||
s_roundPackToF16$(OBJ) \
|
||||
s_normRoundPackToF16$(OBJ) \
|
||||
s_addMagsF16$(OBJ) \
|
||||
s_subMagsF16$(OBJ) \
|
||||
s_mulAddF16$(OBJ) \
|
||||
s_normSubnormalF32Sig$(OBJ) \
|
||||
s_roundPackToF32$(OBJ) \
|
||||
s_normRoundPackToF32$(OBJ) \
|
||||
s_addMagsF32$(OBJ) \
|
||||
s_subMagsF32$(OBJ) \
|
||||
s_mulAddF32$(OBJ) \
|
||||
s_normSubnormalF64Sig$(OBJ) \
|
||||
s_roundPackToF64$(OBJ) \
|
||||
s_normRoundPackToF64$(OBJ) \
|
||||
s_addMagsF64$(OBJ) \
|
||||
s_subMagsF64$(OBJ) \
|
||||
s_mulAddF64$(OBJ) \
|
||||
s_tryPropagateNaNExtF80M$(OBJ) \
|
||||
s_invalidExtF80M$(OBJ) \
|
||||
s_normExtF80SigM$(OBJ) \
|
||||
s_roundPackMToExtF80M$(OBJ) \
|
||||
s_normRoundPackMToExtF80M$(OBJ) \
|
||||
s_addExtF80M$(OBJ) \
|
||||
s_compareNonnormExtF80M$(OBJ) \
|
||||
s_isNaNF128M$(OBJ) \
|
||||
s_tryPropagateNaNF128M$(OBJ) \
|
||||
s_invalidF128M$(OBJ) \
|
||||
s_shiftNormSigF128M$(OBJ) \
|
||||
s_roundPackMToF128M$(OBJ) \
|
||||
s_normRoundPackMToF128M$(OBJ) \
|
||||
s_addF128M$(OBJ) \
|
||||
s_mulAddF128M$(OBJ) \
|
||||
softfloat_state$(OBJ) \
|
||||
ui32_to_f16$(OBJ) \
|
||||
ui32_to_f32$(OBJ) \
|
||||
ui32_to_f64$(OBJ) \
|
||||
ui32_to_extF80M$(OBJ) \
|
||||
ui32_to_f128M$(OBJ) \
|
||||
ui64_to_f16$(OBJ) \
|
||||
ui64_to_f32$(OBJ) \
|
||||
ui64_to_f64$(OBJ) \
|
||||
ui64_to_extF80M$(OBJ) \
|
||||
ui64_to_f128M$(OBJ) \
|
||||
i32_to_f16$(OBJ) \
|
||||
i32_to_f32$(OBJ) \
|
||||
i32_to_f64$(OBJ) \
|
||||
i32_to_extF80M$(OBJ) \
|
||||
i32_to_f128M$(OBJ) \
|
||||
i64_to_f16$(OBJ) \
|
||||
i64_to_f32$(OBJ) \
|
||||
i64_to_f64$(OBJ) \
|
||||
i64_to_extF80M$(OBJ) \
|
||||
i64_to_f128M$(OBJ) \
|
||||
f16_to_ui32$(OBJ) \
|
||||
f16_to_ui64$(OBJ) \
|
||||
f16_to_i32$(OBJ) \
|
||||
f16_to_i64$(OBJ) \
|
||||
f16_to_ui32_r_minMag$(OBJ) \
|
||||
f16_to_ui64_r_minMag$(OBJ) \
|
||||
f16_to_i32_r_minMag$(OBJ) \
|
||||
f16_to_i64_r_minMag$(OBJ) \
|
||||
f16_to_f32$(OBJ) \
|
||||
f16_to_f64$(OBJ) \
|
||||
f16_to_extF80M$(OBJ) \
|
||||
f16_to_f128M$(OBJ) \
|
||||
f16_roundToInt$(OBJ) \
|
||||
f16_add$(OBJ) \
|
||||
f16_sub$(OBJ) \
|
||||
f16_mul$(OBJ) \
|
||||
f16_mulAdd$(OBJ) \
|
||||
f16_div$(OBJ) \
|
||||
f16_rem$(OBJ) \
|
||||
f16_sqrt$(OBJ) \
|
||||
f16_eq$(OBJ) \
|
||||
f16_le$(OBJ) \
|
||||
f16_lt$(OBJ) \
|
||||
f16_eq_signaling$(OBJ) \
|
||||
f16_le_quiet$(OBJ) \
|
||||
f16_lt_quiet$(OBJ) \
|
||||
f16_isSignalingNaN$(OBJ) \
|
||||
f32_to_ui32$(OBJ) \
|
||||
f32_to_ui64$(OBJ) \
|
||||
f32_to_i32$(OBJ) \
|
||||
f32_to_i64$(OBJ) \
|
||||
f32_to_ui32_r_minMag$(OBJ) \
|
||||
f32_to_ui64_r_minMag$(OBJ) \
|
||||
f32_to_i32_r_minMag$(OBJ) \
|
||||
f32_to_i64_r_minMag$(OBJ) \
|
||||
f32_to_f16$(OBJ) \
|
||||
f32_to_f64$(OBJ) \
|
||||
f32_to_extF80M$(OBJ) \
|
||||
f32_to_f128M$(OBJ) \
|
||||
f32_roundToInt$(OBJ) \
|
||||
f32_add$(OBJ) \
|
||||
f32_sub$(OBJ) \
|
||||
f32_mul$(OBJ) \
|
||||
f32_mulAdd$(OBJ) \
|
||||
f32_div$(OBJ) \
|
||||
f32_rem$(OBJ) \
|
||||
f32_sqrt$(OBJ) \
|
||||
f32_eq$(OBJ) \
|
||||
f32_le$(OBJ) \
|
||||
f32_lt$(OBJ) \
|
||||
f32_eq_signaling$(OBJ) \
|
||||
f32_le_quiet$(OBJ) \
|
||||
f32_lt_quiet$(OBJ) \
|
||||
f32_isSignalingNaN$(OBJ) \
|
||||
f64_to_ui32$(OBJ) \
|
||||
f64_to_ui64$(OBJ) \
|
||||
f64_to_i32$(OBJ) \
|
||||
f64_to_i64$(OBJ) \
|
||||
f64_to_ui32_r_minMag$(OBJ) \
|
||||
f64_to_ui64_r_minMag$(OBJ) \
|
||||
f64_to_i32_r_minMag$(OBJ) \
|
||||
f64_to_i64_r_minMag$(OBJ) \
|
||||
f64_to_f16$(OBJ) \
|
||||
f64_to_f32$(OBJ) \
|
||||
f64_to_extF80M$(OBJ) \
|
||||
f64_to_f128M$(OBJ) \
|
||||
f64_roundToInt$(OBJ) \
|
||||
f64_add$(OBJ) \
|
||||
f64_sub$(OBJ) \
|
||||
f64_mul$(OBJ) \
|
||||
f64_mulAdd$(OBJ) \
|
||||
f64_div$(OBJ) \
|
||||
f64_rem$(OBJ) \
|
||||
f64_sqrt$(OBJ) \
|
||||
f64_eq$(OBJ) \
|
||||
f64_le$(OBJ) \
|
||||
f64_lt$(OBJ) \
|
||||
f64_eq_signaling$(OBJ) \
|
||||
f64_le_quiet$(OBJ) \
|
||||
f64_lt_quiet$(OBJ) \
|
||||
f64_isSignalingNaN$(OBJ) \
|
||||
extF80M_to_ui32$(OBJ) \
|
||||
extF80M_to_ui64$(OBJ) \
|
||||
extF80M_to_i32$(OBJ) \
|
||||
extF80M_to_i64$(OBJ) \
|
||||
extF80M_to_ui32_r_minMag$(OBJ) \
|
||||
extF80M_to_ui64_r_minMag$(OBJ) \
|
||||
extF80M_to_i32_r_minMag$(OBJ) \
|
||||
extF80M_to_i64_r_minMag$(OBJ) \
|
||||
extF80M_to_f16$(OBJ) \
|
||||
extF80M_to_f32$(OBJ) \
|
||||
extF80M_to_f64$(OBJ) \
|
||||
extF80M_to_f128M$(OBJ) \
|
||||
extF80M_roundToInt$(OBJ) \
|
||||
extF80M_add$(OBJ) \
|
||||
extF80M_sub$(OBJ) \
|
||||
extF80M_mul$(OBJ) \
|
||||
extF80M_div$(OBJ) \
|
||||
extF80M_rem$(OBJ) \
|
||||
extF80M_sqrt$(OBJ) \
|
||||
extF80M_eq$(OBJ) \
|
||||
extF80M_le$(OBJ) \
|
||||
extF80M_lt$(OBJ) \
|
||||
extF80M_eq_signaling$(OBJ) \
|
||||
extF80M_le_quiet$(OBJ) \
|
||||
extF80M_lt_quiet$(OBJ) \
|
||||
f128M_to_ui32$(OBJ) \
|
||||
f128M_to_ui64$(OBJ) \
|
||||
f128M_to_i32$(OBJ) \
|
||||
f128M_to_i64$(OBJ) \
|
||||
f128M_to_ui32_r_minMag$(OBJ) \
|
||||
f128M_to_ui64_r_minMag$(OBJ) \
|
||||
f128M_to_i32_r_minMag$(OBJ) \
|
||||
f128M_to_i64_r_minMag$(OBJ) \
|
||||
f128M_to_f16$(OBJ) \
|
||||
f128M_to_f32$(OBJ) \
|
||||
f128M_to_f64$(OBJ) \
|
||||
f128M_to_extF80M$(OBJ) \
|
||||
f128M_roundToInt$(OBJ) \
|
||||
f128M_add$(OBJ) \
|
||||
f128M_sub$(OBJ) \
|
||||
f128M_mul$(OBJ) \
|
||||
f128M_mulAdd$(OBJ) \
|
||||
f128M_div$(OBJ) \
|
||||
f128M_rem$(OBJ) \
|
||||
f128M_sqrt$(OBJ) \
|
||||
f128M_eq$(OBJ) \
|
||||
f128M_le$(OBJ) \
|
||||
f128M_lt$(OBJ) \
|
||||
f128M_eq_signaling$(OBJ) \
|
||||
f128M_le_quiet$(OBJ) \
|
||||
f128M_lt_quiet$(OBJ) \
|
||||
|
||||
OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS)
|
||||
|
||||
$(OBJS_ALL): \
|
||||
$(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \
|
||||
$(SOURCE_DIR)/include/primitives.h
|
||||
$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \
|
||||
$(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \
|
||||
$(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \
|
||||
$(SOURCE_DIR)/include/softfloat.h
|
||||
|
||||
$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c
|
||||
$(COMPILE_C) $(SOURCE_DIR)/$*.c
|
||||
|
||||
$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c
|
||||
$(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c
|
||||
|
||||
softfloat$(LIB): $(OBJS_ALL)
|
||||
$(DELETE) $@
|
||||
$(MAKELIB) $^
|
||||
|
||||
.PHONY: clean
|
||||
clean:
|
||||
$(DELETE) $(OBJS_ALL) softfloat$(LIB)
|
||||
|
||||
|
@ -1,52 +1,53 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
|
||||
University of California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define LITTLEENDIAN 1
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#ifdef __GNUC_STDC_INLINE__
|
||||
#define INLINE inline
|
||||
#else
|
||||
#define INLINE extern inline
|
||||
#endif
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define SOFTFLOAT_BUILTIN_CLZ 1
|
||||
#include "opts-GCC.h"
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
|
||||
University of California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define LITTLEENDIAN 1
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#ifdef __GNUC_STDC_INLINE__
|
||||
#define INLINE inline
|
||||
#else
|
||||
#define INLINE extern inline
|
||||
#endif
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define SOFTFLOAT_BUILTIN_CLZ 1
|
||||
#include "opts-GCC.h"
|
||||
|
||||
|
@ -1,390 +1,390 @@
|
||||
|
||||
#=============================================================================
|
||||
#
|
||||
# This Makefile is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
# Package, Release 3e, by John R. Hauser.
|
||||
#
|
||||
# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
|
||||
# University of California. All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions are met:
|
||||
#
|
||||
# 1. Redistributions of source code must retain the above copyright notice,
|
||||
# this list of conditions, and the following disclaimer.
|
||||
#
|
||||
# 2. Redistributions in binary form must reproduce the above copyright
|
||||
# notice, this list of conditions, and the following disclaimer in the
|
||||
# documentation and/or other materials provided with the distribution.
|
||||
#
|
||||
# 3. Neither the name of the University nor the names of its contributors
|
||||
# may be used to endorse or promote products derived from this software
|
||||
# without specific prior written permission.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
# DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
#
|
||||
#=============================================================================
|
||||
|
||||
SOURCE_DIR ?= ../../source
|
||||
SPECIALIZE_TYPE ?= 8086-SSE
|
||||
|
||||
SOFTFLOAT_OPTS ?= \
|
||||
-DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \
|
||||
-DSOFTFLOAT_FAST_DIV64TO32
|
||||
|
||||
DELETE = rm -f
|
||||
C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include
|
||||
COMPILE_C = \
|
||||
x86_64-w64-mingw32-gcc -c -Werror-implicit-function-declaration \
|
||||
-DSOFTFLOAT_FAST_INT64 $(SOFTFLOAT_OPTS) $(C_INCLUDES) -O2 -o $@
|
||||
MAKELIB = x86_64-w64-mingw32-ar crs $@
|
||||
|
||||
OBJ = .o
|
||||
LIB = .a
|
||||
|
||||
OTHER_HEADERS = $(SOURCE_DIR)/include/opts-GCC.h
|
||||
|
||||
.PHONY: all
|
||||
all: softfloat$(LIB)
|
||||
|
||||
OBJS_PRIMITIVES = \
|
||||
s_eq128$(OBJ) \
|
||||
s_le128$(OBJ) \
|
||||
s_lt128$(OBJ) \
|
||||
s_shortShiftLeft128$(OBJ) \
|
||||
s_shortShiftRight128$(OBJ) \
|
||||
s_shortShiftRightJam64$(OBJ) \
|
||||
s_shortShiftRightJam64Extra$(OBJ) \
|
||||
s_shortShiftRightJam128$(OBJ) \
|
||||
s_shortShiftRightJam128Extra$(OBJ) \
|
||||
s_shiftRightJam32$(OBJ) \
|
||||
s_shiftRightJam64$(OBJ) \
|
||||
s_shiftRightJam64Extra$(OBJ) \
|
||||
s_shiftRightJam128$(OBJ) \
|
||||
s_shiftRightJam128Extra$(OBJ) \
|
||||
s_shiftRightJam256M$(OBJ) \
|
||||
s_countLeadingZeros8$(OBJ) \
|
||||
s_countLeadingZeros16$(OBJ) \
|
||||
s_countLeadingZeros32$(OBJ) \
|
||||
s_countLeadingZeros64$(OBJ) \
|
||||
s_add128$(OBJ) \
|
||||
s_add256M$(OBJ) \
|
||||
s_sub128$(OBJ) \
|
||||
s_sub256M$(OBJ) \
|
||||
s_mul64ByShifted32To128$(OBJ) \
|
||||
s_mul64To128$(OBJ) \
|
||||
s_mul128By32$(OBJ) \
|
||||
s_mul128To256M$(OBJ) \
|
||||
s_approxRecip_1Ks$(OBJ) \
|
||||
s_approxRecip32_1$(OBJ) \
|
||||
s_approxRecipSqrt_1Ks$(OBJ) \
|
||||
s_approxRecipSqrt32_1$(OBJ) \
|
||||
|
||||
OBJS_SPECIALIZE = \
|
||||
softfloat_raiseFlags$(OBJ) \
|
||||
s_f16UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF16UI$(OBJ) \
|
||||
s_propagateNaNF16UI$(OBJ) \
|
||||
s_f32UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF32UI$(OBJ) \
|
||||
s_propagateNaNF32UI$(OBJ) \
|
||||
s_f64UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF64UI$(OBJ) \
|
||||
s_propagateNaNF64UI$(OBJ) \
|
||||
extF80M_isSignalingNaN$(OBJ) \
|
||||
s_extF80UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToExtF80UI$(OBJ) \
|
||||
s_propagateNaNExtF80UI$(OBJ) \
|
||||
f128M_isSignalingNaN$(OBJ) \
|
||||
s_f128UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF128UI$(OBJ) \
|
||||
s_propagateNaNF128UI$(OBJ) \
|
||||
|
||||
OBJS_OTHERS = \
|
||||
s_roundToUI32$(OBJ) \
|
||||
s_roundToUI64$(OBJ) \
|
||||
s_roundToI32$(OBJ) \
|
||||
s_roundToI64$(OBJ) \
|
||||
s_normSubnormalF16Sig$(OBJ) \
|
||||
s_roundPackToF16$(OBJ) \
|
||||
s_normRoundPackToF16$(OBJ) \
|
||||
s_addMagsF16$(OBJ) \
|
||||
s_subMagsF16$(OBJ) \
|
||||
s_mulAddF16$(OBJ) \
|
||||
s_normSubnormalF32Sig$(OBJ) \
|
||||
s_roundPackToF32$(OBJ) \
|
||||
s_normRoundPackToF32$(OBJ) \
|
||||
s_addMagsF32$(OBJ) \
|
||||
s_subMagsF32$(OBJ) \
|
||||
s_mulAddF32$(OBJ) \
|
||||
s_normSubnormalF64Sig$(OBJ) \
|
||||
s_roundPackToF64$(OBJ) \
|
||||
s_normRoundPackToF64$(OBJ) \
|
||||
s_addMagsF64$(OBJ) \
|
||||
s_subMagsF64$(OBJ) \
|
||||
s_mulAddF64$(OBJ) \
|
||||
s_normSubnormalExtF80Sig$(OBJ) \
|
||||
s_roundPackToExtF80$(OBJ) \
|
||||
s_normRoundPackToExtF80$(OBJ) \
|
||||
s_addMagsExtF80$(OBJ) \
|
||||
s_subMagsExtF80$(OBJ) \
|
||||
s_normSubnormalF128Sig$(OBJ) \
|
||||
s_roundPackToF128$(OBJ) \
|
||||
s_normRoundPackToF128$(OBJ) \
|
||||
s_addMagsF128$(OBJ) \
|
||||
s_subMagsF128$(OBJ) \
|
||||
s_mulAddF128$(OBJ) \
|
||||
softfloat_state$(OBJ) \
|
||||
ui32_to_f16$(OBJ) \
|
||||
ui32_to_f32$(OBJ) \
|
||||
ui32_to_f64$(OBJ) \
|
||||
ui32_to_extF80$(OBJ) \
|
||||
ui32_to_extF80M$(OBJ) \
|
||||
ui32_to_f128$(OBJ) \
|
||||
ui32_to_f128M$(OBJ) \
|
||||
ui64_to_f16$(OBJ) \
|
||||
ui64_to_f32$(OBJ) \
|
||||
ui64_to_f64$(OBJ) \
|
||||
ui64_to_extF80$(OBJ) \
|
||||
ui64_to_extF80M$(OBJ) \
|
||||
ui64_to_f128$(OBJ) \
|
||||
ui64_to_f128M$(OBJ) \
|
||||
i32_to_f16$(OBJ) \
|
||||
i32_to_f32$(OBJ) \
|
||||
i32_to_f64$(OBJ) \
|
||||
i32_to_extF80$(OBJ) \
|
||||
i32_to_extF80M$(OBJ) \
|
||||
i32_to_f128$(OBJ) \
|
||||
i32_to_f128M$(OBJ) \
|
||||
i64_to_f16$(OBJ) \
|
||||
i64_to_f32$(OBJ) \
|
||||
i64_to_f64$(OBJ) \
|
||||
i64_to_extF80$(OBJ) \
|
||||
i64_to_extF80M$(OBJ) \
|
||||
i64_to_f128$(OBJ) \
|
||||
i64_to_f128M$(OBJ) \
|
||||
f16_to_ui32$(OBJ) \
|
||||
f16_to_ui64$(OBJ) \
|
||||
f16_to_i32$(OBJ) \
|
||||
f16_to_i64$(OBJ) \
|
||||
f16_to_ui32_r_minMag$(OBJ) \
|
||||
f16_to_ui64_r_minMag$(OBJ) \
|
||||
f16_to_i32_r_minMag$(OBJ) \
|
||||
f16_to_i64_r_minMag$(OBJ) \
|
||||
f16_to_f32$(OBJ) \
|
||||
f16_to_f64$(OBJ) \
|
||||
f16_to_extF80$(OBJ) \
|
||||
f16_to_extF80M$(OBJ) \
|
||||
f16_to_f128$(OBJ) \
|
||||
f16_to_f128M$(OBJ) \
|
||||
f16_roundToInt$(OBJ) \
|
||||
f16_add$(OBJ) \
|
||||
f16_sub$(OBJ) \
|
||||
f16_mul$(OBJ) \
|
||||
f16_mulAdd$(OBJ) \
|
||||
f16_div$(OBJ) \
|
||||
f16_rem$(OBJ) \
|
||||
f16_sqrt$(OBJ) \
|
||||
f16_eq$(OBJ) \
|
||||
f16_le$(OBJ) \
|
||||
f16_lt$(OBJ) \
|
||||
f16_eq_signaling$(OBJ) \
|
||||
f16_le_quiet$(OBJ) \
|
||||
f16_lt_quiet$(OBJ) \
|
||||
f16_isSignalingNaN$(OBJ) \
|
||||
f32_to_ui32$(OBJ) \
|
||||
f32_to_ui64$(OBJ) \
|
||||
f32_to_i32$(OBJ) \
|
||||
f32_to_i64$(OBJ) \
|
||||
f32_to_ui32_r_minMag$(OBJ) \
|
||||
f32_to_ui64_r_minMag$(OBJ) \
|
||||
f32_to_i32_r_minMag$(OBJ) \
|
||||
f32_to_i64_r_minMag$(OBJ) \
|
||||
f32_to_f16$(OBJ) \
|
||||
f32_to_f64$(OBJ) \
|
||||
f32_to_extF80$(OBJ) \
|
||||
f32_to_extF80M$(OBJ) \
|
||||
f32_to_f128$(OBJ) \
|
||||
f32_to_f128M$(OBJ) \
|
||||
f32_roundToInt$(OBJ) \
|
||||
f32_add$(OBJ) \
|
||||
f32_sub$(OBJ) \
|
||||
f32_mul$(OBJ) \
|
||||
f32_mulAdd$(OBJ) \
|
||||
f32_div$(OBJ) \
|
||||
f32_rem$(OBJ) \
|
||||
f32_sqrt$(OBJ) \
|
||||
f32_eq$(OBJ) \
|
||||
f32_le$(OBJ) \
|
||||
f32_lt$(OBJ) \
|
||||
f32_eq_signaling$(OBJ) \
|
||||
f32_le_quiet$(OBJ) \
|
||||
f32_lt_quiet$(OBJ) \
|
||||
f32_isSignalingNaN$(OBJ) \
|
||||
f64_to_ui32$(OBJ) \
|
||||
f64_to_ui64$(OBJ) \
|
||||
f64_to_i32$(OBJ) \
|
||||
f64_to_i64$(OBJ) \
|
||||
f64_to_ui32_r_minMag$(OBJ) \
|
||||
f64_to_ui64_r_minMag$(OBJ) \
|
||||
f64_to_i32_r_minMag$(OBJ) \
|
||||
f64_to_i64_r_minMag$(OBJ) \
|
||||
f64_to_f16$(OBJ) \
|
||||
f64_to_f32$(OBJ) \
|
||||
f64_to_extF80$(OBJ) \
|
||||
f64_to_extF80M$(OBJ) \
|
||||
f64_to_f128$(OBJ) \
|
||||
f64_to_f128M$(OBJ) \
|
||||
f64_roundToInt$(OBJ) \
|
||||
f64_add$(OBJ) \
|
||||
f64_sub$(OBJ) \
|
||||
f64_mul$(OBJ) \
|
||||
f64_mulAdd$(OBJ) \
|
||||
f64_div$(OBJ) \
|
||||
f64_rem$(OBJ) \
|
||||
f64_sqrt$(OBJ) \
|
||||
f64_eq$(OBJ) \
|
||||
f64_le$(OBJ) \
|
||||
f64_lt$(OBJ) \
|
||||
f64_eq_signaling$(OBJ) \
|
||||
f64_le_quiet$(OBJ) \
|
||||
f64_lt_quiet$(OBJ) \
|
||||
f64_isSignalingNaN$(OBJ) \
|
||||
extF80_to_ui32$(OBJ) \
|
||||
extF80_to_ui64$(OBJ) \
|
||||
extF80_to_i32$(OBJ) \
|
||||
extF80_to_i64$(OBJ) \
|
||||
extF80_to_ui32_r_minMag$(OBJ) \
|
||||
extF80_to_ui64_r_minMag$(OBJ) \
|
||||
extF80_to_i32_r_minMag$(OBJ) \
|
||||
extF80_to_i64_r_minMag$(OBJ) \
|
||||
extF80_to_f16$(OBJ) \
|
||||
extF80_to_f32$(OBJ) \
|
||||
extF80_to_f64$(OBJ) \
|
||||
extF80_to_f128$(OBJ) \
|
||||
extF80_roundToInt$(OBJ) \
|
||||
extF80_add$(OBJ) \
|
||||
extF80_sub$(OBJ) \
|
||||
extF80_mul$(OBJ) \
|
||||
extF80_div$(OBJ) \
|
||||
extF80_rem$(OBJ) \
|
||||
extF80_sqrt$(OBJ) \
|
||||
extF80_eq$(OBJ) \
|
||||
extF80_le$(OBJ) \
|
||||
extF80_lt$(OBJ) \
|
||||
extF80_eq_signaling$(OBJ) \
|
||||
extF80_le_quiet$(OBJ) \
|
||||
extF80_lt_quiet$(OBJ) \
|
||||
extF80_isSignalingNaN$(OBJ) \
|
||||
extF80M_to_ui32$(OBJ) \
|
||||
extF80M_to_ui64$(OBJ) \
|
||||
extF80M_to_i32$(OBJ) \
|
||||
extF80M_to_i64$(OBJ) \
|
||||
extF80M_to_ui32_r_minMag$(OBJ) \
|
||||
extF80M_to_ui64_r_minMag$(OBJ) \
|
||||
extF80M_to_i32_r_minMag$(OBJ) \
|
||||
extF80M_to_i64_r_minMag$(OBJ) \
|
||||
extF80M_to_f16$(OBJ) \
|
||||
extF80M_to_f32$(OBJ) \
|
||||
extF80M_to_f64$(OBJ) \
|
||||
extF80M_to_f128M$(OBJ) \
|
||||
extF80M_roundToInt$(OBJ) \
|
||||
extF80M_add$(OBJ) \
|
||||
extF80M_sub$(OBJ) \
|
||||
extF80M_mul$(OBJ) \
|
||||
extF80M_div$(OBJ) \
|
||||
extF80M_rem$(OBJ) \
|
||||
extF80M_sqrt$(OBJ) \
|
||||
extF80M_eq$(OBJ) \
|
||||
extF80M_le$(OBJ) \
|
||||
extF80M_lt$(OBJ) \
|
||||
extF80M_eq_signaling$(OBJ) \
|
||||
extF80M_le_quiet$(OBJ) \
|
||||
extF80M_lt_quiet$(OBJ) \
|
||||
f128_to_ui32$(OBJ) \
|
||||
f128_to_ui64$(OBJ) \
|
||||
f128_to_i32$(OBJ) \
|
||||
f128_to_i64$(OBJ) \
|
||||
f128_to_ui32_r_minMag$(OBJ) \
|
||||
f128_to_ui64_r_minMag$(OBJ) \
|
||||
f128_to_i32_r_minMag$(OBJ) \
|
||||
f128_to_i64_r_minMag$(OBJ) \
|
||||
f128_to_f16$(OBJ) \
|
||||
f128_to_f32$(OBJ) \
|
||||
f128_to_extF80$(OBJ) \
|
||||
f128_to_f64$(OBJ) \
|
||||
f128_roundToInt$(OBJ) \
|
||||
f128_add$(OBJ) \
|
||||
f128_sub$(OBJ) \
|
||||
f128_mul$(OBJ) \
|
||||
f128_mulAdd$(OBJ) \
|
||||
f128_div$(OBJ) \
|
||||
f128_rem$(OBJ) \
|
||||
f128_sqrt$(OBJ) \
|
||||
f128_eq$(OBJ) \
|
||||
f128_le$(OBJ) \
|
||||
f128_lt$(OBJ) \
|
||||
f128_eq_signaling$(OBJ) \
|
||||
f128_le_quiet$(OBJ) \
|
||||
f128_lt_quiet$(OBJ) \
|
||||
f128_isSignalingNaN$(OBJ) \
|
||||
f128M_to_ui32$(OBJ) \
|
||||
f128M_to_ui64$(OBJ) \
|
||||
f128M_to_i32$(OBJ) \
|
||||
f128M_to_i64$(OBJ) \
|
||||
f128M_to_ui32_r_minMag$(OBJ) \
|
||||
f128M_to_ui64_r_minMag$(OBJ) \
|
||||
f128M_to_i32_r_minMag$(OBJ) \
|
||||
f128M_to_i64_r_minMag$(OBJ) \
|
||||
f128M_to_f16$(OBJ) \
|
||||
f128M_to_f32$(OBJ) \
|
||||
f128M_to_extF80M$(OBJ) \
|
||||
f128M_to_f64$(OBJ) \
|
||||
f128M_roundToInt$(OBJ) \
|
||||
f128M_add$(OBJ) \
|
||||
f128M_sub$(OBJ) \
|
||||
f128M_mul$(OBJ) \
|
||||
f128M_mulAdd$(OBJ) \
|
||||
f128M_div$(OBJ) \
|
||||
f128M_rem$(OBJ) \
|
||||
f128M_sqrt$(OBJ) \
|
||||
f128M_eq$(OBJ) \
|
||||
f128M_le$(OBJ) \
|
||||
f128M_lt$(OBJ) \
|
||||
f128M_eq_signaling$(OBJ) \
|
||||
f128M_le_quiet$(OBJ) \
|
||||
f128M_lt_quiet$(OBJ) \
|
||||
|
||||
OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS)
|
||||
|
||||
$(OBJS_ALL): \
|
||||
$(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \
|
||||
$(SOURCE_DIR)/include/primitives.h
|
||||
$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \
|
||||
$(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \
|
||||
$(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \
|
||||
$(SOURCE_DIR)/include/softfloat.h
|
||||
|
||||
$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c
|
||||
$(COMPILE_C) $(SOURCE_DIR)/$*.c
|
||||
|
||||
$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c
|
||||
$(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c
|
||||
|
||||
softfloat$(LIB): $(OBJS_ALL)
|
||||
$(DELETE) $@
|
||||
$(MAKELIB) $^
|
||||
|
||||
.PHONY: clean
|
||||
clean:
|
||||
$(DELETE) $(OBJS_ALL) softfloat$(LIB)
|
||||
|
||||
|
||||
#=============================================================================
|
||||
#
|
||||
# This Makefile is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
# Package, Release 3e, by John R. Hauser.
|
||||
#
|
||||
# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
|
||||
# University of California. All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions are met:
|
||||
#
|
||||
# 1. Redistributions of source code must retain the above copyright notice,
|
||||
# this list of conditions, and the following disclaimer.
|
||||
#
|
||||
# 2. Redistributions in binary form must reproduce the above copyright
|
||||
# notice, this list of conditions, and the following disclaimer in the
|
||||
# documentation and/or other materials provided with the distribution.
|
||||
#
|
||||
# 3. Neither the name of the University nor the names of its contributors
|
||||
# may be used to endorse or promote products derived from this software
|
||||
# without specific prior written permission.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
# DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
#
|
||||
#=============================================================================
|
||||
|
||||
SOURCE_DIR ?= ../../source
|
||||
SPECIALIZE_TYPE ?= 8086-SSE
|
||||
|
||||
SOFTFLOAT_OPTS ?= \
|
||||
-DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \
|
||||
-DSOFTFLOAT_FAST_DIV64TO32
|
||||
|
||||
DELETE = rm -f
|
||||
C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include
|
||||
COMPILE_C = \
|
||||
x86_64-w64-mingw32-gcc -c -Werror-implicit-function-declaration \
|
||||
-DSOFTFLOAT_FAST_INT64 $(SOFTFLOAT_OPTS) $(C_INCLUDES) -O2 -o $@
|
||||
MAKELIB = x86_64-w64-mingw32-ar crs $@
|
||||
|
||||
OBJ = .o
|
||||
LIB = .a
|
||||
|
||||
OTHER_HEADERS = $(SOURCE_DIR)/include/opts-GCC.h
|
||||
|
||||
.PHONY: all
|
||||
all: softfloat$(LIB)
|
||||
|
||||
OBJS_PRIMITIVES = \
|
||||
s_eq128$(OBJ) \
|
||||
s_le128$(OBJ) \
|
||||
s_lt128$(OBJ) \
|
||||
s_shortShiftLeft128$(OBJ) \
|
||||
s_shortShiftRight128$(OBJ) \
|
||||
s_shortShiftRightJam64$(OBJ) \
|
||||
s_shortShiftRightJam64Extra$(OBJ) \
|
||||
s_shortShiftRightJam128$(OBJ) \
|
||||
s_shortShiftRightJam128Extra$(OBJ) \
|
||||
s_shiftRightJam32$(OBJ) \
|
||||
s_shiftRightJam64$(OBJ) \
|
||||
s_shiftRightJam64Extra$(OBJ) \
|
||||
s_shiftRightJam128$(OBJ) \
|
||||
s_shiftRightJam128Extra$(OBJ) \
|
||||
s_shiftRightJam256M$(OBJ) \
|
||||
s_countLeadingZeros8$(OBJ) \
|
||||
s_countLeadingZeros16$(OBJ) \
|
||||
s_countLeadingZeros32$(OBJ) \
|
||||
s_countLeadingZeros64$(OBJ) \
|
||||
s_add128$(OBJ) \
|
||||
s_add256M$(OBJ) \
|
||||
s_sub128$(OBJ) \
|
||||
s_sub256M$(OBJ) \
|
||||
s_mul64ByShifted32To128$(OBJ) \
|
||||
s_mul64To128$(OBJ) \
|
||||
s_mul128By32$(OBJ) \
|
||||
s_mul128To256M$(OBJ) \
|
||||
s_approxRecip_1Ks$(OBJ) \
|
||||
s_approxRecip32_1$(OBJ) \
|
||||
s_approxRecipSqrt_1Ks$(OBJ) \
|
||||
s_approxRecipSqrt32_1$(OBJ) \
|
||||
|
||||
OBJS_SPECIALIZE = \
|
||||
softfloat_raiseFlags$(OBJ) \
|
||||
s_f16UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF16UI$(OBJ) \
|
||||
s_propagateNaNF16UI$(OBJ) \
|
||||
s_f32UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF32UI$(OBJ) \
|
||||
s_propagateNaNF32UI$(OBJ) \
|
||||
s_f64UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF64UI$(OBJ) \
|
||||
s_propagateNaNF64UI$(OBJ) \
|
||||
extF80M_isSignalingNaN$(OBJ) \
|
||||
s_extF80UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToExtF80UI$(OBJ) \
|
||||
s_propagateNaNExtF80UI$(OBJ) \
|
||||
f128M_isSignalingNaN$(OBJ) \
|
||||
s_f128UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF128UI$(OBJ) \
|
||||
s_propagateNaNF128UI$(OBJ) \
|
||||
|
||||
OBJS_OTHERS = \
|
||||
s_roundToUI32$(OBJ) \
|
||||
s_roundToUI64$(OBJ) \
|
||||
s_roundToI32$(OBJ) \
|
||||
s_roundToI64$(OBJ) \
|
||||
s_normSubnormalF16Sig$(OBJ) \
|
||||
s_roundPackToF16$(OBJ) \
|
||||
s_normRoundPackToF16$(OBJ) \
|
||||
s_addMagsF16$(OBJ) \
|
||||
s_subMagsF16$(OBJ) \
|
||||
s_mulAddF16$(OBJ) \
|
||||
s_normSubnormalF32Sig$(OBJ) \
|
||||
s_roundPackToF32$(OBJ) \
|
||||
s_normRoundPackToF32$(OBJ) \
|
||||
s_addMagsF32$(OBJ) \
|
||||
s_subMagsF32$(OBJ) \
|
||||
s_mulAddF32$(OBJ) \
|
||||
s_normSubnormalF64Sig$(OBJ) \
|
||||
s_roundPackToF64$(OBJ) \
|
||||
s_normRoundPackToF64$(OBJ) \
|
||||
s_addMagsF64$(OBJ) \
|
||||
s_subMagsF64$(OBJ) \
|
||||
s_mulAddF64$(OBJ) \
|
||||
s_normSubnormalExtF80Sig$(OBJ) \
|
||||
s_roundPackToExtF80$(OBJ) \
|
||||
s_normRoundPackToExtF80$(OBJ) \
|
||||
s_addMagsExtF80$(OBJ) \
|
||||
s_subMagsExtF80$(OBJ) \
|
||||
s_normSubnormalF128Sig$(OBJ) \
|
||||
s_roundPackToF128$(OBJ) \
|
||||
s_normRoundPackToF128$(OBJ) \
|
||||
s_addMagsF128$(OBJ) \
|
||||
s_subMagsF128$(OBJ) \
|
||||
s_mulAddF128$(OBJ) \
|
||||
softfloat_state$(OBJ) \
|
||||
ui32_to_f16$(OBJ) \
|
||||
ui32_to_f32$(OBJ) \
|
||||
ui32_to_f64$(OBJ) \
|
||||
ui32_to_extF80$(OBJ) \
|
||||
ui32_to_extF80M$(OBJ) \
|
||||
ui32_to_f128$(OBJ) \
|
||||
ui32_to_f128M$(OBJ) \
|
||||
ui64_to_f16$(OBJ) \
|
||||
ui64_to_f32$(OBJ) \
|
||||
ui64_to_f64$(OBJ) \
|
||||
ui64_to_extF80$(OBJ) \
|
||||
ui64_to_extF80M$(OBJ) \
|
||||
ui64_to_f128$(OBJ) \
|
||||
ui64_to_f128M$(OBJ) \
|
||||
i32_to_f16$(OBJ) \
|
||||
i32_to_f32$(OBJ) \
|
||||
i32_to_f64$(OBJ) \
|
||||
i32_to_extF80$(OBJ) \
|
||||
i32_to_extF80M$(OBJ) \
|
||||
i32_to_f128$(OBJ) \
|
||||
i32_to_f128M$(OBJ) \
|
||||
i64_to_f16$(OBJ) \
|
||||
i64_to_f32$(OBJ) \
|
||||
i64_to_f64$(OBJ) \
|
||||
i64_to_extF80$(OBJ) \
|
||||
i64_to_extF80M$(OBJ) \
|
||||
i64_to_f128$(OBJ) \
|
||||
i64_to_f128M$(OBJ) \
|
||||
f16_to_ui32$(OBJ) \
|
||||
f16_to_ui64$(OBJ) \
|
||||
f16_to_i32$(OBJ) \
|
||||
f16_to_i64$(OBJ) \
|
||||
f16_to_ui32_r_minMag$(OBJ) \
|
||||
f16_to_ui64_r_minMag$(OBJ) \
|
||||
f16_to_i32_r_minMag$(OBJ) \
|
||||
f16_to_i64_r_minMag$(OBJ) \
|
||||
f16_to_f32$(OBJ) \
|
||||
f16_to_f64$(OBJ) \
|
||||
f16_to_extF80$(OBJ) \
|
||||
f16_to_extF80M$(OBJ) \
|
||||
f16_to_f128$(OBJ) \
|
||||
f16_to_f128M$(OBJ) \
|
||||
f16_roundToInt$(OBJ) \
|
||||
f16_add$(OBJ) \
|
||||
f16_sub$(OBJ) \
|
||||
f16_mul$(OBJ) \
|
||||
f16_mulAdd$(OBJ) \
|
||||
f16_div$(OBJ) \
|
||||
f16_rem$(OBJ) \
|
||||
f16_sqrt$(OBJ) \
|
||||
f16_eq$(OBJ) \
|
||||
f16_le$(OBJ) \
|
||||
f16_lt$(OBJ) \
|
||||
f16_eq_signaling$(OBJ) \
|
||||
f16_le_quiet$(OBJ) \
|
||||
f16_lt_quiet$(OBJ) \
|
||||
f16_isSignalingNaN$(OBJ) \
|
||||
f32_to_ui32$(OBJ) \
|
||||
f32_to_ui64$(OBJ) \
|
||||
f32_to_i32$(OBJ) \
|
||||
f32_to_i64$(OBJ) \
|
||||
f32_to_ui32_r_minMag$(OBJ) \
|
||||
f32_to_ui64_r_minMag$(OBJ) \
|
||||
f32_to_i32_r_minMag$(OBJ) \
|
||||
f32_to_i64_r_minMag$(OBJ) \
|
||||
f32_to_f16$(OBJ) \
|
||||
f32_to_f64$(OBJ) \
|
||||
f32_to_extF80$(OBJ) \
|
||||
f32_to_extF80M$(OBJ) \
|
||||
f32_to_f128$(OBJ) \
|
||||
f32_to_f128M$(OBJ) \
|
||||
f32_roundToInt$(OBJ) \
|
||||
f32_add$(OBJ) \
|
||||
f32_sub$(OBJ) \
|
||||
f32_mul$(OBJ) \
|
||||
f32_mulAdd$(OBJ) \
|
||||
f32_div$(OBJ) \
|
||||
f32_rem$(OBJ) \
|
||||
f32_sqrt$(OBJ) \
|
||||
f32_eq$(OBJ) \
|
||||
f32_le$(OBJ) \
|
||||
f32_lt$(OBJ) \
|
||||
f32_eq_signaling$(OBJ) \
|
||||
f32_le_quiet$(OBJ) \
|
||||
f32_lt_quiet$(OBJ) \
|
||||
f32_isSignalingNaN$(OBJ) \
|
||||
f64_to_ui32$(OBJ) \
|
||||
f64_to_ui64$(OBJ) \
|
||||
f64_to_i32$(OBJ) \
|
||||
f64_to_i64$(OBJ) \
|
||||
f64_to_ui32_r_minMag$(OBJ) \
|
||||
f64_to_ui64_r_minMag$(OBJ) \
|
||||
f64_to_i32_r_minMag$(OBJ) \
|
||||
f64_to_i64_r_minMag$(OBJ) \
|
||||
f64_to_f16$(OBJ) \
|
||||
f64_to_f32$(OBJ) \
|
||||
f64_to_extF80$(OBJ) \
|
||||
f64_to_extF80M$(OBJ) \
|
||||
f64_to_f128$(OBJ) \
|
||||
f64_to_f128M$(OBJ) \
|
||||
f64_roundToInt$(OBJ) \
|
||||
f64_add$(OBJ) \
|
||||
f64_sub$(OBJ) \
|
||||
f64_mul$(OBJ) \
|
||||
f64_mulAdd$(OBJ) \
|
||||
f64_div$(OBJ) \
|
||||
f64_rem$(OBJ) \
|
||||
f64_sqrt$(OBJ) \
|
||||
f64_eq$(OBJ) \
|
||||
f64_le$(OBJ) \
|
||||
f64_lt$(OBJ) \
|
||||
f64_eq_signaling$(OBJ) \
|
||||
f64_le_quiet$(OBJ) \
|
||||
f64_lt_quiet$(OBJ) \
|
||||
f64_isSignalingNaN$(OBJ) \
|
||||
extF80_to_ui32$(OBJ) \
|
||||
extF80_to_ui64$(OBJ) \
|
||||
extF80_to_i32$(OBJ) \
|
||||
extF80_to_i64$(OBJ) \
|
||||
extF80_to_ui32_r_minMag$(OBJ) \
|
||||
extF80_to_ui64_r_minMag$(OBJ) \
|
||||
extF80_to_i32_r_minMag$(OBJ) \
|
||||
extF80_to_i64_r_minMag$(OBJ) \
|
||||
extF80_to_f16$(OBJ) \
|
||||
extF80_to_f32$(OBJ) \
|
||||
extF80_to_f64$(OBJ) \
|
||||
extF80_to_f128$(OBJ) \
|
||||
extF80_roundToInt$(OBJ) \
|
||||
extF80_add$(OBJ) \
|
||||
extF80_sub$(OBJ) \
|
||||
extF80_mul$(OBJ) \
|
||||
extF80_div$(OBJ) \
|
||||
extF80_rem$(OBJ) \
|
||||
extF80_sqrt$(OBJ) \
|
||||
extF80_eq$(OBJ) \
|
||||
extF80_le$(OBJ) \
|
||||
extF80_lt$(OBJ) \
|
||||
extF80_eq_signaling$(OBJ) \
|
||||
extF80_le_quiet$(OBJ) \
|
||||
extF80_lt_quiet$(OBJ) \
|
||||
extF80_isSignalingNaN$(OBJ) \
|
||||
extF80M_to_ui32$(OBJ) \
|
||||
extF80M_to_ui64$(OBJ) \
|
||||
extF80M_to_i32$(OBJ) \
|
||||
extF80M_to_i64$(OBJ) \
|
||||
extF80M_to_ui32_r_minMag$(OBJ) \
|
||||
extF80M_to_ui64_r_minMag$(OBJ) \
|
||||
extF80M_to_i32_r_minMag$(OBJ) \
|
||||
extF80M_to_i64_r_minMag$(OBJ) \
|
||||
extF80M_to_f16$(OBJ) \
|
||||
extF80M_to_f32$(OBJ) \
|
||||
extF80M_to_f64$(OBJ) \
|
||||
extF80M_to_f128M$(OBJ) \
|
||||
extF80M_roundToInt$(OBJ) \
|
||||
extF80M_add$(OBJ) \
|
||||
extF80M_sub$(OBJ) \
|
||||
extF80M_mul$(OBJ) \
|
||||
extF80M_div$(OBJ) \
|
||||
extF80M_rem$(OBJ) \
|
||||
extF80M_sqrt$(OBJ) \
|
||||
extF80M_eq$(OBJ) \
|
||||
extF80M_le$(OBJ) \
|
||||
extF80M_lt$(OBJ) \
|
||||
extF80M_eq_signaling$(OBJ) \
|
||||
extF80M_le_quiet$(OBJ) \
|
||||
extF80M_lt_quiet$(OBJ) \
|
||||
f128_to_ui32$(OBJ) \
|
||||
f128_to_ui64$(OBJ) \
|
||||
f128_to_i32$(OBJ) \
|
||||
f128_to_i64$(OBJ) \
|
||||
f128_to_ui32_r_minMag$(OBJ) \
|
||||
f128_to_ui64_r_minMag$(OBJ) \
|
||||
f128_to_i32_r_minMag$(OBJ) \
|
||||
f128_to_i64_r_minMag$(OBJ) \
|
||||
f128_to_f16$(OBJ) \
|
||||
f128_to_f32$(OBJ) \
|
||||
f128_to_extF80$(OBJ) \
|
||||
f128_to_f64$(OBJ) \
|
||||
f128_roundToInt$(OBJ) \
|
||||
f128_add$(OBJ) \
|
||||
f128_sub$(OBJ) \
|
||||
f128_mul$(OBJ) \
|
||||
f128_mulAdd$(OBJ) \
|
||||
f128_div$(OBJ) \
|
||||
f128_rem$(OBJ) \
|
||||
f128_sqrt$(OBJ) \
|
||||
f128_eq$(OBJ) \
|
||||
f128_le$(OBJ) \
|
||||
f128_lt$(OBJ) \
|
||||
f128_eq_signaling$(OBJ) \
|
||||
f128_le_quiet$(OBJ) \
|
||||
f128_lt_quiet$(OBJ) \
|
||||
f128_isSignalingNaN$(OBJ) \
|
||||
f128M_to_ui32$(OBJ) \
|
||||
f128M_to_ui64$(OBJ) \
|
||||
f128M_to_i32$(OBJ) \
|
||||
f128M_to_i64$(OBJ) \
|
||||
f128M_to_ui32_r_minMag$(OBJ) \
|
||||
f128M_to_ui64_r_minMag$(OBJ) \
|
||||
f128M_to_i32_r_minMag$(OBJ) \
|
||||
f128M_to_i64_r_minMag$(OBJ) \
|
||||
f128M_to_f16$(OBJ) \
|
||||
f128M_to_f32$(OBJ) \
|
||||
f128M_to_extF80M$(OBJ) \
|
||||
f128M_to_f64$(OBJ) \
|
||||
f128M_roundToInt$(OBJ) \
|
||||
f128M_add$(OBJ) \
|
||||
f128M_sub$(OBJ) \
|
||||
f128M_mul$(OBJ) \
|
||||
f128M_mulAdd$(OBJ) \
|
||||
f128M_div$(OBJ) \
|
||||
f128M_rem$(OBJ) \
|
||||
f128M_sqrt$(OBJ) \
|
||||
f128M_eq$(OBJ) \
|
||||
f128M_le$(OBJ) \
|
||||
f128M_lt$(OBJ) \
|
||||
f128M_eq_signaling$(OBJ) \
|
||||
f128M_le_quiet$(OBJ) \
|
||||
f128M_lt_quiet$(OBJ) \
|
||||
|
||||
OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS)
|
||||
|
||||
$(OBJS_ALL): \
|
||||
$(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \
|
||||
$(SOURCE_DIR)/include/primitives.h
|
||||
$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \
|
||||
$(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \
|
||||
$(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \
|
||||
$(SOURCE_DIR)/include/softfloat.h
|
||||
|
||||
$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c
|
||||
$(COMPILE_C) $(SOURCE_DIR)/$*.c
|
||||
|
||||
$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c
|
||||
$(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c
|
||||
|
||||
softfloat$(LIB): $(OBJS_ALL)
|
||||
$(DELETE) $@
|
||||
$(MAKELIB) $^
|
||||
|
||||
.PHONY: clean
|
||||
clean:
|
||||
$(DELETE) $(OBJS_ALL) softfloat$(LIB)
|
||||
|
||||
|
@ -1,53 +1,54 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
|
||||
University of California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define LITTLEENDIAN 1
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#ifdef __GNUC_STDC_INLINE__
|
||||
#define INLINE inline
|
||||
#else
|
||||
#define INLINE extern inline
|
||||
#endif
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define SOFTFLOAT_BUILTIN_CLZ 1
|
||||
#define SOFTFLOAT_INTRINSIC_INT128 1
|
||||
#include "opts-GCC.h"
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
|
||||
University of California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define LITTLEENDIAN 1
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#ifdef __GNUC_STDC_INLINE__
|
||||
#define INLINE inline
|
||||
#else
|
||||
#define INLINE extern inline
|
||||
#endif
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define SOFTFLOAT_BUILTIN_CLZ 1
|
||||
#define SOFTFLOAT_INTRINSIC_INT128 1
|
||||
#include "opts-GCC.h"
|
||||
|
||||
|
@ -1,391 +1,396 @@
|
||||
|
||||
#=============================================================================
|
||||
#
|
||||
# This Makefile template is part of the SoftFloat IEEE Floating-Point
|
||||
# Arithmetic Package, Release 3e, by John R. Hauser.
|
||||
#
|
||||
# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
|
||||
# University of California. All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions are met:
|
||||
#
|
||||
# 1. Redistributions of source code must retain the above copyright notice,
|
||||
# this list of conditions, and the following disclaimer.
|
||||
#
|
||||
# 2. Redistributions in binary form must reproduce the above copyright
|
||||
# notice, this list of conditions, and the following disclaimer in the
|
||||
# documentation and/or other materials provided with the distribution.
|
||||
#
|
||||
# 3. Neither the name of the University nor the names of its contributors
|
||||
# may be used to endorse or promote products derived from this software
|
||||
# without specific prior written permission.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
# DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
#
|
||||
#=============================================================================
|
||||
|
||||
# Edit lines marked with `==>'. See "SoftFloat-source.html".
|
||||
|
||||
==> SOURCE_DIR ?= ../../source
|
||||
==> SPECIALIZE_TYPE ?= 8086
|
||||
|
||||
==> SOFTFLOAT_OPTS ?= \
|
||||
==> -DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \
|
||||
==> -DSOFTFLOAT_FAST_DIV64TO32
|
||||
|
||||
==> DELETE = rm -f
|
||||
==> C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include
|
||||
==> COMPILE_C = \
|
||||
==> cc -c -DSOFTFLOAT_FAST_INT64 $(SOFTFLOAT_OPTS) $(C_INCLUDES) -O2 -o $@
|
||||
==> MAKELIB = ar crs $@
|
||||
|
||||
==> OBJ = .o
|
||||
==> LIB = .a
|
||||
|
||||
==> OTHER_HEADERS =
|
||||
|
||||
.PHONY: all
|
||||
all: softfloat$(LIB)
|
||||
|
||||
OBJS_PRIMITIVES = \
|
||||
s_eq128$(OBJ) \
|
||||
s_le128$(OBJ) \
|
||||
s_lt128$(OBJ) \
|
||||
s_shortShiftLeft128$(OBJ) \
|
||||
s_shortShiftRight128$(OBJ) \
|
||||
s_shortShiftRightJam64$(OBJ) \
|
||||
s_shortShiftRightJam64Extra$(OBJ) \
|
||||
s_shortShiftRightJam128$(OBJ) \
|
||||
s_shortShiftRightJam128Extra$(OBJ) \
|
||||
s_shiftRightJam32$(OBJ) \
|
||||
s_shiftRightJam64$(OBJ) \
|
||||
s_shiftRightJam64Extra$(OBJ) \
|
||||
s_shiftRightJam128$(OBJ) \
|
||||
s_shiftRightJam128Extra$(OBJ) \
|
||||
s_shiftRightJam256M$(OBJ) \
|
||||
s_countLeadingZeros8$(OBJ) \
|
||||
s_countLeadingZeros16$(OBJ) \
|
||||
s_countLeadingZeros32$(OBJ) \
|
||||
s_countLeadingZeros64$(OBJ) \
|
||||
s_add128$(OBJ) \
|
||||
s_add256M$(OBJ) \
|
||||
s_sub128$(OBJ) \
|
||||
s_sub256M$(OBJ) \
|
||||
s_mul64ByShifted32To128$(OBJ) \
|
||||
s_mul64To128$(OBJ) \
|
||||
s_mul128By32$(OBJ) \
|
||||
s_mul128To256M$(OBJ) \
|
||||
s_approxRecip_1Ks$(OBJ) \
|
||||
s_approxRecip32_1$(OBJ) \
|
||||
s_approxRecipSqrt_1Ks$(OBJ) \
|
||||
s_approxRecipSqrt32_1$(OBJ) \
|
||||
|
||||
OBJS_SPECIALIZE = \
|
||||
softfloat_raiseFlags$(OBJ) \
|
||||
s_f16UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF16UI$(OBJ) \
|
||||
s_propagateNaNF16UI$(OBJ) \
|
||||
s_f32UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF32UI$(OBJ) \
|
||||
s_propagateNaNF32UI$(OBJ) \
|
||||
s_f64UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF64UI$(OBJ) \
|
||||
s_propagateNaNF64UI$(OBJ) \
|
||||
extF80M_isSignalingNaN$(OBJ) \
|
||||
s_extF80UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToExtF80UI$(OBJ) \
|
||||
s_propagateNaNExtF80UI$(OBJ) \
|
||||
f128M_isSignalingNaN$(OBJ) \
|
||||
s_f128UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF128UI$(OBJ) \
|
||||
s_propagateNaNF128UI$(OBJ) \
|
||||
|
||||
OBJS_OTHERS = \
|
||||
s_roundToUI32$(OBJ) \
|
||||
s_roundToUI64$(OBJ) \
|
||||
s_roundToI32$(OBJ) \
|
||||
s_roundToI64$(OBJ) \
|
||||
s_normSubnormalF16Sig$(OBJ) \
|
||||
s_roundPackToF16$(OBJ) \
|
||||
s_normRoundPackToF16$(OBJ) \
|
||||
s_addMagsF16$(OBJ) \
|
||||
s_subMagsF16$(OBJ) \
|
||||
s_mulAddF16$(OBJ) \
|
||||
s_normSubnormalF32Sig$(OBJ) \
|
||||
s_roundPackToF32$(OBJ) \
|
||||
s_normRoundPackToF32$(OBJ) \
|
||||
s_addMagsF32$(OBJ) \
|
||||
s_subMagsF32$(OBJ) \
|
||||
s_mulAddF32$(OBJ) \
|
||||
s_normSubnormalF64Sig$(OBJ) \
|
||||
s_roundPackToF64$(OBJ) \
|
||||
s_normRoundPackToF64$(OBJ) \
|
||||
s_addMagsF64$(OBJ) \
|
||||
s_subMagsF64$(OBJ) \
|
||||
s_mulAddF64$(OBJ) \
|
||||
s_normSubnormalExtF80Sig$(OBJ) \
|
||||
s_roundPackToExtF80$(OBJ) \
|
||||
s_normRoundPackToExtF80$(OBJ) \
|
||||
s_addMagsExtF80$(OBJ) \
|
||||
s_subMagsExtF80$(OBJ) \
|
||||
s_normSubnormalF128Sig$(OBJ) \
|
||||
s_roundPackToF128$(OBJ) \
|
||||
s_normRoundPackToF128$(OBJ) \
|
||||
s_addMagsF128$(OBJ) \
|
||||
s_subMagsF128$(OBJ) \
|
||||
s_mulAddF128$(OBJ) \
|
||||
softfloat_state$(OBJ) \
|
||||
ui32_to_f16$(OBJ) \
|
||||
ui32_to_f32$(OBJ) \
|
||||
ui32_to_f64$(OBJ) \
|
||||
ui32_to_extF80$(OBJ) \
|
||||
ui32_to_extF80M$(OBJ) \
|
||||
ui32_to_f128$(OBJ) \
|
||||
ui32_to_f128M$(OBJ) \
|
||||
ui64_to_f16$(OBJ) \
|
||||
ui64_to_f32$(OBJ) \
|
||||
ui64_to_f64$(OBJ) \
|
||||
ui64_to_extF80$(OBJ) \
|
||||
ui64_to_extF80M$(OBJ) \
|
||||
ui64_to_f128$(OBJ) \
|
||||
ui64_to_f128M$(OBJ) \
|
||||
i32_to_f16$(OBJ) \
|
||||
i32_to_f32$(OBJ) \
|
||||
i32_to_f64$(OBJ) \
|
||||
i32_to_extF80$(OBJ) \
|
||||
i32_to_extF80M$(OBJ) \
|
||||
i32_to_f128$(OBJ) \
|
||||
i32_to_f128M$(OBJ) \
|
||||
i64_to_f16$(OBJ) \
|
||||
i64_to_f32$(OBJ) \
|
||||
i64_to_f64$(OBJ) \
|
||||
i64_to_extF80$(OBJ) \
|
||||
i64_to_extF80M$(OBJ) \
|
||||
i64_to_f128$(OBJ) \
|
||||
i64_to_f128M$(OBJ) \
|
||||
f16_to_ui32$(OBJ) \
|
||||
f16_to_ui64$(OBJ) \
|
||||
f16_to_i32$(OBJ) \
|
||||
f16_to_i64$(OBJ) \
|
||||
f16_to_ui32_r_minMag$(OBJ) \
|
||||
f16_to_ui64_r_minMag$(OBJ) \
|
||||
f16_to_i32_r_minMag$(OBJ) \
|
||||
f16_to_i64_r_minMag$(OBJ) \
|
||||
f16_to_f32$(OBJ) \
|
||||
f16_to_f64$(OBJ) \
|
||||
f16_to_extF80$(OBJ) \
|
||||
f16_to_extF80M$(OBJ) \
|
||||
f16_to_f128$(OBJ) \
|
||||
f16_to_f128M$(OBJ) \
|
||||
f16_roundToInt$(OBJ) \
|
||||
f16_add$(OBJ) \
|
||||
f16_sub$(OBJ) \
|
||||
f16_mul$(OBJ) \
|
||||
f16_mulAdd$(OBJ) \
|
||||
f16_div$(OBJ) \
|
||||
f16_rem$(OBJ) \
|
||||
f16_sqrt$(OBJ) \
|
||||
f16_eq$(OBJ) \
|
||||
f16_le$(OBJ) \
|
||||
f16_lt$(OBJ) \
|
||||
f16_eq_signaling$(OBJ) \
|
||||
f16_le_quiet$(OBJ) \
|
||||
f16_lt_quiet$(OBJ) \
|
||||
f16_isSignalingNaN$(OBJ) \
|
||||
f32_to_ui32$(OBJ) \
|
||||
f32_to_ui64$(OBJ) \
|
||||
f32_to_i32$(OBJ) \
|
||||
f32_to_i64$(OBJ) \
|
||||
f32_to_ui32_r_minMag$(OBJ) \
|
||||
f32_to_ui64_r_minMag$(OBJ) \
|
||||
f32_to_i32_r_minMag$(OBJ) \
|
||||
f32_to_i64_r_minMag$(OBJ) \
|
||||
f32_to_f16$(OBJ) \
|
||||
f32_to_f64$(OBJ) \
|
||||
f32_to_extF80$(OBJ) \
|
||||
f32_to_extF80M$(OBJ) \
|
||||
f32_to_f128$(OBJ) \
|
||||
f32_to_f128M$(OBJ) \
|
||||
f32_roundToInt$(OBJ) \
|
||||
f32_add$(OBJ) \
|
||||
f32_sub$(OBJ) \
|
||||
f32_mul$(OBJ) \
|
||||
f32_mulAdd$(OBJ) \
|
||||
f32_div$(OBJ) \
|
||||
f32_rem$(OBJ) \
|
||||
f32_sqrt$(OBJ) \
|
||||
f32_eq$(OBJ) \
|
||||
f32_le$(OBJ) \
|
||||
f32_lt$(OBJ) \
|
||||
f32_eq_signaling$(OBJ) \
|
||||
f32_le_quiet$(OBJ) \
|
||||
f32_lt_quiet$(OBJ) \
|
||||
f32_isSignalingNaN$(OBJ) \
|
||||
f64_to_ui32$(OBJ) \
|
||||
f64_to_ui64$(OBJ) \
|
||||
f64_to_i32$(OBJ) \
|
||||
f64_to_i64$(OBJ) \
|
||||
f64_to_ui32_r_minMag$(OBJ) \
|
||||
f64_to_ui64_r_minMag$(OBJ) \
|
||||
f64_to_i32_r_minMag$(OBJ) \
|
||||
f64_to_i64_r_minMag$(OBJ) \
|
||||
f64_to_f16$(OBJ) \
|
||||
f64_to_f32$(OBJ) \
|
||||
f64_to_extF80$(OBJ) \
|
||||
f64_to_extF80M$(OBJ) \
|
||||
f64_to_f128$(OBJ) \
|
||||
f64_to_f128M$(OBJ) \
|
||||
f64_roundToInt$(OBJ) \
|
||||
f64_add$(OBJ) \
|
||||
f64_sub$(OBJ) \
|
||||
f64_mul$(OBJ) \
|
||||
f64_mulAdd$(OBJ) \
|
||||
f64_div$(OBJ) \
|
||||
f64_rem$(OBJ) \
|
||||
f64_sqrt$(OBJ) \
|
||||
f64_eq$(OBJ) \
|
||||
f64_le$(OBJ) \
|
||||
f64_lt$(OBJ) \
|
||||
f64_eq_signaling$(OBJ) \
|
||||
f64_le_quiet$(OBJ) \
|
||||
f64_lt_quiet$(OBJ) \
|
||||
f64_isSignalingNaN$(OBJ) \
|
||||
extF80_to_ui32$(OBJ) \
|
||||
extF80_to_ui64$(OBJ) \
|
||||
extF80_to_i32$(OBJ) \
|
||||
extF80_to_i64$(OBJ) \
|
||||
extF80_to_ui32_r_minMag$(OBJ) \
|
||||
extF80_to_ui64_r_minMag$(OBJ) \
|
||||
extF80_to_i32_r_minMag$(OBJ) \
|
||||
extF80_to_i64_r_minMag$(OBJ) \
|
||||
extF80_to_f16$(OBJ) \
|
||||
extF80_to_f32$(OBJ) \
|
||||
extF80_to_f64$(OBJ) \
|
||||
extF80_to_f128$(OBJ) \
|
||||
extF80_roundToInt$(OBJ) \
|
||||
extF80_add$(OBJ) \
|
||||
extF80_sub$(OBJ) \
|
||||
extF80_mul$(OBJ) \
|
||||
extF80_div$(OBJ) \
|
||||
extF80_rem$(OBJ) \
|
||||
extF80_sqrt$(OBJ) \
|
||||
extF80_eq$(OBJ) \
|
||||
extF80_le$(OBJ) \
|
||||
extF80_lt$(OBJ) \
|
||||
extF80_eq_signaling$(OBJ) \
|
||||
extF80_le_quiet$(OBJ) \
|
||||
extF80_lt_quiet$(OBJ) \
|
||||
extF80_isSignalingNaN$(OBJ) \
|
||||
extF80M_to_ui32$(OBJ) \
|
||||
extF80M_to_ui64$(OBJ) \
|
||||
extF80M_to_i32$(OBJ) \
|
||||
extF80M_to_i64$(OBJ) \
|
||||
extF80M_to_ui32_r_minMag$(OBJ) \
|
||||
extF80M_to_ui64_r_minMag$(OBJ) \
|
||||
extF80M_to_i32_r_minMag$(OBJ) \
|
||||
extF80M_to_i64_r_minMag$(OBJ) \
|
||||
extF80M_to_f16$(OBJ) \
|
||||
extF80M_to_f32$(OBJ) \
|
||||
extF80M_to_f64$(OBJ) \
|
||||
extF80M_to_f128M$(OBJ) \
|
||||
extF80M_roundToInt$(OBJ) \
|
||||
extF80M_add$(OBJ) \
|
||||
extF80M_sub$(OBJ) \
|
||||
extF80M_mul$(OBJ) \
|
||||
extF80M_div$(OBJ) \
|
||||
extF80M_rem$(OBJ) \
|
||||
extF80M_sqrt$(OBJ) \
|
||||
extF80M_eq$(OBJ) \
|
||||
extF80M_le$(OBJ) \
|
||||
extF80M_lt$(OBJ) \
|
||||
extF80M_eq_signaling$(OBJ) \
|
||||
extF80M_le_quiet$(OBJ) \
|
||||
extF80M_lt_quiet$(OBJ) \
|
||||
f128_to_ui32$(OBJ) \
|
||||
f128_to_ui64$(OBJ) \
|
||||
f128_to_i32$(OBJ) \
|
||||
f128_to_i64$(OBJ) \
|
||||
f128_to_ui32_r_minMag$(OBJ) \
|
||||
f128_to_ui64_r_minMag$(OBJ) \
|
||||
f128_to_i32_r_minMag$(OBJ) \
|
||||
f128_to_i64_r_minMag$(OBJ) \
|
||||
f128_to_f16$(OBJ) \
|
||||
f128_to_f32$(OBJ) \
|
||||
f128_to_extF80$(OBJ) \
|
||||
f128_to_f64$(OBJ) \
|
||||
f128_roundToInt$(OBJ) \
|
||||
f128_add$(OBJ) \
|
||||
f128_sub$(OBJ) \
|
||||
f128_mul$(OBJ) \
|
||||
f128_mulAdd$(OBJ) \
|
||||
f128_div$(OBJ) \
|
||||
f128_rem$(OBJ) \
|
||||
f128_sqrt$(OBJ) \
|
||||
f128_eq$(OBJ) \
|
||||
f128_le$(OBJ) \
|
||||
f128_lt$(OBJ) \
|
||||
f128_eq_signaling$(OBJ) \
|
||||
f128_le_quiet$(OBJ) \
|
||||
f128_lt_quiet$(OBJ) \
|
||||
f128_isSignalingNaN$(OBJ) \
|
||||
f128M_to_ui32$(OBJ) \
|
||||
f128M_to_ui64$(OBJ) \
|
||||
f128M_to_i32$(OBJ) \
|
||||
f128M_to_i64$(OBJ) \
|
||||
f128M_to_ui32_r_minMag$(OBJ) \
|
||||
f128M_to_ui64_r_minMag$(OBJ) \
|
||||
f128M_to_i32_r_minMag$(OBJ) \
|
||||
f128M_to_i64_r_minMag$(OBJ) \
|
||||
f128M_to_f16$(OBJ) \
|
||||
f128M_to_f32$(OBJ) \
|
||||
f128M_to_extF80M$(OBJ) \
|
||||
f128M_to_f64$(OBJ) \
|
||||
f128M_roundToInt$(OBJ) \
|
||||
f128M_add$(OBJ) \
|
||||
f128M_sub$(OBJ) \
|
||||
f128M_mul$(OBJ) \
|
||||
f128M_mulAdd$(OBJ) \
|
||||
f128M_div$(OBJ) \
|
||||
f128M_rem$(OBJ) \
|
||||
f128M_sqrt$(OBJ) \
|
||||
f128M_eq$(OBJ) \
|
||||
f128M_le$(OBJ) \
|
||||
f128M_lt$(OBJ) \
|
||||
f128M_eq_signaling$(OBJ) \
|
||||
f128M_le_quiet$(OBJ) \
|
||||
f128M_lt_quiet$(OBJ) \
|
||||
|
||||
OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS)
|
||||
|
||||
$(OBJS_ALL): \
|
||||
$(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \
|
||||
$(SOURCE_DIR)/include/primitives.h
|
||||
$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \
|
||||
$(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \
|
||||
$(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \
|
||||
$(SOURCE_DIR)/include/softfloat.h
|
||||
|
||||
$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c
|
||||
$(COMPILE_C) $(SOURCE_DIR)/$*.c
|
||||
|
||||
$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c
|
||||
$(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c
|
||||
|
||||
softfloat$(LIB): $(OBJS_ALL)
|
||||
$(DELETE) $@
|
||||
$(MAKELIB) $^
|
||||
|
||||
.PHONY: clean
|
||||
clean:
|
||||
$(DELETE) $(OBJS_ALL) softfloat$(LIB)
|
||||
|
||||
|
||||
#=============================================================================
|
||||
#
|
||||
# This Makefile template is part of the SoftFloat IEEE Floating-Point
|
||||
# Arithmetic Package, Release 3e, by John R. Hauser.
|
||||
#
|
||||
# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
|
||||
# University of California. All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions are met:
|
||||
#
|
||||
# 1. Redistributions of source code must retain the above copyright notice,
|
||||
# this list of conditions, and the following disclaimer.
|
||||
#
|
||||
# 2. Redistributions in binary form must reproduce the above copyright
|
||||
# notice, this list of conditions, and the following disclaimer in the
|
||||
# documentation and/or other materials provided with the distribution.
|
||||
#
|
||||
# 3. Neither the name of the University nor the names of its contributors
|
||||
# may be used to endorse or promote products derived from this software
|
||||
# without specific prior written permission.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
# DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
#
|
||||
#=============================================================================
|
||||
|
||||
# Edit lines marked with `==>'. See "SoftFloat-source.html".
|
||||
|
||||
==> SOURCE_DIR ?= ../../source
|
||||
==> SPECIALIZE_TYPE ?= 8086
|
||||
|
||||
==> SOFTFLOAT_OPTS ?= \
|
||||
==> -DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \
|
||||
==> -DSOFTFLOAT_FAST_DIV64TO32
|
||||
|
||||
==> DELETE = rm -f
|
||||
==> C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include
|
||||
==> COMPILE_C = \
|
||||
==> cc -c -DSOFTFLOAT_FAST_INT64 $(SOFTFLOAT_OPTS) $(C_INCLUDES) -O2 -o $@
|
||||
==> MAKELIB = ar crs $@
|
||||
|
||||
==> OBJ = .o
|
||||
==> LIB = .a
|
||||
|
||||
==> OTHER_HEADERS =
|
||||
|
||||
.PHONY: all
|
||||
all: softfloat$(LIB)
|
||||
|
||||
OBJS_PRIMITIVES = \
|
||||
s_eq128$(OBJ) \
|
||||
s_le128$(OBJ) \
|
||||
s_lt128$(OBJ) \
|
||||
s_shortShiftLeft128$(OBJ) \
|
||||
s_shortShiftRight128$(OBJ) \
|
||||
s_shortShiftRightJam64$(OBJ) \
|
||||
s_shortShiftRightJam64Extra$(OBJ) \
|
||||
s_shortShiftRightJam128$(OBJ) \
|
||||
s_shortShiftRightJam128Extra$(OBJ) \
|
||||
s_shiftRightJam32$(OBJ) \
|
||||
s_shiftRightJam64$(OBJ) \
|
||||
s_shiftRightJam64Extra$(OBJ) \
|
||||
s_shiftRightJam128$(OBJ) \
|
||||
s_shiftRightJam128Extra$(OBJ) \
|
||||
s_shiftRightJam256M$(OBJ) \
|
||||
s_countLeadingZeros8$(OBJ) \
|
||||
s_countLeadingZeros16$(OBJ) \
|
||||
s_countLeadingZeros32$(OBJ) \
|
||||
s_countLeadingZeros64$(OBJ) \
|
||||
s_add128$(OBJ) \
|
||||
s_add256M$(OBJ) \
|
||||
s_sub128$(OBJ) \
|
||||
s_sub256M$(OBJ) \
|
||||
s_mul64ByShifted32To128$(OBJ) \
|
||||
s_mul64To128$(OBJ) \
|
||||
s_mul128By32$(OBJ) \
|
||||
s_mul128To256M$(OBJ) \
|
||||
s_approxRecip_1Ks$(OBJ) \
|
||||
s_approxRecip32_1$(OBJ) \
|
||||
s_approxRecipSqrt_1Ks$(OBJ) \
|
||||
s_approxRecipSqrt32_1$(OBJ) \
|
||||
|
||||
OBJS_SPECIALIZE = \
|
||||
softfloat_raiseFlags$(OBJ) \
|
||||
s_f16UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF16UI$(OBJ) \
|
||||
s_propagateNaNF16UI$(OBJ) \
|
||||
s_f32UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF32UI$(OBJ) \
|
||||
s_propagateNaNF32UI$(OBJ) \
|
||||
s_f64UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF64UI$(OBJ) \
|
||||
s_propagateNaNF64UI$(OBJ) \
|
||||
extF80M_isSignalingNaN$(OBJ) \
|
||||
s_extF80UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToExtF80UI$(OBJ) \
|
||||
s_propagateNaNExtF80UI$(OBJ) \
|
||||
f128M_isSignalingNaN$(OBJ) \
|
||||
s_f128UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF128UI$(OBJ) \
|
||||
s_propagateNaNF128UI$(OBJ) \
|
||||
|
||||
OBJS_OTHERS = \
|
||||
s_roundToUI32$(OBJ) \
|
||||
s_roundToUI64$(OBJ) \
|
||||
s_roundToI32$(OBJ) \
|
||||
s_roundToI64$(OBJ) \
|
||||
s_normSubnormalBF16Sig$(OBJ) \
|
||||
s_roundPackToBF16$(OBJ) \
|
||||
s_normSubnormalF16Sig$(OBJ) \
|
||||
s_roundPackToF16$(OBJ) \
|
||||
s_normRoundPackToF16$(OBJ) \
|
||||
s_addMagsF16$(OBJ) \
|
||||
s_subMagsF16$(OBJ) \
|
||||
s_mulAddF16$(OBJ) \
|
||||
s_normSubnormalF32Sig$(OBJ) \
|
||||
s_roundPackToF32$(OBJ) \
|
||||
s_normRoundPackToF32$(OBJ) \
|
||||
s_addMagsF32$(OBJ) \
|
||||
s_subMagsF32$(OBJ) \
|
||||
s_mulAddF32$(OBJ) \
|
||||
s_normSubnormalF64Sig$(OBJ) \
|
||||
s_roundPackToF64$(OBJ) \
|
||||
s_normRoundPackToF64$(OBJ) \
|
||||
s_addMagsF64$(OBJ) \
|
||||
s_subMagsF64$(OBJ) \
|
||||
s_mulAddF64$(OBJ) \
|
||||
s_normSubnormalExtF80Sig$(OBJ) \
|
||||
s_roundPackToExtF80$(OBJ) \
|
||||
s_normRoundPackToExtF80$(OBJ) \
|
||||
s_addMagsExtF80$(OBJ) \
|
||||
s_subMagsExtF80$(OBJ) \
|
||||
s_normSubnormalF128Sig$(OBJ) \
|
||||
s_roundPackToF128$(OBJ) \
|
||||
s_normRoundPackToF128$(OBJ) \
|
||||
s_addMagsF128$(OBJ) \
|
||||
s_subMagsF128$(OBJ) \
|
||||
s_mulAddF128$(OBJ) \
|
||||
softfloat_state$(OBJ) \
|
||||
ui32_to_f16$(OBJ) \
|
||||
ui32_to_f32$(OBJ) \
|
||||
ui32_to_f64$(OBJ) \
|
||||
ui32_to_extF80$(OBJ) \
|
||||
ui32_to_extF80M$(OBJ) \
|
||||
ui32_to_f128$(OBJ) \
|
||||
ui32_to_f128M$(OBJ) \
|
||||
ui64_to_f16$(OBJ) \
|
||||
ui64_to_f32$(OBJ) \
|
||||
ui64_to_f64$(OBJ) \
|
||||
ui64_to_extF80$(OBJ) \
|
||||
ui64_to_extF80M$(OBJ) \
|
||||
ui64_to_f128$(OBJ) \
|
||||
ui64_to_f128M$(OBJ) \
|
||||
i32_to_f16$(OBJ) \
|
||||
i32_to_f32$(OBJ) \
|
||||
i32_to_f64$(OBJ) \
|
||||
i32_to_extF80$(OBJ) \
|
||||
i32_to_extF80M$(OBJ) \
|
||||
i32_to_f128$(OBJ) \
|
||||
i32_to_f128M$(OBJ) \
|
||||
i64_to_f16$(OBJ) \
|
||||
i64_to_f32$(OBJ) \
|
||||
i64_to_f64$(OBJ) \
|
||||
i64_to_extF80$(OBJ) \
|
||||
i64_to_extF80M$(OBJ) \
|
||||
i64_to_f128$(OBJ) \
|
||||
i64_to_f128M$(OBJ) \
|
||||
bf16_isSignalingNaN$(OBJ) \
|
||||
bf16_to_f32$(OBJ) \
|
||||
f16_to_ui32$(OBJ) \
|
||||
f16_to_ui64$(OBJ) \
|
||||
f16_to_i32$(OBJ) \
|
||||
f16_to_i64$(OBJ) \
|
||||
f16_to_ui32_r_minMag$(OBJ) \
|
||||
f16_to_ui64_r_minMag$(OBJ) \
|
||||
f16_to_i32_r_minMag$(OBJ) \
|
||||
f16_to_i64_r_minMag$(OBJ) \
|
||||
f16_to_f32$(OBJ) \
|
||||
f16_to_f64$(OBJ) \
|
||||
f16_to_extF80$(OBJ) \
|
||||
f16_to_extF80M$(OBJ) \
|
||||
f16_to_f128$(OBJ) \
|
||||
f16_to_f128M$(OBJ) \
|
||||
f16_roundToInt$(OBJ) \
|
||||
f16_add$(OBJ) \
|
||||
f16_sub$(OBJ) \
|
||||
f16_mul$(OBJ) \
|
||||
f16_mulAdd$(OBJ) \
|
||||
f16_div$(OBJ) \
|
||||
f16_rem$(OBJ) \
|
||||
f16_sqrt$(OBJ) \
|
||||
f16_eq$(OBJ) \
|
||||
f16_le$(OBJ) \
|
||||
f16_lt$(OBJ) \
|
||||
f16_eq_signaling$(OBJ) \
|
||||
f16_le_quiet$(OBJ) \
|
||||
f16_lt_quiet$(OBJ) \
|
||||
f16_isSignalingNaN$(OBJ) \
|
||||
f32_to_ui32$(OBJ) \
|
||||
f32_to_ui64$(OBJ) \
|
||||
f32_to_i32$(OBJ) \
|
||||
f32_to_i64$(OBJ) \
|
||||
f32_to_ui32_r_minMag$(OBJ) \
|
||||
f32_to_ui64_r_minMag$(OBJ) \
|
||||
f32_to_i32_r_minMag$(OBJ) \
|
||||
f32_to_i64_r_minMag$(OBJ) \
|
||||
f32_to_bf16$(OBJ) \
|
||||
f32_to_f16$(OBJ) \
|
||||
f32_to_f64$(OBJ) \
|
||||
f32_to_extF80$(OBJ) \
|
||||
f32_to_extF80M$(OBJ) \
|
||||
f32_to_f128$(OBJ) \
|
||||
f32_to_f128M$(OBJ) \
|
||||
f32_roundToInt$(OBJ) \
|
||||
f32_add$(OBJ) \
|
||||
f32_sub$(OBJ) \
|
||||
f32_mul$(OBJ) \
|
||||
f32_mulAdd$(OBJ) \
|
||||
f32_div$(OBJ) \
|
||||
f32_rem$(OBJ) \
|
||||
f32_sqrt$(OBJ) \
|
||||
f32_eq$(OBJ) \
|
||||
f32_le$(OBJ) \
|
||||
f32_lt$(OBJ) \
|
||||
f32_eq_signaling$(OBJ) \
|
||||
f32_le_quiet$(OBJ) \
|
||||
f32_lt_quiet$(OBJ) \
|
||||
f32_isSignalingNaN$(OBJ) \
|
||||
f64_to_ui32$(OBJ) \
|
||||
f64_to_ui64$(OBJ) \
|
||||
f64_to_i32$(OBJ) \
|
||||
f64_to_i64$(OBJ) \
|
||||
f64_to_ui32_r_minMag$(OBJ) \
|
||||
f64_to_ui64_r_minMag$(OBJ) \
|
||||
f64_to_i32_r_minMag$(OBJ) \
|
||||
f64_to_i64_r_minMag$(OBJ) \
|
||||
f64_to_f16$(OBJ) \
|
||||
f64_to_f32$(OBJ) \
|
||||
f64_to_extF80$(OBJ) \
|
||||
f64_to_extF80M$(OBJ) \
|
||||
f64_to_f128$(OBJ) \
|
||||
f64_to_f128M$(OBJ) \
|
||||
f64_roundToInt$(OBJ) \
|
||||
f64_add$(OBJ) \
|
||||
f64_sub$(OBJ) \
|
||||
f64_mul$(OBJ) \
|
||||
f64_mulAdd$(OBJ) \
|
||||
f64_div$(OBJ) \
|
||||
f64_rem$(OBJ) \
|
||||
f64_sqrt$(OBJ) \
|
||||
f64_eq$(OBJ) \
|
||||
f64_le$(OBJ) \
|
||||
f64_lt$(OBJ) \
|
||||
f64_eq_signaling$(OBJ) \
|
||||
f64_le_quiet$(OBJ) \
|
||||
f64_lt_quiet$(OBJ) \
|
||||
f64_isSignalingNaN$(OBJ) \
|
||||
extF80_to_ui32$(OBJ) \
|
||||
extF80_to_ui64$(OBJ) \
|
||||
extF80_to_i32$(OBJ) \
|
||||
extF80_to_i64$(OBJ) \
|
||||
extF80_to_ui32_r_minMag$(OBJ) \
|
||||
extF80_to_ui64_r_minMag$(OBJ) \
|
||||
extF80_to_i32_r_minMag$(OBJ) \
|
||||
extF80_to_i64_r_minMag$(OBJ) \
|
||||
extF80_to_f16$(OBJ) \
|
||||
extF80_to_f32$(OBJ) \
|
||||
extF80_to_f64$(OBJ) \
|
||||
extF80_to_f128$(OBJ) \
|
||||
extF80_roundToInt$(OBJ) \
|
||||
extF80_add$(OBJ) \
|
||||
extF80_sub$(OBJ) \
|
||||
extF80_mul$(OBJ) \
|
||||
extF80_div$(OBJ) \
|
||||
extF80_rem$(OBJ) \
|
||||
extF80_sqrt$(OBJ) \
|
||||
extF80_eq$(OBJ) \
|
||||
extF80_le$(OBJ) \
|
||||
extF80_lt$(OBJ) \
|
||||
extF80_eq_signaling$(OBJ) \
|
||||
extF80_le_quiet$(OBJ) \
|
||||
extF80_lt_quiet$(OBJ) \
|
||||
extF80_isSignalingNaN$(OBJ) \
|
||||
extF80M_to_ui32$(OBJ) \
|
||||
extF80M_to_ui64$(OBJ) \
|
||||
extF80M_to_i32$(OBJ) \
|
||||
extF80M_to_i64$(OBJ) \
|
||||
extF80M_to_ui32_r_minMag$(OBJ) \
|
||||
extF80M_to_ui64_r_minMag$(OBJ) \
|
||||
extF80M_to_i32_r_minMag$(OBJ) \
|
||||
extF80M_to_i64_r_minMag$(OBJ) \
|
||||
extF80M_to_f16$(OBJ) \
|
||||
extF80M_to_f32$(OBJ) \
|
||||
extF80M_to_f64$(OBJ) \
|
||||
extF80M_to_f128M$(OBJ) \
|
||||
extF80M_roundToInt$(OBJ) \
|
||||
extF80M_add$(OBJ) \
|
||||
extF80M_sub$(OBJ) \
|
||||
extF80M_mul$(OBJ) \
|
||||
extF80M_div$(OBJ) \
|
||||
extF80M_rem$(OBJ) \
|
||||
extF80M_sqrt$(OBJ) \
|
||||
extF80M_eq$(OBJ) \
|
||||
extF80M_le$(OBJ) \
|
||||
extF80M_lt$(OBJ) \
|
||||
extF80M_eq_signaling$(OBJ) \
|
||||
extF80M_le_quiet$(OBJ) \
|
||||
extF80M_lt_quiet$(OBJ) \
|
||||
f128_to_ui32$(OBJ) \
|
||||
f128_to_ui64$(OBJ) \
|
||||
f128_to_i32$(OBJ) \
|
||||
f128_to_i64$(OBJ) \
|
||||
f128_to_ui32_r_minMag$(OBJ) \
|
||||
f128_to_ui64_r_minMag$(OBJ) \
|
||||
f128_to_i32_r_minMag$(OBJ) \
|
||||
f128_to_i64_r_minMag$(OBJ) \
|
||||
f128_to_f16$(OBJ) \
|
||||
f128_to_f32$(OBJ) \
|
||||
f128_to_extF80$(OBJ) \
|
||||
f128_to_f64$(OBJ) \
|
||||
f128_roundToInt$(OBJ) \
|
||||
f128_add$(OBJ) \
|
||||
f128_sub$(OBJ) \
|
||||
f128_mul$(OBJ) \
|
||||
f128_mulAdd$(OBJ) \
|
||||
f128_div$(OBJ) \
|
||||
f128_rem$(OBJ) \
|
||||
f128_sqrt$(OBJ) \
|
||||
f128_eq$(OBJ) \
|
||||
f128_le$(OBJ) \
|
||||
f128_lt$(OBJ) \
|
||||
f128_eq_signaling$(OBJ) \
|
||||
f128_le_quiet$(OBJ) \
|
||||
f128_lt_quiet$(OBJ) \
|
||||
f128_isSignalingNaN$(OBJ) \
|
||||
f128M_to_ui32$(OBJ) \
|
||||
f128M_to_ui64$(OBJ) \
|
||||
f128M_to_i32$(OBJ) \
|
||||
f128M_to_i64$(OBJ) \
|
||||
f128M_to_ui32_r_minMag$(OBJ) \
|
||||
f128M_to_ui64_r_minMag$(OBJ) \
|
||||
f128M_to_i32_r_minMag$(OBJ) \
|
||||
f128M_to_i64_r_minMag$(OBJ) \
|
||||
f128M_to_f16$(OBJ) \
|
||||
f128M_to_f32$(OBJ) \
|
||||
f128M_to_extF80M$(OBJ) \
|
||||
f128M_to_f64$(OBJ) \
|
||||
f128M_roundToInt$(OBJ) \
|
||||
f128M_add$(OBJ) \
|
||||
f128M_sub$(OBJ) \
|
||||
f128M_mul$(OBJ) \
|
||||
f128M_mulAdd$(OBJ) \
|
||||
f128M_div$(OBJ) \
|
||||
f128M_rem$(OBJ) \
|
||||
f128M_sqrt$(OBJ) \
|
||||
f128M_eq$(OBJ) \
|
||||
f128M_le$(OBJ) \
|
||||
f128M_lt$(OBJ) \
|
||||
f128M_eq_signaling$(OBJ) \
|
||||
f128M_le_quiet$(OBJ) \
|
||||
f128M_lt_quiet$(OBJ) \
|
||||
|
||||
OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS)
|
||||
|
||||
$(OBJS_ALL): \
|
||||
$(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \
|
||||
$(SOURCE_DIR)/include/primitives.h
|
||||
$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \
|
||||
$(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \
|
||||
$(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \
|
||||
$(SOURCE_DIR)/include/softfloat.h
|
||||
|
||||
$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c
|
||||
$(COMPILE_C) $(SOURCE_DIR)/$*.c
|
||||
|
||||
$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c
|
||||
$(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c
|
||||
|
||||
softfloat$(LIB): $(OBJS_ALL)
|
||||
$(DELETE) $@
|
||||
$(MAKELIB) $^
|
||||
|
||||
.PHONY: clean
|
||||
clean:
|
||||
$(DELETE) $(OBJS_ALL) softfloat$(LIB)
|
||||
|
||||
|
@ -1,49 +1,50 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C header template is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
// Edit lines marked with `==>'. See "SoftFloat-source.html".
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
== > #define LITTLEENDIAN 1
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
== > #define INLINE inline
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
== > #define THREAD_LOCAL _Thread_local
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C header template is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
// Edit lines marked with `==>'. See "SoftFloat-source.html".
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
==> #define LITTLEENDIAN 1
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
==> #define INLINE inline
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
==> #define THREAD_LOCAL _Thread_local
|
||||
|
||||
|
@ -1,325 +1,325 @@
|
||||
|
||||
#=============================================================================
|
||||
#
|
||||
# This Makefile template is part of the SoftFloat IEEE Floating-Point
|
||||
# Arithmetic Package, Release 3e, by John R. Hauser.
|
||||
#
|
||||
# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
|
||||
# University of California. All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions are met:
|
||||
#
|
||||
# 1. Redistributions of source code must retain the above copyright notice,
|
||||
# this list of conditions, and the following disclaimer.
|
||||
#
|
||||
# 2. Redistributions in binary form must reproduce the above copyright
|
||||
# notice, this list of conditions, and the following disclaimer in the
|
||||
# documentation and/or other materials provided with the distribution.
|
||||
#
|
||||
# 3. Neither the name of the University nor the names of its contributors
|
||||
# may be used to endorse or promote products derived from this software
|
||||
# without specific prior written permission.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
# DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
#
|
||||
#=============================================================================
|
||||
|
||||
# Edit lines marked with `==>'. See "SoftFloat-source.html".
|
||||
|
||||
==> SOURCE_DIR ?= ../../source
|
||||
==> SPECIALIZE_TYPE ?= 8086
|
||||
|
||||
==> SOFTFLOAT_OPTS ?= \
|
||||
==> -DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \
|
||||
==> -DSOFTFLOAT_FAST_DIV64TO32
|
||||
|
||||
==> DELETE = rm -f
|
||||
==> C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include
|
||||
==> COMPILE_C = cc -c $(SOFTFLOAT_OPTS) $(C_INCLUDES) -O2 -o $@
|
||||
==> MAKELIB = ar crs $@
|
||||
|
||||
==> OBJ = .o
|
||||
==> LIB = .a
|
||||
|
||||
==> OTHER_HEADERS =
|
||||
|
||||
.PHONY: all
|
||||
all: softfloat$(LIB)
|
||||
|
||||
OBJS_PRIMITIVES = \
|
||||
s_compare96M$(OBJ) \
|
||||
s_compare128M$(OBJ) \
|
||||
s_shortShiftLeft64To96M$(OBJ) \
|
||||
s_shortShiftLeftM$(OBJ) \
|
||||
s_shiftLeftM$(OBJ) \
|
||||
s_shortShiftRightM$(OBJ) \
|
||||
s_shortShiftRightJam64$(OBJ) \
|
||||
s_shortShiftRightJamM$(OBJ) \
|
||||
s_shiftRightJam32$(OBJ) \
|
||||
s_shiftRightJam64$(OBJ) \
|
||||
s_shiftRightJamM$(OBJ) \
|
||||
s_shiftRightM$(OBJ) \
|
||||
s_countLeadingZeros8$(OBJ) \
|
||||
s_countLeadingZeros16$(OBJ) \
|
||||
s_countLeadingZeros32$(OBJ) \
|
||||
s_countLeadingZeros64$(OBJ) \
|
||||
s_addM$(OBJ) \
|
||||
s_addCarryM$(OBJ) \
|
||||
s_addComplCarryM$(OBJ) \
|
||||
s_negXM$(OBJ) \
|
||||
s_sub1XM$(OBJ) \
|
||||
s_subM$(OBJ) \
|
||||
s_mul64To128M$(OBJ) \
|
||||
s_mul128MTo256M$(OBJ) \
|
||||
s_approxRecip_1Ks$(OBJ) \
|
||||
s_approxRecip32_1$(OBJ) \
|
||||
s_approxRecipSqrt_1Ks$(OBJ) \
|
||||
s_approxRecipSqrt32_1$(OBJ) \
|
||||
s_remStepMBy32$(OBJ) \
|
||||
|
||||
OBJS_SPECIALIZE = \
|
||||
softfloat_raiseFlags$(OBJ) \
|
||||
s_f16UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF16UI$(OBJ) \
|
||||
s_propagateNaNF16UI$(OBJ) \
|
||||
s_f32UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF32UI$(OBJ) \
|
||||
s_propagateNaNF32UI$(OBJ) \
|
||||
s_f64UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF64UI$(OBJ) \
|
||||
s_propagateNaNF64UI$(OBJ) \
|
||||
extF80M_isSignalingNaN$(OBJ) \
|
||||
s_extF80MToCommonNaN$(OBJ) \
|
||||
s_commonNaNToExtF80M$(OBJ) \
|
||||
s_propagateNaNExtF80M$(OBJ) \
|
||||
f128M_isSignalingNaN$(OBJ) \
|
||||
s_f128MToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF128M$(OBJ) \
|
||||
s_propagateNaNF128M$(OBJ) \
|
||||
|
||||
OBJS_OTHERS = \
|
||||
s_roundToUI32$(OBJ) \
|
||||
s_roundMToUI64$(OBJ) \
|
||||
s_roundToI32$(OBJ) \
|
||||
s_roundMToI64$(OBJ) \
|
||||
s_normSubnormalF16Sig$(OBJ) \
|
||||
s_roundPackToF16$(OBJ) \
|
||||
s_normRoundPackToF16$(OBJ) \
|
||||
s_addMagsF16$(OBJ) \
|
||||
s_subMagsF16$(OBJ) \
|
||||
s_mulAddF16$(OBJ) \
|
||||
s_normSubnormalF32Sig$(OBJ) \
|
||||
s_roundPackToF32$(OBJ) \
|
||||
s_normRoundPackToF32$(OBJ) \
|
||||
s_addMagsF32$(OBJ) \
|
||||
s_subMagsF32$(OBJ) \
|
||||
s_mulAddF32$(OBJ) \
|
||||
s_normSubnormalF64Sig$(OBJ) \
|
||||
s_roundPackToF64$(OBJ) \
|
||||
s_normRoundPackToF64$(OBJ) \
|
||||
s_addMagsF64$(OBJ) \
|
||||
s_subMagsF64$(OBJ) \
|
||||
s_mulAddF64$(OBJ) \
|
||||
s_tryPropagateNaNExtF80M$(OBJ) \
|
||||
s_invalidExtF80M$(OBJ) \
|
||||
s_normExtF80SigM$(OBJ) \
|
||||
s_roundPackMToExtF80M$(OBJ) \
|
||||
s_normRoundPackMToExtF80M$(OBJ) \
|
||||
s_addExtF80M$(OBJ) \
|
||||
s_compareNonnormExtF80M$(OBJ) \
|
||||
s_isNaNF128M$(OBJ) \
|
||||
s_tryPropagateNaNF128M$(OBJ) \
|
||||
s_invalidF128M$(OBJ) \
|
||||
s_shiftNormSigF128M$(OBJ) \
|
||||
s_roundPackMToF128M$(OBJ) \
|
||||
s_normRoundPackMToF128M$(OBJ) \
|
||||
s_addF128M$(OBJ) \
|
||||
s_mulAddF128M$(OBJ) \
|
||||
softfloat_state$(OBJ) \
|
||||
ui32_to_f16$(OBJ) \
|
||||
ui32_to_f32$(OBJ) \
|
||||
ui32_to_f64$(OBJ) \
|
||||
ui32_to_extF80M$(OBJ) \
|
||||
ui32_to_f128M$(OBJ) \
|
||||
ui64_to_f16$(OBJ) \
|
||||
ui64_to_f32$(OBJ) \
|
||||
ui64_to_f64$(OBJ) \
|
||||
ui64_to_extF80M$(OBJ) \
|
||||
ui64_to_f128M$(OBJ) \
|
||||
i32_to_f16$(OBJ) \
|
||||
i32_to_f32$(OBJ) \
|
||||
i32_to_f64$(OBJ) \
|
||||
i32_to_extF80M$(OBJ) \
|
||||
i32_to_f128M$(OBJ) \
|
||||
i64_to_f16$(OBJ) \
|
||||
i64_to_f32$(OBJ) \
|
||||
i64_to_f64$(OBJ) \
|
||||
i64_to_extF80M$(OBJ) \
|
||||
i64_to_f128M$(OBJ) \
|
||||
f16_to_ui32$(OBJ) \
|
||||
f16_to_ui64$(OBJ) \
|
||||
f16_to_i32$(OBJ) \
|
||||
f16_to_i64$(OBJ) \
|
||||
f16_to_ui32_r_minMag$(OBJ) \
|
||||
f16_to_ui64_r_minMag$(OBJ) \
|
||||
f16_to_i32_r_minMag$(OBJ) \
|
||||
f16_to_i64_r_minMag$(OBJ) \
|
||||
f16_to_f32$(OBJ) \
|
||||
f16_to_f64$(OBJ) \
|
||||
f16_to_extF80M$(OBJ) \
|
||||
f16_to_f128M$(OBJ) \
|
||||
f16_roundToInt$(OBJ) \
|
||||
f16_add$(OBJ) \
|
||||
f16_sub$(OBJ) \
|
||||
f16_mul$(OBJ) \
|
||||
f16_mulAdd$(OBJ) \
|
||||
f16_div$(OBJ) \
|
||||
f16_rem$(OBJ) \
|
||||
f16_sqrt$(OBJ) \
|
||||
f16_eq$(OBJ) \
|
||||
f16_le$(OBJ) \
|
||||
f16_lt$(OBJ) \
|
||||
f16_eq_signaling$(OBJ) \
|
||||
f16_le_quiet$(OBJ) \
|
||||
f16_lt_quiet$(OBJ) \
|
||||
f16_isSignalingNaN$(OBJ) \
|
||||
f32_to_ui32$(OBJ) \
|
||||
f32_to_ui64$(OBJ) \
|
||||
f32_to_i32$(OBJ) \
|
||||
f32_to_i64$(OBJ) \
|
||||
f32_to_ui32_r_minMag$(OBJ) \
|
||||
f32_to_ui64_r_minMag$(OBJ) \
|
||||
f32_to_i32_r_minMag$(OBJ) \
|
||||
f32_to_i64_r_minMag$(OBJ) \
|
||||
f32_to_f16$(OBJ) \
|
||||
f32_to_f64$(OBJ) \
|
||||
f32_to_extF80M$(OBJ) \
|
||||
f32_to_f128M$(OBJ) \
|
||||
f32_roundToInt$(OBJ) \
|
||||
f32_add$(OBJ) \
|
||||
f32_sub$(OBJ) \
|
||||
f32_mul$(OBJ) \
|
||||
f32_mulAdd$(OBJ) \
|
||||
f32_div$(OBJ) \
|
||||
f32_rem$(OBJ) \
|
||||
f32_sqrt$(OBJ) \
|
||||
f32_eq$(OBJ) \
|
||||
f32_le$(OBJ) \
|
||||
f32_lt$(OBJ) \
|
||||
f32_eq_signaling$(OBJ) \
|
||||
f32_le_quiet$(OBJ) \
|
||||
f32_lt_quiet$(OBJ) \
|
||||
f32_isSignalingNaN$(OBJ) \
|
||||
f64_to_ui32$(OBJ) \
|
||||
f64_to_ui64$(OBJ) \
|
||||
f64_to_i32$(OBJ) \
|
||||
f64_to_i64$(OBJ) \
|
||||
f64_to_ui32_r_minMag$(OBJ) \
|
||||
f64_to_ui64_r_minMag$(OBJ) \
|
||||
f64_to_i32_r_minMag$(OBJ) \
|
||||
f64_to_i64_r_minMag$(OBJ) \
|
||||
f64_to_f16$(OBJ) \
|
||||
f64_to_f32$(OBJ) \
|
||||
f64_to_extF80M$(OBJ) \
|
||||
f64_to_f128M$(OBJ) \
|
||||
f64_roundToInt$(OBJ) \
|
||||
f64_add$(OBJ) \
|
||||
f64_sub$(OBJ) \
|
||||
f64_mul$(OBJ) \
|
||||
f64_mulAdd$(OBJ) \
|
||||
f64_div$(OBJ) \
|
||||
f64_rem$(OBJ) \
|
||||
f64_sqrt$(OBJ) \
|
||||
f64_eq$(OBJ) \
|
||||
f64_le$(OBJ) \
|
||||
f64_lt$(OBJ) \
|
||||
f64_eq_signaling$(OBJ) \
|
||||
f64_le_quiet$(OBJ) \
|
||||
f64_lt_quiet$(OBJ) \
|
||||
f64_isSignalingNaN$(OBJ) \
|
||||
extF80M_to_ui32$(OBJ) \
|
||||
extF80M_to_ui64$(OBJ) \
|
||||
extF80M_to_i32$(OBJ) \
|
||||
extF80M_to_i64$(OBJ) \
|
||||
extF80M_to_ui32_r_minMag$(OBJ) \
|
||||
extF80M_to_ui64_r_minMag$(OBJ) \
|
||||
extF80M_to_i32_r_minMag$(OBJ) \
|
||||
extF80M_to_i64_r_minMag$(OBJ) \
|
||||
extF80M_to_f16$(OBJ) \
|
||||
extF80M_to_f32$(OBJ) \
|
||||
extF80M_to_f64$(OBJ) \
|
||||
extF80M_to_f128M$(OBJ) \
|
||||
extF80M_roundToInt$(OBJ) \
|
||||
extF80M_add$(OBJ) \
|
||||
extF80M_sub$(OBJ) \
|
||||
extF80M_mul$(OBJ) \
|
||||
extF80M_div$(OBJ) \
|
||||
extF80M_rem$(OBJ) \
|
||||
extF80M_sqrt$(OBJ) \
|
||||
extF80M_eq$(OBJ) \
|
||||
extF80M_le$(OBJ) \
|
||||
extF80M_lt$(OBJ) \
|
||||
extF80M_eq_signaling$(OBJ) \
|
||||
extF80M_le_quiet$(OBJ) \
|
||||
extF80M_lt_quiet$(OBJ) \
|
||||
f128M_to_ui32$(OBJ) \
|
||||
f128M_to_ui64$(OBJ) \
|
||||
f128M_to_i32$(OBJ) \
|
||||
f128M_to_i64$(OBJ) \
|
||||
f128M_to_ui32_r_minMag$(OBJ) \
|
||||
f128M_to_ui64_r_minMag$(OBJ) \
|
||||
f128M_to_i32_r_minMag$(OBJ) \
|
||||
f128M_to_i64_r_minMag$(OBJ) \
|
||||
f128M_to_f16$(OBJ) \
|
||||
f128M_to_f32$(OBJ) \
|
||||
f128M_to_f64$(OBJ) \
|
||||
f128M_to_extF80M$(OBJ) \
|
||||
f128M_roundToInt$(OBJ) \
|
||||
f128M_add$(OBJ) \
|
||||
f128M_sub$(OBJ) \
|
||||
f128M_mul$(OBJ) \
|
||||
f128M_mulAdd$(OBJ) \
|
||||
f128M_div$(OBJ) \
|
||||
f128M_rem$(OBJ) \
|
||||
f128M_sqrt$(OBJ) \
|
||||
f128M_eq$(OBJ) \
|
||||
f128M_le$(OBJ) \
|
||||
f128M_lt$(OBJ) \
|
||||
f128M_eq_signaling$(OBJ) \
|
||||
f128M_le_quiet$(OBJ) \
|
||||
f128M_lt_quiet$(OBJ) \
|
||||
|
||||
OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS)
|
||||
|
||||
$(OBJS_ALL): \
|
||||
$(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \
|
||||
$(SOURCE_DIR)/include/primitives.h
|
||||
$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \
|
||||
$(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \
|
||||
$(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \
|
||||
$(SOURCE_DIR)/include/softfloat.h
|
||||
|
||||
$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c
|
||||
$(COMPILE_C) $(SOURCE_DIR)/$*.c
|
||||
|
||||
$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c
|
||||
$(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c
|
||||
|
||||
softfloat$(LIB): $(OBJS_ALL)
|
||||
$(DELETE) $@
|
||||
$(MAKELIB) $^
|
||||
|
||||
.PHONY: clean
|
||||
clean:
|
||||
$(DELETE) $(OBJS_ALL) softfloat$(LIB)
|
||||
|
||||
|
||||
#=============================================================================
|
||||
#
|
||||
# This Makefile template is part of the SoftFloat IEEE Floating-Point
|
||||
# Arithmetic Package, Release 3e, by John R. Hauser.
|
||||
#
|
||||
# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
|
||||
# University of California. All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions are met:
|
||||
#
|
||||
# 1. Redistributions of source code must retain the above copyright notice,
|
||||
# this list of conditions, and the following disclaimer.
|
||||
#
|
||||
# 2. Redistributions in binary form must reproduce the above copyright
|
||||
# notice, this list of conditions, and the following disclaimer in the
|
||||
# documentation and/or other materials provided with the distribution.
|
||||
#
|
||||
# 3. Neither the name of the University nor the names of its contributors
|
||||
# may be used to endorse or promote products derived from this software
|
||||
# without specific prior written permission.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
# DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
#
|
||||
#=============================================================================
|
||||
|
||||
# Edit lines marked with `==>'. See "SoftFloat-source.html".
|
||||
|
||||
==> SOURCE_DIR ?= ../../source
|
||||
==> SPECIALIZE_TYPE ?= 8086
|
||||
|
||||
==> SOFTFLOAT_OPTS ?= \
|
||||
==> -DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \
|
||||
==> -DSOFTFLOAT_FAST_DIV64TO32
|
||||
|
||||
==> DELETE = rm -f
|
||||
==> C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include
|
||||
==> COMPILE_C = cc -c $(SOFTFLOAT_OPTS) $(C_INCLUDES) -O2 -o $@
|
||||
==> MAKELIB = ar crs $@
|
||||
|
||||
==> OBJ = .o
|
||||
==> LIB = .a
|
||||
|
||||
==> OTHER_HEADERS =
|
||||
|
||||
.PHONY: all
|
||||
all: softfloat$(LIB)
|
||||
|
||||
OBJS_PRIMITIVES = \
|
||||
s_compare96M$(OBJ) \
|
||||
s_compare128M$(OBJ) \
|
||||
s_shortShiftLeft64To96M$(OBJ) \
|
||||
s_shortShiftLeftM$(OBJ) \
|
||||
s_shiftLeftM$(OBJ) \
|
||||
s_shortShiftRightM$(OBJ) \
|
||||
s_shortShiftRightJam64$(OBJ) \
|
||||
s_shortShiftRightJamM$(OBJ) \
|
||||
s_shiftRightJam32$(OBJ) \
|
||||
s_shiftRightJam64$(OBJ) \
|
||||
s_shiftRightJamM$(OBJ) \
|
||||
s_shiftRightM$(OBJ) \
|
||||
s_countLeadingZeros8$(OBJ) \
|
||||
s_countLeadingZeros16$(OBJ) \
|
||||
s_countLeadingZeros32$(OBJ) \
|
||||
s_countLeadingZeros64$(OBJ) \
|
||||
s_addM$(OBJ) \
|
||||
s_addCarryM$(OBJ) \
|
||||
s_addComplCarryM$(OBJ) \
|
||||
s_negXM$(OBJ) \
|
||||
s_sub1XM$(OBJ) \
|
||||
s_subM$(OBJ) \
|
||||
s_mul64To128M$(OBJ) \
|
||||
s_mul128MTo256M$(OBJ) \
|
||||
s_approxRecip_1Ks$(OBJ) \
|
||||
s_approxRecip32_1$(OBJ) \
|
||||
s_approxRecipSqrt_1Ks$(OBJ) \
|
||||
s_approxRecipSqrt32_1$(OBJ) \
|
||||
s_remStepMBy32$(OBJ) \
|
||||
|
||||
OBJS_SPECIALIZE = \
|
||||
softfloat_raiseFlags$(OBJ) \
|
||||
s_f16UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF16UI$(OBJ) \
|
||||
s_propagateNaNF16UI$(OBJ) \
|
||||
s_f32UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF32UI$(OBJ) \
|
||||
s_propagateNaNF32UI$(OBJ) \
|
||||
s_f64UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF64UI$(OBJ) \
|
||||
s_propagateNaNF64UI$(OBJ) \
|
||||
extF80M_isSignalingNaN$(OBJ) \
|
||||
s_extF80MToCommonNaN$(OBJ) \
|
||||
s_commonNaNToExtF80M$(OBJ) \
|
||||
s_propagateNaNExtF80M$(OBJ) \
|
||||
f128M_isSignalingNaN$(OBJ) \
|
||||
s_f128MToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF128M$(OBJ) \
|
||||
s_propagateNaNF128M$(OBJ) \
|
||||
|
||||
OBJS_OTHERS = \
|
||||
s_roundToUI32$(OBJ) \
|
||||
s_roundMToUI64$(OBJ) \
|
||||
s_roundToI32$(OBJ) \
|
||||
s_roundMToI64$(OBJ) \
|
||||
s_normSubnormalF16Sig$(OBJ) \
|
||||
s_roundPackToF16$(OBJ) \
|
||||
s_normRoundPackToF16$(OBJ) \
|
||||
s_addMagsF16$(OBJ) \
|
||||
s_subMagsF16$(OBJ) \
|
||||
s_mulAddF16$(OBJ) \
|
||||
s_normSubnormalF32Sig$(OBJ) \
|
||||
s_roundPackToF32$(OBJ) \
|
||||
s_normRoundPackToF32$(OBJ) \
|
||||
s_addMagsF32$(OBJ) \
|
||||
s_subMagsF32$(OBJ) \
|
||||
s_mulAddF32$(OBJ) \
|
||||
s_normSubnormalF64Sig$(OBJ) \
|
||||
s_roundPackToF64$(OBJ) \
|
||||
s_normRoundPackToF64$(OBJ) \
|
||||
s_addMagsF64$(OBJ) \
|
||||
s_subMagsF64$(OBJ) \
|
||||
s_mulAddF64$(OBJ) \
|
||||
s_tryPropagateNaNExtF80M$(OBJ) \
|
||||
s_invalidExtF80M$(OBJ) \
|
||||
s_normExtF80SigM$(OBJ) \
|
||||
s_roundPackMToExtF80M$(OBJ) \
|
||||
s_normRoundPackMToExtF80M$(OBJ) \
|
||||
s_addExtF80M$(OBJ) \
|
||||
s_compareNonnormExtF80M$(OBJ) \
|
||||
s_isNaNF128M$(OBJ) \
|
||||
s_tryPropagateNaNF128M$(OBJ) \
|
||||
s_invalidF128M$(OBJ) \
|
||||
s_shiftNormSigF128M$(OBJ) \
|
||||
s_roundPackMToF128M$(OBJ) \
|
||||
s_normRoundPackMToF128M$(OBJ) \
|
||||
s_addF128M$(OBJ) \
|
||||
s_mulAddF128M$(OBJ) \
|
||||
softfloat_state$(OBJ) \
|
||||
ui32_to_f16$(OBJ) \
|
||||
ui32_to_f32$(OBJ) \
|
||||
ui32_to_f64$(OBJ) \
|
||||
ui32_to_extF80M$(OBJ) \
|
||||
ui32_to_f128M$(OBJ) \
|
||||
ui64_to_f16$(OBJ) \
|
||||
ui64_to_f32$(OBJ) \
|
||||
ui64_to_f64$(OBJ) \
|
||||
ui64_to_extF80M$(OBJ) \
|
||||
ui64_to_f128M$(OBJ) \
|
||||
i32_to_f16$(OBJ) \
|
||||
i32_to_f32$(OBJ) \
|
||||
i32_to_f64$(OBJ) \
|
||||
i32_to_extF80M$(OBJ) \
|
||||
i32_to_f128M$(OBJ) \
|
||||
i64_to_f16$(OBJ) \
|
||||
i64_to_f32$(OBJ) \
|
||||
i64_to_f64$(OBJ) \
|
||||
i64_to_extF80M$(OBJ) \
|
||||
i64_to_f128M$(OBJ) \
|
||||
f16_to_ui32$(OBJ) \
|
||||
f16_to_ui64$(OBJ) \
|
||||
f16_to_i32$(OBJ) \
|
||||
f16_to_i64$(OBJ) \
|
||||
f16_to_ui32_r_minMag$(OBJ) \
|
||||
f16_to_ui64_r_minMag$(OBJ) \
|
||||
f16_to_i32_r_minMag$(OBJ) \
|
||||
f16_to_i64_r_minMag$(OBJ) \
|
||||
f16_to_f32$(OBJ) \
|
||||
f16_to_f64$(OBJ) \
|
||||
f16_to_extF80M$(OBJ) \
|
||||
f16_to_f128M$(OBJ) \
|
||||
f16_roundToInt$(OBJ) \
|
||||
f16_add$(OBJ) \
|
||||
f16_sub$(OBJ) \
|
||||
f16_mul$(OBJ) \
|
||||
f16_mulAdd$(OBJ) \
|
||||
f16_div$(OBJ) \
|
||||
f16_rem$(OBJ) \
|
||||
f16_sqrt$(OBJ) \
|
||||
f16_eq$(OBJ) \
|
||||
f16_le$(OBJ) \
|
||||
f16_lt$(OBJ) \
|
||||
f16_eq_signaling$(OBJ) \
|
||||
f16_le_quiet$(OBJ) \
|
||||
f16_lt_quiet$(OBJ) \
|
||||
f16_isSignalingNaN$(OBJ) \
|
||||
f32_to_ui32$(OBJ) \
|
||||
f32_to_ui64$(OBJ) \
|
||||
f32_to_i32$(OBJ) \
|
||||
f32_to_i64$(OBJ) \
|
||||
f32_to_ui32_r_minMag$(OBJ) \
|
||||
f32_to_ui64_r_minMag$(OBJ) \
|
||||
f32_to_i32_r_minMag$(OBJ) \
|
||||
f32_to_i64_r_minMag$(OBJ) \
|
||||
f32_to_f16$(OBJ) \
|
||||
f32_to_f64$(OBJ) \
|
||||
f32_to_extF80M$(OBJ) \
|
||||
f32_to_f128M$(OBJ) \
|
||||
f32_roundToInt$(OBJ) \
|
||||
f32_add$(OBJ) \
|
||||
f32_sub$(OBJ) \
|
||||
f32_mul$(OBJ) \
|
||||
f32_mulAdd$(OBJ) \
|
||||
f32_div$(OBJ) \
|
||||
f32_rem$(OBJ) \
|
||||
f32_sqrt$(OBJ) \
|
||||
f32_eq$(OBJ) \
|
||||
f32_le$(OBJ) \
|
||||
f32_lt$(OBJ) \
|
||||
f32_eq_signaling$(OBJ) \
|
||||
f32_le_quiet$(OBJ) \
|
||||
f32_lt_quiet$(OBJ) \
|
||||
f32_isSignalingNaN$(OBJ) \
|
||||
f64_to_ui32$(OBJ) \
|
||||
f64_to_ui64$(OBJ) \
|
||||
f64_to_i32$(OBJ) \
|
||||
f64_to_i64$(OBJ) \
|
||||
f64_to_ui32_r_minMag$(OBJ) \
|
||||
f64_to_ui64_r_minMag$(OBJ) \
|
||||
f64_to_i32_r_minMag$(OBJ) \
|
||||
f64_to_i64_r_minMag$(OBJ) \
|
||||
f64_to_f16$(OBJ) \
|
||||
f64_to_f32$(OBJ) \
|
||||
f64_to_extF80M$(OBJ) \
|
||||
f64_to_f128M$(OBJ) \
|
||||
f64_roundToInt$(OBJ) \
|
||||
f64_add$(OBJ) \
|
||||
f64_sub$(OBJ) \
|
||||
f64_mul$(OBJ) \
|
||||
f64_mulAdd$(OBJ) \
|
||||
f64_div$(OBJ) \
|
||||
f64_rem$(OBJ) \
|
||||
f64_sqrt$(OBJ) \
|
||||
f64_eq$(OBJ) \
|
||||
f64_le$(OBJ) \
|
||||
f64_lt$(OBJ) \
|
||||
f64_eq_signaling$(OBJ) \
|
||||
f64_le_quiet$(OBJ) \
|
||||
f64_lt_quiet$(OBJ) \
|
||||
f64_isSignalingNaN$(OBJ) \
|
||||
extF80M_to_ui32$(OBJ) \
|
||||
extF80M_to_ui64$(OBJ) \
|
||||
extF80M_to_i32$(OBJ) \
|
||||
extF80M_to_i64$(OBJ) \
|
||||
extF80M_to_ui32_r_minMag$(OBJ) \
|
||||
extF80M_to_ui64_r_minMag$(OBJ) \
|
||||
extF80M_to_i32_r_minMag$(OBJ) \
|
||||
extF80M_to_i64_r_minMag$(OBJ) \
|
||||
extF80M_to_f16$(OBJ) \
|
||||
extF80M_to_f32$(OBJ) \
|
||||
extF80M_to_f64$(OBJ) \
|
||||
extF80M_to_f128M$(OBJ) \
|
||||
extF80M_roundToInt$(OBJ) \
|
||||
extF80M_add$(OBJ) \
|
||||
extF80M_sub$(OBJ) \
|
||||
extF80M_mul$(OBJ) \
|
||||
extF80M_div$(OBJ) \
|
||||
extF80M_rem$(OBJ) \
|
||||
extF80M_sqrt$(OBJ) \
|
||||
extF80M_eq$(OBJ) \
|
||||
extF80M_le$(OBJ) \
|
||||
extF80M_lt$(OBJ) \
|
||||
extF80M_eq_signaling$(OBJ) \
|
||||
extF80M_le_quiet$(OBJ) \
|
||||
extF80M_lt_quiet$(OBJ) \
|
||||
f128M_to_ui32$(OBJ) \
|
||||
f128M_to_ui64$(OBJ) \
|
||||
f128M_to_i32$(OBJ) \
|
||||
f128M_to_i64$(OBJ) \
|
||||
f128M_to_ui32_r_minMag$(OBJ) \
|
||||
f128M_to_ui64_r_minMag$(OBJ) \
|
||||
f128M_to_i32_r_minMag$(OBJ) \
|
||||
f128M_to_i64_r_minMag$(OBJ) \
|
||||
f128M_to_f16$(OBJ) \
|
||||
f128M_to_f32$(OBJ) \
|
||||
f128M_to_f64$(OBJ) \
|
||||
f128M_to_extF80M$(OBJ) \
|
||||
f128M_roundToInt$(OBJ) \
|
||||
f128M_add$(OBJ) \
|
||||
f128M_sub$(OBJ) \
|
||||
f128M_mul$(OBJ) \
|
||||
f128M_mulAdd$(OBJ) \
|
||||
f128M_div$(OBJ) \
|
||||
f128M_rem$(OBJ) \
|
||||
f128M_sqrt$(OBJ) \
|
||||
f128M_eq$(OBJ) \
|
||||
f128M_le$(OBJ) \
|
||||
f128M_lt$(OBJ) \
|
||||
f128M_eq_signaling$(OBJ) \
|
||||
f128M_le_quiet$(OBJ) \
|
||||
f128M_lt_quiet$(OBJ) \
|
||||
|
||||
OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS)
|
||||
|
||||
$(OBJS_ALL): \
|
||||
$(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \
|
||||
$(SOURCE_DIR)/include/primitives.h
|
||||
$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \
|
||||
$(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \
|
||||
$(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \
|
||||
$(SOURCE_DIR)/include/softfloat.h
|
||||
|
||||
$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c
|
||||
$(COMPILE_C) $(SOURCE_DIR)/$*.c
|
||||
|
||||
$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c
|
||||
$(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c
|
||||
|
||||
softfloat$(LIB): $(OBJS_ALL)
|
||||
$(DELETE) $@
|
||||
$(MAKELIB) $^
|
||||
|
||||
.PHONY: clean
|
||||
clean:
|
||||
$(DELETE) $(OBJS_ALL) softfloat$(LIB)
|
||||
|
||||
|
@ -1,49 +1,50 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C header template is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
// Edit lines marked with `==>'. See "SoftFloat-source.html".
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
== > #define LITTLEENDIAN 1
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
== > #define INLINE inline
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
== > #define THREAD_LOCAL _Thread_local
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C header template is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
// Edit lines marked with `==>'. See "SoftFloat-source.html".
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
==> #define LITTLEENDIAN 1
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
==> #define INLINE inline
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
==> #define THREAD_LOCAL _Thread_local
|
||||
|
||||
|
@ -1,258 +1,258 @@
|
||||
|
||||
<HTML>
|
||||
|
||||
<HEAD>
|
||||
<TITLE>Berkeley SoftFloat History</TITLE>
|
||||
</HEAD>
|
||||
|
||||
<BODY>
|
||||
|
||||
<H1>History of Berkeley SoftFloat, to Release 3e</H1>
|
||||
|
||||
<P>
|
||||
John R. Hauser<BR>
|
||||
2018 January 20<BR>
|
||||
</P>
|
||||
|
||||
|
||||
<H3>Release 3e (2018 January)</H3>
|
||||
|
||||
<UL>
|
||||
|
||||
<LI>
|
||||
Changed the default numeric code for optional rounding mode <CODE>odd</CODE>
|
||||
(round to odd, also known as <EM>jamming</EM>) from 5 to 6.
|
||||
|
||||
<LI>
|
||||
Modified the behavior of rounding mode <CODE>odd</CODE> when rounding to an
|
||||
integer value (either conversion to an integer format or a
|
||||
‘<CODE>roundToInt</CODE>’ function).
|
||||
Previously, for those cases only, rounding mode <CODE>odd</CODE> acted the same
|
||||
as rounding to minimum magnitude.
|
||||
Now all operations are rounded consistently.
|
||||
|
||||
<LI>
|
||||
Fixed some errors in the specialization code modeling Intel x86 floating-point,
|
||||
specifically the integers returned on invalid operations and the propagation of
|
||||
NaN payloads in a few rare cases.
|
||||
|
||||
<LI>
|
||||
Added specialization code modeling ARM floating-point, conforming to VFPv2 or
|
||||
later.
|
||||
|
||||
<LI>
|
||||
Added an example target for ARM processors.
|
||||
|
||||
<LI>
|
||||
Fixed a minor bug whereby function <CODE>f16_to_ui64</CODE> might return a
|
||||
different integer than expected in the case that the floating-point operand is
|
||||
negative.
|
||||
|
||||
<LI>
|
||||
Added example target-specific optimization for GCC, employing GCC instrinsics
|
||||
and support for <NOBR>128-bit</NOBR> integer arithmetic.
|
||||
|
||||
<LI>
|
||||
Made other minor improvements.
|
||||
|
||||
</UL>
|
||||
|
||||
|
||||
<H3>Release 3d (2017 August)</H3>
|
||||
|
||||
<UL>
|
||||
|
||||
<LI>
|
||||
Fixed bugs in the square root functions for <NOBR>64-bit</NOBR>
|
||||
double-precision, <NOBR>80-bit</NOBR> double-extended-precision, and
|
||||
<NOBR>128-bit</NOBR> quadruple-precision.
|
||||
For <NOBR>64-bit</NOBR> double-precision (<CODE>f64_sqrt</CODE>), the result
|
||||
could sometimes be off by <NOBR>1 unit</NOBR> in the last place
|
||||
(<NOBR>1 ulp</NOBR>) from what it should be.
|
||||
For the larger formats, the square root could be wrong in a large portion of
|
||||
the less-significant bits.
|
||||
(A bug in <CODE>f128_sqrt</CODE> was first reported by Alexei Sibidanov.)
|
||||
|
||||
</UL>
|
||||
|
||||
|
||||
<H3>Release 3c (2017 February)</H3>
|
||||
|
||||
<UL>
|
||||
|
||||
<LI>
|
||||
Added optional rounding mode <CODE>odd</CODE> (round to odd, also known as
|
||||
<EM>jamming</EM>).
|
||||
|
||||
<LI>
|
||||
Corrected the documentation concerning non-canonical representations in
|
||||
<NOBR>80-bit</NOBR> double-extended-precision.
|
||||
|
||||
</UL>
|
||||
|
||||
|
||||
<H3>Release 3b (2016 July)</H3>
|
||||
|
||||
<UL>
|
||||
|
||||
<LI>
|
||||
Implemented the common <NOBR>16-bit</NOBR> “half-precision”
|
||||
floating-point format (<CODE>float16_t</CODE>).
|
||||
|
||||
<LI>
|
||||
Made the integer values returned on invalid conversions to integer formats
|
||||
be determined by the port-specific specialization instead of being the same for
|
||||
all ports.
|
||||
|
||||
<LI>
|
||||
Added preprocessor macro <CODE>THREAD_LOCAL</CODE> to allow the floating-point
|
||||
state (modes and exception flags) to be made per-thread.
|
||||
|
||||
<LI>
|
||||
Modified the provided Makefiles to allow some options to be overridden from the
|
||||
<CODE>make</CODE> command.
|
||||
|
||||
<LI>
|
||||
Made other minor improvements.
|
||||
|
||||
</UL>
|
||||
|
||||
|
||||
<H3>Release 3a (2015 October)</H3>
|
||||
|
||||
<UL>
|
||||
|
||||
<LI>
|
||||
Replaced the license text supplied by the University of California, Berkeley.
|
||||
|
||||
</UL>
|
||||
|
||||
|
||||
<H3>Release 3 (2015 February)</H3>
|
||||
|
||||
<UL>
|
||||
|
||||
<LI>
|
||||
Complete rewrite, funded by the University of California, Berkeley, and
|
||||
consequently having a different use license than earlier releases.
|
||||
Major changes included renaming most types and functions, upgrading some
|
||||
algorithms, restructuring the source files, and making SoftFloat into a true
|
||||
library.
|
||||
|
||||
<LI>
|
||||
Added functions to convert between floating-point and unsigned integers, both
|
||||
<NOBR>32-bit</NOBR> and <NOBR>64-bit</NOBR> (<CODE>uint32_t</CODE> and
|
||||
<CODE>uint64_t</CODE>).
|
||||
|
||||
<LI>
|
||||
Added functions for fused multiply-add, for all supported floating-point
|
||||
formats except <NOBR>80-bit</NOBR> double-extended-precision.
|
||||
|
||||
<LI>
|
||||
Added support for a fifth rounding mode, <CODE>near_maxMag</CODE> (round to
|
||||
nearest, with ties to maximum magnitude, away from zero).
|
||||
|
||||
<LI>
|
||||
Dropped the <CODE>timesoftfloat</CODE> program (now part of the Berkeley
|
||||
TestFloat package).
|
||||
|
||||
</UL>
|
||||
|
||||
|
||||
<H3>Release 2c (2015 January)</H3>
|
||||
|
||||
<UL>
|
||||
|
||||
<LI>
|
||||
Fixed mistakes affecting some <NOBR>64-bit</NOBR> processors.
|
||||
|
||||
<LI>
|
||||
Further improved the documentation and the wording for the legal restrictions
|
||||
on using SoftFloat releases <NOBR>through 2c</NOBR> (not applicable to
|
||||
<NOBR>Release 3</NOBR> or later).
|
||||
|
||||
</UL>
|
||||
|
||||
|
||||
<H3>Release 2b (2002 May)</H3>
|
||||
|
||||
<UL>
|
||||
|
||||
<LI>
|
||||
Made minor updates to the documentation, including improved wording for the
|
||||
legal restrictions on using SoftFloat.
|
||||
|
||||
</UL>
|
||||
|
||||
|
||||
<H3>Release 2a (1998 December)</H3>
|
||||
|
||||
<UL>
|
||||
|
||||
<LI>
|
||||
Added functions to convert between <NOBR>64-bit</NOBR> integers
|
||||
(<CODE>int64</CODE>) and all supported floating-point formats.
|
||||
|
||||
<LI>
|
||||
Fixed a bug in all <NOBR>64-bit</NOBR>-version square root functions except
|
||||
<CODE>float32_sqrt</CODE> that caused the result sometimes to be off by
|
||||
<NOBR>1 unit</NOBR> in the last place (<NOBR>1 ulp</NOBR>) from what it should
|
||||
be.
|
||||
(Bug discovered by Paul Donahue.)
|
||||
|
||||
<LI>
|
||||
Improved the Makefiles.
|
||||
</UL>
|
||||
|
||||
|
||||
<H3>Release 2 (1997 June)</H3>
|
||||
|
||||
<UL>
|
||||
|
||||
<LI>
|
||||
Created the <NOBR>64-bit</NOBR> (<CODE>bits64</CODE>) version, adding the
|
||||
<CODE>floatx80</CODE> and <CODE>float128</CODE> formats.
|
||||
|
||||
<LI>
|
||||
Changed the source directory structure, splitting the sources into a
|
||||
<CODE>bits32</CODE> and a <CODE>bits64</CODE> version.
|
||||
Renamed <CODE>environment.h</CODE> to <CODE>milieu.h</CODE> to avoid confusion
|
||||
with environment variables.
|
||||
|
||||
<LI>
|
||||
Fixed a small error that caused <CODE>float64_round_to_int</CODE> often to
|
||||
round the wrong way in nearest/even mode when the operand was between
|
||||
2<SUP>20</SUP> and 2<SUP>21</SUP> and halfway between two integers.
|
||||
|
||||
</UL>
|
||||
|
||||
|
||||
<H3>Release 1a (1996 July)</H3>
|
||||
|
||||
<UL>
|
||||
|
||||
<LI>
|
||||
Corrected a mistake that caused borderline underflow cases not to raise the
|
||||
underflow flag when they should have.
|
||||
(Problem reported by Doug Priest.)
|
||||
|
||||
<LI>
|
||||
Added the <CODE>float_detect_tininess</CODE> variable to control whether
|
||||
tininess is detected before or after rounding.
|
||||
|
||||
</UL>
|
||||
|
||||
|
||||
<H3>Release 1 (1996 July)</H3>
|
||||
|
||||
<UL>
|
||||
|
||||
<LI>
|
||||
Original release, based on work done for the International Computer Science
|
||||
Institute (ICSI) in Berkeley, California.
|
||||
|
||||
</UL>
|
||||
|
||||
|
||||
</BODY>
|
||||
|
||||
|
||||
<HTML>
|
||||
|
||||
<HEAD>
|
||||
<TITLE>Berkeley SoftFloat History</TITLE>
|
||||
</HEAD>
|
||||
|
||||
<BODY>
|
||||
|
||||
<H1>History of Berkeley SoftFloat, to Release 3e</H1>
|
||||
|
||||
<P>
|
||||
John R. Hauser<BR>
|
||||
2018 January 20<BR>
|
||||
</P>
|
||||
|
||||
|
||||
<H3>Release 3e (2018 January)</H3>
|
||||
|
||||
<UL>
|
||||
|
||||
<LI>
|
||||
Changed the default numeric code for optional rounding mode <CODE>odd</CODE>
|
||||
(round to odd, also known as <EM>jamming</EM>) from 5 to 6.
|
||||
|
||||
<LI>
|
||||
Modified the behavior of rounding mode <CODE>odd</CODE> when rounding to an
|
||||
integer value (either conversion to an integer format or a
|
||||
‘<CODE>roundToInt</CODE>’ function).
|
||||
Previously, for those cases only, rounding mode <CODE>odd</CODE> acted the same
|
||||
as rounding to minimum magnitude.
|
||||
Now all operations are rounded consistently.
|
||||
|
||||
<LI>
|
||||
Fixed some errors in the specialization code modeling Intel x86 floating-point,
|
||||
specifically the integers returned on invalid operations and the propagation of
|
||||
NaN payloads in a few rare cases.
|
||||
|
||||
<LI>
|
||||
Added specialization code modeling ARM floating-point, conforming to VFPv2 or
|
||||
later.
|
||||
|
||||
<LI>
|
||||
Added an example target for ARM processors.
|
||||
|
||||
<LI>
|
||||
Fixed a minor bug whereby function <CODE>f16_to_ui64</CODE> might return a
|
||||
different integer than expected in the case that the floating-point operand is
|
||||
negative.
|
||||
|
||||
<LI>
|
||||
Added example target-specific optimization for GCC, employing GCC instrinsics
|
||||
and support for <NOBR>128-bit</NOBR> integer arithmetic.
|
||||
|
||||
<LI>
|
||||
Made other minor improvements.
|
||||
|
||||
</UL>
|
||||
|
||||
|
||||
<H3>Release 3d (2017 August)</H3>
|
||||
|
||||
<UL>
|
||||
|
||||
<LI>
|
||||
Fixed bugs in the square root functions for <NOBR>64-bit</NOBR>
|
||||
double-precision, <NOBR>80-bit</NOBR> double-extended-precision, and
|
||||
<NOBR>128-bit</NOBR> quadruple-precision.
|
||||
For <NOBR>64-bit</NOBR> double-precision (<CODE>f64_sqrt</CODE>), the result
|
||||
could sometimes be off by <NOBR>1 unit</NOBR> in the last place
|
||||
(<NOBR>1 ulp</NOBR>) from what it should be.
|
||||
For the larger formats, the square root could be wrong in a large portion of
|
||||
the less-significant bits.
|
||||
(A bug in <CODE>f128_sqrt</CODE> was first reported by Alexei Sibidanov.)
|
||||
|
||||
</UL>
|
||||
|
||||
|
||||
<H3>Release 3c (2017 February)</H3>
|
||||
|
||||
<UL>
|
||||
|
||||
<LI>
|
||||
Added optional rounding mode <CODE>odd</CODE> (round to odd, also known as
|
||||
<EM>jamming</EM>).
|
||||
|
||||
<LI>
|
||||
Corrected the documentation concerning non-canonical representations in
|
||||
<NOBR>80-bit</NOBR> double-extended-precision.
|
||||
|
||||
</UL>
|
||||
|
||||
|
||||
<H3>Release 3b (2016 July)</H3>
|
||||
|
||||
<UL>
|
||||
|
||||
<LI>
|
||||
Implemented the common <NOBR>16-bit</NOBR> “half-precision”
|
||||
floating-point format (<CODE>float16_t</CODE>).
|
||||
|
||||
<LI>
|
||||
Made the integer values returned on invalid conversions to integer formats
|
||||
be determined by the port-specific specialization instead of being the same for
|
||||
all ports.
|
||||
|
||||
<LI>
|
||||
Added preprocessor macro <CODE>THREAD_LOCAL</CODE> to allow the floating-point
|
||||
state (modes and exception flags) to be made per-thread.
|
||||
|
||||
<LI>
|
||||
Modified the provided Makefiles to allow some options to be overridden from the
|
||||
<CODE>make</CODE> command.
|
||||
|
||||
<LI>
|
||||
Made other minor improvements.
|
||||
|
||||
</UL>
|
||||
|
||||
|
||||
<H3>Release 3a (2015 October)</H3>
|
||||
|
||||
<UL>
|
||||
|
||||
<LI>
|
||||
Replaced the license text supplied by the University of California, Berkeley.
|
||||
|
||||
</UL>
|
||||
|
||||
|
||||
<H3>Release 3 (2015 February)</H3>
|
||||
|
||||
<UL>
|
||||
|
||||
<LI>
|
||||
Complete rewrite, funded by the University of California, Berkeley, and
|
||||
consequently having a different use license than earlier releases.
|
||||
Major changes included renaming most types and functions, upgrading some
|
||||
algorithms, restructuring the source files, and making SoftFloat into a true
|
||||
library.
|
||||
|
||||
<LI>
|
||||
Added functions to convert between floating-point and unsigned integers, both
|
||||
<NOBR>32-bit</NOBR> and <NOBR>64-bit</NOBR> (<CODE>uint32_t</CODE> and
|
||||
<CODE>uint64_t</CODE>).
|
||||
|
||||
<LI>
|
||||
Added functions for fused multiply-add, for all supported floating-point
|
||||
formats except <NOBR>80-bit</NOBR> double-extended-precision.
|
||||
|
||||
<LI>
|
||||
Added support for a fifth rounding mode, <CODE>near_maxMag</CODE> (round to
|
||||
nearest, with ties to maximum magnitude, away from zero).
|
||||
|
||||
<LI>
|
||||
Dropped the <CODE>timesoftfloat</CODE> program (now part of the Berkeley
|
||||
TestFloat package).
|
||||
|
||||
</UL>
|
||||
|
||||
|
||||
<H3>Release 2c (2015 January)</H3>
|
||||
|
||||
<UL>
|
||||
|
||||
<LI>
|
||||
Fixed mistakes affecting some <NOBR>64-bit</NOBR> processors.
|
||||
|
||||
<LI>
|
||||
Further improved the documentation and the wording for the legal restrictions
|
||||
on using SoftFloat releases <NOBR>through 2c</NOBR> (not applicable to
|
||||
<NOBR>Release 3</NOBR> or later).
|
||||
|
||||
</UL>
|
||||
|
||||
|
||||
<H3>Release 2b (2002 May)</H3>
|
||||
|
||||
<UL>
|
||||
|
||||
<LI>
|
||||
Made minor updates to the documentation, including improved wording for the
|
||||
legal restrictions on using SoftFloat.
|
||||
|
||||
</UL>
|
||||
|
||||
|
||||
<H3>Release 2a (1998 December)</H3>
|
||||
|
||||
<UL>
|
||||
|
||||
<LI>
|
||||
Added functions to convert between <NOBR>64-bit</NOBR> integers
|
||||
(<CODE>int64</CODE>) and all supported floating-point formats.
|
||||
|
||||
<LI>
|
||||
Fixed a bug in all <NOBR>64-bit</NOBR>-version square root functions except
|
||||
<CODE>float32_sqrt</CODE> that caused the result sometimes to be off by
|
||||
<NOBR>1 unit</NOBR> in the last place (<NOBR>1 ulp</NOBR>) from what it should
|
||||
be.
|
||||
(Bug discovered by Paul Donahue.)
|
||||
|
||||
<LI>
|
||||
Improved the Makefiles.
|
||||
</UL>
|
||||
|
||||
|
||||
<H3>Release 2 (1997 June)</H3>
|
||||
|
||||
<UL>
|
||||
|
||||
<LI>
|
||||
Created the <NOBR>64-bit</NOBR> (<CODE>bits64</CODE>) version, adding the
|
||||
<CODE>floatx80</CODE> and <CODE>float128</CODE> formats.
|
||||
|
||||
<LI>
|
||||
Changed the source directory structure, splitting the sources into a
|
||||
<CODE>bits32</CODE> and a <CODE>bits64</CODE> version.
|
||||
Renamed <CODE>environment.h</CODE> to <CODE>milieu.h</CODE> to avoid confusion
|
||||
with environment variables.
|
||||
|
||||
<LI>
|
||||
Fixed a small error that caused <CODE>float64_round_to_int</CODE> often to
|
||||
round the wrong way in nearest/even mode when the operand was between
|
||||
2<SUP>20</SUP> and 2<SUP>21</SUP> and halfway between two integers.
|
||||
|
||||
</UL>
|
||||
|
||||
|
||||
<H3>Release 1a (1996 July)</H3>
|
||||
|
||||
<UL>
|
||||
|
||||
<LI>
|
||||
Corrected a mistake that caused borderline underflow cases not to raise the
|
||||
underflow flag when they should have.
|
||||
(Problem reported by Doug Priest.)
|
||||
|
||||
<LI>
|
||||
Added the <CODE>float_detect_tininess</CODE> variable to control whether
|
||||
tininess is detected before or after rounding.
|
||||
|
||||
</UL>
|
||||
|
||||
|
||||
<H3>Release 1 (1996 July)</H3>
|
||||
|
||||
<UL>
|
||||
|
||||
<LI>
|
||||
Original release, based on work done for the International Computer Science
|
||||
Institute (ICSI) in Berkeley, California.
|
||||
|
||||
</UL>
|
||||
|
||||
|
||||
</BODY>
|
||||
|
||||
|
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -1,57 +1,57 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
bool extF80M_isSignalingNaN( const extFloat80_t *aPtr )
|
||||
{
|
||||
const struct extFloat80M *aSPtr;
|
||||
uint64_t uiA0;
|
||||
|
||||
aSPtr = (const struct extFloat80M *) aPtr;
|
||||
if ( (aSPtr->signExp & 0x7FFF) != 0x7FFF ) return false;
|
||||
uiA0 = aSPtr->signif;
|
||||
return
|
||||
! (uiA0 & UINT64_C( 0x4000000000000000 ))
|
||||
&& (uiA0 & UINT64_C( 0x3FFFFFFFFFFFFFFF));
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
bool extF80M_isSignalingNaN( const extFloat80_t *aPtr )
|
||||
{
|
||||
const struct extFloat80M *aSPtr;
|
||||
uint64_t uiA0;
|
||||
|
||||
aSPtr = (const struct extFloat80M *) aPtr;
|
||||
if ( (aSPtr->signExp & 0x7FFF) != 0x7FFF ) return false;
|
||||
uiA0 = aSPtr->signif;
|
||||
return
|
||||
! (uiA0 & UINT64_C( 0x4000000000000000 ))
|
||||
&& (uiA0 & UINT64_C( 0x3FFFFFFFFFFFFFFF));
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,60 +1,60 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "primitives.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
bool f128M_isSignalingNaN( const float128_t *aPtr )
|
||||
{
|
||||
const uint32_t *aWPtr;
|
||||
uint32_t uiA96;
|
||||
|
||||
aWPtr = (const uint32_t *) aPtr;
|
||||
uiA96 = aWPtr[indexWordHi( 4 )];
|
||||
if ( (uiA96 & 0x7FFF8000) != 0x7FFF0000 ) return false;
|
||||
return
|
||||
((uiA96 & 0x00007FFF) != 0)
|
||||
|| ((aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )]
|
||||
| aWPtr[indexWord( 4, 0 )])
|
||||
!= 0);
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "primitives.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
bool f128M_isSignalingNaN( const float128_t *aPtr )
|
||||
{
|
||||
const uint32_t *aWPtr;
|
||||
uint32_t uiA96;
|
||||
|
||||
aWPtr = (const uint32_t *) aPtr;
|
||||
uiA96 = aWPtr[indexWordHi( 4 )];
|
||||
if ( (uiA96 & 0x7FFF8000) != 0x7FFF0000 ) return false;
|
||||
return
|
||||
((uiA96 & 0x00007FFF) != 0)
|
||||
|| ((aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )]
|
||||
| aWPtr[indexWord( 4, 0 )])
|
||||
!= 0);
|
||||
|
||||
}
|
||||
|
||||
|
59
softfloat/source/8086-SSE/s_bf16UIToCommonNaN.c
Normal file
59
softfloat/source/8086-SSE/s_bf16UIToCommonNaN.c
Normal file
@ -0,0 +1,59 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming `uiA' has the bit pattern of a BF16 NaN, converts
|
||||
| this NaN to the common NaN form, and stores the resulting common NaN at the
|
||||
| location pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_bf16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr )
|
||||
{
|
||||
|
||||
if ( softfloat_isSigNaNBF16UI( uiA ) ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
}
|
||||
zPtr->sign = uiA>>15;
|
||||
zPtr->v64 = (uint_fast64_t) uiA<<56;
|
||||
zPtr->v0 = 0;
|
||||
|
||||
}
|
||||
|
51
softfloat/source/8086-SSE/s_commonNaNToBF16UI.c
Normal file
51
softfloat/source/8086-SSE/s_commonNaNToBF16UI.c
Normal file
@ -0,0 +1,51 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "specialize.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by `aPtr' into a BF16 NaN, and
|
||||
| returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast16_t softfloat_commonNaNToBF16UI( const struct commonNaN *aPtr )
|
||||
{
|
||||
|
||||
return (uint_fast16_t) aPtr->sign<<15 | 0x7FC0 | aPtr->v64>>56;
|
||||
|
||||
}
|
||||
|
@ -1,56 +1,56 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "specialize.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by `aPtr' into an 80-bit extended
|
||||
| floating-point NaN, and stores this NaN at the location pointed to by
|
||||
| `zSPtr'.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void
|
||||
softfloat_commonNaNToExtF80M(
|
||||
const struct commonNaN *aPtr, struct extFloat80M *zSPtr )
|
||||
{
|
||||
|
||||
zSPtr->signExp = packToExtF80UI64( aPtr->sign, 0x7FFF );
|
||||
zSPtr->signif = UINT64_C( 0xC000000000000000 ) | aPtr->v64>>1;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "specialize.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by `aPtr' into an 80-bit extended
|
||||
| floating-point NaN, and stores this NaN at the location pointed to by
|
||||
| `zSPtr'.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void
|
||||
softfloat_commonNaNToExtF80M(
|
||||
const struct commonNaN *aPtr, struct extFloat80M *zSPtr )
|
||||
{
|
||||
|
||||
zSPtr->signExp = packToExtF80UI64( aPtr->sign, 0x7FFF );
|
||||
zSPtr->signif = UINT64_C( 0xC000000000000000 ) | aPtr->v64>>1;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,56 +1,56 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "primitives.h"
|
||||
#include "specialize.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by `aPtr' into an 80-bit extended
|
||||
| floating-point NaN, and returns the bit pattern of this value as an unsigned
|
||||
| integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr )
|
||||
{
|
||||
struct uint128 uiZ;
|
||||
|
||||
uiZ.v64 = (uint_fast16_t) aPtr->sign<<15 | 0x7FFF;
|
||||
uiZ.v0 = UINT64_C( 0xC000000000000000 ) | aPtr->v64>>1;
|
||||
return uiZ;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "primitives.h"
|
||||
#include "specialize.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by `aPtr' into an 80-bit extended
|
||||
| floating-point NaN, and returns the bit pattern of this value as an unsigned
|
||||
| integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr )
|
||||
{
|
||||
struct uint128 uiZ;
|
||||
|
||||
uiZ.v64 = (uint_fast16_t) aPtr->sign<<15 | 0x7FFF;
|
||||
uiZ.v0 = UINT64_C( 0xC000000000000000 ) | aPtr->v64>>1;
|
||||
return uiZ;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,56 +1,56 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "primitives.h"
|
||||
#include "specialize.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by `aPtr' into a 128-bit floating-point
|
||||
| NaN, and stores this NaN at the location pointed to by `zWPtr'. Argument
|
||||
| `zWPtr' points to an array of four 32-bit elements that concatenate in the
|
||||
| platform's normal endian order to form a 128-bit floating-point value.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void
|
||||
softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr )
|
||||
{
|
||||
|
||||
softfloat_shortShiftRight128M( (const uint32_t *) &aPtr->v0, 16, zWPtr );
|
||||
zWPtr[indexWordHi( 4 )] |= (uint32_t) aPtr->sign<<31 | 0x7FFF8000;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "primitives.h"
|
||||
#include "specialize.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by `aPtr' into a 128-bit floating-point
|
||||
| NaN, and stores this NaN at the location pointed to by `zWPtr'. Argument
|
||||
| `zWPtr' points to an array of four 32-bit elements that concatenate in the
|
||||
| platform's normal endian order to form a 128-bit floating-point value.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void
|
||||
softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr )
|
||||
{
|
||||
|
||||
softfloat_shortShiftRight128M( (const uint32_t *) &aPtr->v0, 16, zWPtr );
|
||||
zWPtr[indexWordHi( 4 )] |= (uint32_t) aPtr->sign<<31 | 0x7FFF8000;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,55 +1,55 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "primitives.h"
|
||||
#include "specialize.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by `aPtr' into a 128-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN *aPtr )
|
||||
{
|
||||
struct uint128 uiZ;
|
||||
|
||||
uiZ = softfloat_shortShiftRight128( aPtr->v64, aPtr->v0, 16 );
|
||||
uiZ.v64 |= (uint_fast64_t) aPtr->sign<<63 | UINT64_C( 0x7FFF800000000000 );
|
||||
return uiZ;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "primitives.h"
|
||||
#include "specialize.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by `aPtr' into a 128-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN *aPtr )
|
||||
{
|
||||
struct uint128 uiZ;
|
||||
|
||||
uiZ = softfloat_shortShiftRight128( aPtr->v64, aPtr->v0, 16 );
|
||||
uiZ.v64 |= (uint_fast64_t) aPtr->sign<<63 | UINT64_C( 0x7FFF800000000000 );
|
||||
return uiZ;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,51 +1,51 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "specialize.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by `aPtr' into a 16-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast16_t softfloat_commonNaNToF16UI( const struct commonNaN *aPtr )
|
||||
{
|
||||
|
||||
return (uint_fast16_t) aPtr->sign<<15 | 0x7E00 | aPtr->v64>>54;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "specialize.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by `aPtr' into a 16-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast16_t softfloat_commonNaNToF16UI( const struct commonNaN *aPtr )
|
||||
{
|
||||
|
||||
return (uint_fast16_t) aPtr->sign<<15 | 0x7E00 | aPtr->v64>>54;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,51 +1,51 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "specialize.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by `aPtr' into a 32-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast32_t softfloat_commonNaNToF32UI( const struct commonNaN *aPtr )
|
||||
{
|
||||
|
||||
return (uint_fast32_t) aPtr->sign<<31 | 0x7FC00000 | aPtr->v64>>41;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "specialize.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by `aPtr' into a 32-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast32_t softfloat_commonNaNToF32UI( const struct commonNaN *aPtr )
|
||||
{
|
||||
|
||||
return (uint_fast32_t) aPtr->sign<<31 | 0x7FC00000 | aPtr->v64>>41;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,53 +1,53 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "specialize.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by `aPtr' into a 64-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast64_t softfloat_commonNaNToF64UI( const struct commonNaN *aPtr )
|
||||
{
|
||||
|
||||
return
|
||||
(uint_fast64_t) aPtr->sign<<63 | UINT64_C( 0x7FF8000000000000 )
|
||||
| aPtr->v64>>12;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "specialize.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by `aPtr' into a 64-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast64_t softfloat_commonNaNToF64UI( const struct commonNaN *aPtr )
|
||||
{
|
||||
|
||||
return
|
||||
(uint_fast64_t) aPtr->sign<<63 | UINT64_C( 0x7FF8000000000000 )
|
||||
| aPtr->v64>>12;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,62 +1,62 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming the 80-bit extended floating-point value pointed to by `aSPtr' is
|
||||
| a NaN, converts this NaN to the common NaN form, and stores the resulting
|
||||
| common NaN at the location pointed to by `zPtr'. If the NaN is a signaling
|
||||
| NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void
|
||||
softfloat_extF80MToCommonNaN(
|
||||
const struct extFloat80M *aSPtr, struct commonNaN *zPtr )
|
||||
{
|
||||
|
||||
if ( extF80M_isSignalingNaN( (const extFloat80_t *) aSPtr ) ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
}
|
||||
zPtr->sign = signExtF80UI64( aSPtr->signExp );
|
||||
zPtr->v64 = aSPtr->signif<<1;
|
||||
zPtr->v0 = 0;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming the 80-bit extended floating-point value pointed to by `aSPtr' is
|
||||
| a NaN, converts this NaN to the common NaN form, and stores the resulting
|
||||
| common NaN at the location pointed to by `zPtr'. If the NaN is a signaling
|
||||
| NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void
|
||||
softfloat_extF80MToCommonNaN(
|
||||
const struct extFloat80M *aSPtr, struct commonNaN *zPtr )
|
||||
{
|
||||
|
||||
if ( extF80M_isSignalingNaN( (const extFloat80_t *) aSPtr ) ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
}
|
||||
zPtr->sign = signExtF80UI64( aSPtr->signExp );
|
||||
zPtr->v64 = aSPtr->signif<<1;
|
||||
zPtr->v0 = 0;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,62 +1,62 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming the unsigned integer formed from concatenating `uiA64' and `uiA0'
|
||||
| has the bit pattern of an 80-bit extended floating-point NaN, converts
|
||||
| this NaN to the common NaN form, and stores the resulting common NaN at the
|
||||
| location pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void
|
||||
softfloat_extF80UIToCommonNaN(
|
||||
uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )
|
||||
{
|
||||
|
||||
if ( softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
}
|
||||
zPtr->sign = uiA64>>15;
|
||||
zPtr->v64 = uiA0<<1;
|
||||
zPtr->v0 = 0;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming the unsigned integer formed from concatenating `uiA64' and `uiA0'
|
||||
| has the bit pattern of an 80-bit extended floating-point NaN, converts
|
||||
| this NaN to the common NaN form, and stores the resulting common NaN at the
|
||||
| location pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void
|
||||
softfloat_extF80UIToCommonNaN(
|
||||
uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )
|
||||
{
|
||||
|
||||
if ( softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
}
|
||||
zPtr->sign = uiA64>>15;
|
||||
zPtr->v64 = uiA0<<1;
|
||||
zPtr->v0 = 0;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,62 +1,62 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "primitives.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming the 128-bit floating-point value pointed to by `aWPtr' is a NaN,
|
||||
| converts this NaN to the common NaN form, and stores the resulting common
|
||||
| NaN at the location pointed to by `zPtr'. If the NaN is a signaling NaN,
|
||||
| the invalid exception is raised. Argument `aWPtr' points to an array of
|
||||
| four 32-bit elements that concatenate in the platform's normal endian order
|
||||
| to form a 128-bit floating-point value.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void
|
||||
softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr )
|
||||
{
|
||||
|
||||
if ( f128M_isSignalingNaN( (const float128_t *) aWPtr ) ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
}
|
||||
zPtr->sign = aWPtr[indexWordHi( 4 )]>>31;
|
||||
softfloat_shortShiftLeft128M( aWPtr, 16, (uint32_t *) &zPtr->v0 );
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "primitives.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming the 128-bit floating-point value pointed to by `aWPtr' is a NaN,
|
||||
| converts this NaN to the common NaN form, and stores the resulting common
|
||||
| NaN at the location pointed to by `zPtr'. If the NaN is a signaling NaN,
|
||||
| the invalid exception is raised. Argument `aWPtr' points to an array of
|
||||
| four 32-bit elements that concatenate in the platform's normal endian order
|
||||
| to form a 128-bit floating-point value.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void
|
||||
softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr )
|
||||
{
|
||||
|
||||
if ( f128M_isSignalingNaN( (const float128_t *) aWPtr ) ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
}
|
||||
zPtr->sign = aWPtr[indexWordHi( 4 )]>>31;
|
||||
softfloat_shortShiftLeft128M( aWPtr, 16, (uint32_t *) &zPtr->v0 );
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,65 +1,65 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "primitives.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming the unsigned integer formed from concatenating `uiA64' and `uiA0'
|
||||
| has the bit pattern of a 128-bit floating-point NaN, converts this NaN to
|
||||
| the common NaN form, and stores the resulting common NaN at the location
|
||||
| pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid exception
|
||||
| is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void
|
||||
softfloat_f128UIToCommonNaN(
|
||||
uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )
|
||||
{
|
||||
struct uint128 NaNSig;
|
||||
|
||||
if ( softfloat_isSigNaNF128UI( uiA64, uiA0 ) ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
}
|
||||
NaNSig = softfloat_shortShiftLeft128( uiA64, uiA0, 16 );
|
||||
zPtr->sign = uiA64>>63;
|
||||
zPtr->v64 = NaNSig.v64;
|
||||
zPtr->v0 = NaNSig.v0;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "primitives.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming the unsigned integer formed from concatenating `uiA64' and `uiA0'
|
||||
| has the bit pattern of a 128-bit floating-point NaN, converts this NaN to
|
||||
| the common NaN form, and stores the resulting common NaN at the location
|
||||
| pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid exception
|
||||
| is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void
|
||||
softfloat_f128UIToCommonNaN(
|
||||
uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )
|
||||
{
|
||||
struct uint128 NaNSig;
|
||||
|
||||
if ( softfloat_isSigNaNF128UI( uiA64, uiA0 ) ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
}
|
||||
NaNSig = softfloat_shortShiftLeft128( uiA64, uiA0, 16 );
|
||||
zPtr->sign = uiA64>>63;
|
||||
zPtr->v64 = NaNSig.v64;
|
||||
zPtr->v0 = NaNSig.v0;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,59 +1,59 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming `uiA' has the bit pattern of a 16-bit floating-point NaN, converts
|
||||
| this NaN to the common NaN form, and stores the resulting common NaN at the
|
||||
| location pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr )
|
||||
{
|
||||
|
||||
if ( softfloat_isSigNaNF16UI( uiA ) ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
}
|
||||
zPtr->sign = uiA>>15;
|
||||
zPtr->v64 = (uint_fast64_t) uiA<<54;
|
||||
zPtr->v0 = 0;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming `uiA' has the bit pattern of a 16-bit floating-point NaN, converts
|
||||
| this NaN to the common NaN form, and stores the resulting common NaN at the
|
||||
| location pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr )
|
||||
{
|
||||
|
||||
if ( softfloat_isSigNaNF16UI( uiA ) ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
}
|
||||
zPtr->sign = uiA>>15;
|
||||
zPtr->v64 = (uint_fast64_t) uiA<<54;
|
||||
zPtr->v0 = 0;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,59 +1,59 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming `uiA' has the bit pattern of a 32-bit floating-point NaN, converts
|
||||
| this NaN to the common NaN form, and stores the resulting common NaN at the
|
||||
| location pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr )
|
||||
{
|
||||
|
||||
if ( softfloat_isSigNaNF32UI( uiA ) ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
}
|
||||
zPtr->sign = uiA>>31;
|
||||
zPtr->v64 = (uint_fast64_t) uiA<<41;
|
||||
zPtr->v0 = 0;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming `uiA' has the bit pattern of a 32-bit floating-point NaN, converts
|
||||
| this NaN to the common NaN form, and stores the resulting common NaN at the
|
||||
| location pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr )
|
||||
{
|
||||
|
||||
if ( softfloat_isSigNaNF32UI( uiA ) ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
}
|
||||
zPtr->sign = uiA>>31;
|
||||
zPtr->v64 = (uint_fast64_t) uiA<<41;
|
||||
zPtr->v0 = 0;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,59 +1,59 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming `uiA' has the bit pattern of a 64-bit floating-point NaN, converts
|
||||
| this NaN to the common NaN form, and stores the resulting common NaN at the
|
||||
| location pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr )
|
||||
{
|
||||
|
||||
if ( softfloat_isSigNaNF64UI( uiA ) ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
}
|
||||
zPtr->sign = uiA>>63;
|
||||
zPtr->v64 = uiA<<12;
|
||||
zPtr->v0 = 0;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming `uiA' has the bit pattern of a 64-bit floating-point NaN, converts
|
||||
| this NaN to the common NaN form, and stores the resulting common NaN at the
|
||||
| location pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr )
|
||||
{
|
||||
|
||||
if ( softfloat_isSigNaNF64UI( uiA ) ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
}
|
||||
zPtr->sign = uiA>>63;
|
||||
zPtr->v64 = uiA<<12;
|
||||
zPtr->v0 = 0;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,107 +1,107 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming at least one of the two 80-bit extended floating-point values
|
||||
| pointed to by `aSPtr' and `bSPtr' is a NaN, stores the combined NaN result
|
||||
| at the location pointed to by `zSPtr'. If either original floating-point
|
||||
| value is a signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void
|
||||
softfloat_propagateNaNExtF80M(
|
||||
const struct extFloat80M *aSPtr,
|
||||
const struct extFloat80M *bSPtr,
|
||||
struct extFloat80M *zSPtr
|
||||
)
|
||||
{
|
||||
bool isSigNaNA;
|
||||
const struct extFloat80M *sPtr;
|
||||
bool isSigNaNB;
|
||||
uint_fast16_t uiB64;
|
||||
uint64_t uiB0;
|
||||
uint_fast16_t uiA64;
|
||||
uint64_t uiA0;
|
||||
uint_fast16_t uiMagA64, uiMagB64;
|
||||
|
||||
isSigNaNA = extF80M_isSignalingNaN( (const extFloat80_t *) aSPtr );
|
||||
sPtr = aSPtr;
|
||||
if ( ! bSPtr ) {
|
||||
if ( isSigNaNA ) softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
goto copy;
|
||||
}
|
||||
isSigNaNB = extF80M_isSignalingNaN( (const extFloat80_t *) bSPtr );
|
||||
if ( isSigNaNA | isSigNaNB ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
if ( isSigNaNA ) {
|
||||
uiB64 = bSPtr->signExp;
|
||||
if ( isSigNaNB ) goto returnLargerUIMag;
|
||||
uiB0 = bSPtr->signif;
|
||||
if ( isNaNExtF80UI( uiB64, uiB0 ) ) goto copyB;
|
||||
goto copy;
|
||||
} else {
|
||||
uiA64 = aSPtr->signExp;
|
||||
uiA0 = aSPtr->signif;
|
||||
if ( isNaNExtF80UI( uiA64, uiA0 ) ) goto copy;
|
||||
goto copyB;
|
||||
}
|
||||
}
|
||||
uiB64 = bSPtr->signExp;
|
||||
returnLargerUIMag:
|
||||
uiA64 = aSPtr->signExp;
|
||||
uiMagA64 = uiA64 & 0x7FFF;
|
||||
uiMagB64 = uiB64 & 0x7FFF;
|
||||
if ( uiMagA64 < uiMagB64 ) goto copyB;
|
||||
if ( uiMagB64 < uiMagA64 ) goto copy;
|
||||
uiA0 = aSPtr->signif;
|
||||
uiB0 = bSPtr->signif;
|
||||
if ( uiA0 < uiB0 ) goto copyB;
|
||||
if ( uiB0 < uiA0 ) goto copy;
|
||||
if ( uiA64 < uiB64 ) goto copy;
|
||||
copyB:
|
||||
sPtr = bSPtr;
|
||||
copy:
|
||||
zSPtr->signExp = sPtr->signExp;
|
||||
zSPtr->signif = sPtr->signif | UINT64_C( 0xC000000000000000 );
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming at least one of the two 80-bit extended floating-point values
|
||||
| pointed to by `aSPtr' and `bSPtr' is a NaN, stores the combined NaN result
|
||||
| at the location pointed to by `zSPtr'. If either original floating-point
|
||||
| value is a signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void
|
||||
softfloat_propagateNaNExtF80M(
|
||||
const struct extFloat80M *aSPtr,
|
||||
const struct extFloat80M *bSPtr,
|
||||
struct extFloat80M *zSPtr
|
||||
)
|
||||
{
|
||||
bool isSigNaNA;
|
||||
const struct extFloat80M *sPtr;
|
||||
bool isSigNaNB;
|
||||
uint_fast16_t uiB64;
|
||||
uint64_t uiB0;
|
||||
uint_fast16_t uiA64;
|
||||
uint64_t uiA0;
|
||||
uint_fast16_t uiMagA64, uiMagB64;
|
||||
|
||||
isSigNaNA = extF80M_isSignalingNaN( (const extFloat80_t *) aSPtr );
|
||||
sPtr = aSPtr;
|
||||
if ( ! bSPtr ) {
|
||||
if ( isSigNaNA ) softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
goto copy;
|
||||
}
|
||||
isSigNaNB = extF80M_isSignalingNaN( (const extFloat80_t *) bSPtr );
|
||||
if ( isSigNaNA | isSigNaNB ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
if ( isSigNaNA ) {
|
||||
uiB64 = bSPtr->signExp;
|
||||
if ( isSigNaNB ) goto returnLargerUIMag;
|
||||
uiB0 = bSPtr->signif;
|
||||
if ( isNaNExtF80UI( uiB64, uiB0 ) ) goto copyB;
|
||||
goto copy;
|
||||
} else {
|
||||
uiA64 = aSPtr->signExp;
|
||||
uiA0 = aSPtr->signif;
|
||||
if ( isNaNExtF80UI( uiA64, uiA0 ) ) goto copy;
|
||||
goto copyB;
|
||||
}
|
||||
}
|
||||
uiB64 = bSPtr->signExp;
|
||||
returnLargerUIMag:
|
||||
uiA64 = aSPtr->signExp;
|
||||
uiMagA64 = uiA64 & 0x7FFF;
|
||||
uiMagB64 = uiB64 & 0x7FFF;
|
||||
if ( uiMagA64 < uiMagB64 ) goto copyB;
|
||||
if ( uiMagB64 < uiMagA64 ) goto copy;
|
||||
uiA0 = aSPtr->signif;
|
||||
uiB0 = bSPtr->signif;
|
||||
if ( uiA0 < uiB0 ) goto copyB;
|
||||
if ( uiB0 < uiA0 ) goto copy;
|
||||
if ( uiA64 < uiB64 ) goto copy;
|
||||
copyB:
|
||||
sPtr = bSPtr;
|
||||
copy:
|
||||
zSPtr->signExp = sPtr->signExp;
|
||||
zSPtr->signif = sPtr->signif | UINT64_C( 0xC000000000000000 );
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,106 +1,106 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting the unsigned integer formed from concatenating 'uiA64' and
|
||||
| 'uiA0' as an 80-bit extended floating-point value, and likewise interpreting
|
||||
| the unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
|
||||
| 80-bit extended floating-point value, and assuming at least on of these
|
||||
| floating-point values is a NaN, returns the bit pattern of the combined NaN
|
||||
| result. If either original floating-point value is a signaling NaN, the
|
||||
| invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128
|
||||
softfloat_propagateNaNExtF80UI(
|
||||
uint_fast16_t uiA64,
|
||||
uint_fast64_t uiA0,
|
||||
uint_fast16_t uiB64,
|
||||
uint_fast64_t uiB0
|
||||
)
|
||||
{
|
||||
bool isSigNaNA, isSigNaNB;
|
||||
uint_fast64_t uiNonsigA0, uiNonsigB0;
|
||||
uint_fast16_t uiMagA64, uiMagB64;
|
||||
struct uint128 uiZ;
|
||||
|
||||
/*------------------------------------------------------------------------
|
||||
*------------------------------------------------------------------------*/
|
||||
isSigNaNA = softfloat_isSigNaNExtF80UI( uiA64, uiA0 );
|
||||
isSigNaNB = softfloat_isSigNaNExtF80UI( uiB64, uiB0 );
|
||||
/*------------------------------------------------------------------------
|
||||
| Make NaNs non-signaling.
|
||||
*------------------------------------------------------------------------*/
|
||||
uiNonsigA0 = uiA0 | UINT64_C( 0xC000000000000000 );
|
||||
uiNonsigB0 = uiB0 | UINT64_C( 0xC000000000000000 );
|
||||
/*------------------------------------------------------------------------
|
||||
*------------------------------------------------------------------------*/
|
||||
if ( isSigNaNA | isSigNaNB ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
if ( isSigNaNA ) {
|
||||
if ( isSigNaNB ) goto returnLargerMag;
|
||||
if ( isNaNExtF80UI( uiB64, uiB0 ) ) goto returnB;
|
||||
goto returnA;
|
||||
} else {
|
||||
if ( isNaNExtF80UI( uiA64, uiA0 ) ) goto returnA;
|
||||
goto returnB;
|
||||
}
|
||||
}
|
||||
returnLargerMag:
|
||||
uiMagA64 = uiA64 & 0x7FFF;
|
||||
uiMagB64 = uiB64 & 0x7FFF;
|
||||
if ( uiMagA64 < uiMagB64 ) goto returnB;
|
||||
if ( uiMagB64 < uiMagA64 ) goto returnA;
|
||||
if ( uiA0 < uiB0 ) goto returnB;
|
||||
if ( uiB0 < uiA0 ) goto returnA;
|
||||
if ( uiA64 < uiB64 ) goto returnA;
|
||||
returnB:
|
||||
uiZ.v64 = uiB64;
|
||||
uiZ.v0 = uiNonsigB0;
|
||||
return uiZ;
|
||||
returnA:
|
||||
uiZ.v64 = uiA64;
|
||||
uiZ.v0 = uiNonsigA0;
|
||||
return uiZ;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting the unsigned integer formed from concatenating 'uiA64' and
|
||||
| 'uiA0' as an 80-bit extended floating-point value, and likewise interpreting
|
||||
| the unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
|
||||
| 80-bit extended floating-point value, and assuming at least on of these
|
||||
| floating-point values is a NaN, returns the bit pattern of the combined NaN
|
||||
| result. If either original floating-point value is a signaling NaN, the
|
||||
| invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128
|
||||
softfloat_propagateNaNExtF80UI(
|
||||
uint_fast16_t uiA64,
|
||||
uint_fast64_t uiA0,
|
||||
uint_fast16_t uiB64,
|
||||
uint_fast64_t uiB0
|
||||
)
|
||||
{
|
||||
bool isSigNaNA, isSigNaNB;
|
||||
uint_fast64_t uiNonsigA0, uiNonsigB0;
|
||||
uint_fast16_t uiMagA64, uiMagB64;
|
||||
struct uint128 uiZ;
|
||||
|
||||
/*------------------------------------------------------------------------
|
||||
*------------------------------------------------------------------------*/
|
||||
isSigNaNA = softfloat_isSigNaNExtF80UI( uiA64, uiA0 );
|
||||
isSigNaNB = softfloat_isSigNaNExtF80UI( uiB64, uiB0 );
|
||||
/*------------------------------------------------------------------------
|
||||
| Make NaNs non-signaling.
|
||||
*------------------------------------------------------------------------*/
|
||||
uiNonsigA0 = uiA0 | UINT64_C( 0xC000000000000000 );
|
||||
uiNonsigB0 = uiB0 | UINT64_C( 0xC000000000000000 );
|
||||
/*------------------------------------------------------------------------
|
||||
*------------------------------------------------------------------------*/
|
||||
if ( isSigNaNA | isSigNaNB ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
if ( isSigNaNA ) {
|
||||
if ( isSigNaNB ) goto returnLargerMag;
|
||||
if ( isNaNExtF80UI( uiB64, uiB0 ) ) goto returnB;
|
||||
goto returnA;
|
||||
} else {
|
||||
if ( isNaNExtF80UI( uiA64, uiA0 ) ) goto returnA;
|
||||
goto returnB;
|
||||
}
|
||||
}
|
||||
returnLargerMag:
|
||||
uiMagA64 = uiA64 & 0x7FFF;
|
||||
uiMagB64 = uiB64 & 0x7FFF;
|
||||
if ( uiMagA64 < uiMagB64 ) goto returnB;
|
||||
if ( uiMagB64 < uiMagA64 ) goto returnA;
|
||||
if ( uiA0 < uiB0 ) goto returnB;
|
||||
if ( uiB0 < uiA0 ) goto returnA;
|
||||
if ( uiA64 < uiB64 ) goto returnA;
|
||||
returnB:
|
||||
uiZ.v64 = uiB64;
|
||||
uiZ.v0 = uiNonsigB0;
|
||||
return uiZ;
|
||||
returnA:
|
||||
uiZ.v64 = uiA64;
|
||||
uiZ.v0 = uiNonsigA0;
|
||||
return uiZ;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,76 +1,76 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming at least one of the two 128-bit floating-point values pointed to by
|
||||
| `aWPtr' and `bWPtr' is a NaN, stores the combined NaN result at the location
|
||||
| pointed to by `zWPtr'. If either original floating-point value is a
|
||||
| signaling NaN, the invalid exception is raised. Each of `aWPtr', `bWPtr',
|
||||
| and `zWPtr' points to an array of four 32-bit elements that concatenate in
|
||||
| the platform's normal endian order to form a 128-bit floating-point value.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void
|
||||
softfloat_propagateNaNF128M(
|
||||
const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr )
|
||||
{
|
||||
bool isSigNaNA;
|
||||
const uint32_t *ptr;
|
||||
|
||||
ptr = aWPtr;
|
||||
isSigNaNA = f128M_isSignalingNaN( (const float128_t *) aWPtr );
|
||||
if (
|
||||
isSigNaNA
|
||||
|| (bWPtr && f128M_isSignalingNaN( (const float128_t *) bWPtr ))
|
||||
) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
if ( isSigNaNA ) goto copy;
|
||||
}
|
||||
if ( ! softfloat_isNaNF128M( aWPtr ) ) ptr = bWPtr;
|
||||
copy:
|
||||
zWPtr[indexWordHi( 4 )] = ptr[indexWordHi( 4 )] | 0x00008000;
|
||||
zWPtr[indexWord( 4, 2 )] = ptr[indexWord( 4, 2 )];
|
||||
zWPtr[indexWord( 4, 1 )] = ptr[indexWord( 4, 1 )];
|
||||
zWPtr[indexWord( 4, 0 )] = ptr[indexWord( 4, 0 )];
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming at least one of the two 128-bit floating-point values pointed to by
|
||||
| `aWPtr' and `bWPtr' is a NaN, stores the combined NaN result at the location
|
||||
| pointed to by `zWPtr'. If either original floating-point value is a
|
||||
| signaling NaN, the invalid exception is raised. Each of `aWPtr', `bWPtr',
|
||||
| and `zWPtr' points to an array of four 32-bit elements that concatenate in
|
||||
| the platform's normal endian order to form a 128-bit floating-point value.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void
|
||||
softfloat_propagateNaNF128M(
|
||||
const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr )
|
||||
{
|
||||
bool isSigNaNA;
|
||||
const uint32_t *ptr;
|
||||
|
||||
ptr = aWPtr;
|
||||
isSigNaNA = f128M_isSignalingNaN( (const float128_t *) aWPtr );
|
||||
if (
|
||||
isSigNaNA
|
||||
|| (bWPtr && f128M_isSignalingNaN( (const float128_t *) bWPtr ))
|
||||
) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
if ( isSigNaNA ) goto copy;
|
||||
}
|
||||
if ( ! softfloat_isNaNF128M( aWPtr ) ) ptr = bWPtr;
|
||||
copy:
|
||||
zWPtr[indexWordHi( 4 )] = ptr[indexWordHi( 4 )] | 0x00008000;
|
||||
zWPtr[indexWord( 4, 2 )] = ptr[indexWord( 4, 2 )];
|
||||
zWPtr[indexWord( 4, 1 )] = ptr[indexWord( 4, 1 )];
|
||||
zWPtr[indexWord( 4, 0 )] = ptr[indexWord( 4, 0 )];
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,81 +1,81 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting the unsigned integer formed from concatenating `uiA64' and
|
||||
| `uiA0' as a 128-bit floating-point value, and likewise interpreting the
|
||||
| unsigned integer formed from concatenating `uiB64' and `uiB0' as another
|
||||
| 128-bit floating-point value, and assuming at least on of these floating-
|
||||
| point values is a NaN, returns the bit pattern of the combined NaN result.
|
||||
| If either original floating-point value is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128
|
||||
softfloat_propagateNaNF128UI(
|
||||
uint_fast64_t uiA64,
|
||||
uint_fast64_t uiA0,
|
||||
uint_fast64_t uiB64,
|
||||
uint_fast64_t uiB0
|
||||
)
|
||||
{
|
||||
bool isSigNaNA;
|
||||
struct uint128 uiZ;
|
||||
|
||||
isSigNaNA = softfloat_isSigNaNF128UI( uiA64, uiA0 );
|
||||
if ( isSigNaNA || softfloat_isSigNaNF128UI( uiB64, uiB0 ) ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
if ( isSigNaNA ) goto returnNonsigA;
|
||||
}
|
||||
if ( isNaNF128UI( uiA64, uiA0 ) ) {
|
||||
returnNonsigA:
|
||||
uiZ.v64 = uiA64;
|
||||
uiZ.v0 = uiA0;
|
||||
} else {
|
||||
uiZ.v64 = uiB64;
|
||||
uiZ.v0 = uiB0;
|
||||
}
|
||||
uiZ.v64 |= UINT64_C( 0x0000800000000000 );
|
||||
return uiZ;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting the unsigned integer formed from concatenating `uiA64' and
|
||||
| `uiA0' as a 128-bit floating-point value, and likewise interpreting the
|
||||
| unsigned integer formed from concatenating `uiB64' and `uiB0' as another
|
||||
| 128-bit floating-point value, and assuming at least on of these floating-
|
||||
| point values is a NaN, returns the bit pattern of the combined NaN result.
|
||||
| If either original floating-point value is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128
|
||||
softfloat_propagateNaNF128UI(
|
||||
uint_fast64_t uiA64,
|
||||
uint_fast64_t uiA0,
|
||||
uint_fast64_t uiB64,
|
||||
uint_fast64_t uiB0
|
||||
)
|
||||
{
|
||||
bool isSigNaNA;
|
||||
struct uint128 uiZ;
|
||||
|
||||
isSigNaNA = softfloat_isSigNaNF128UI( uiA64, uiA0 );
|
||||
if ( isSigNaNA || softfloat_isSigNaNF128UI( uiB64, uiB0 ) ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
if ( isSigNaNA ) goto returnNonsigA;
|
||||
}
|
||||
if ( isNaNF128UI( uiA64, uiA0 ) ) {
|
||||
returnNonsigA:
|
||||
uiZ.v64 = uiA64;
|
||||
uiZ.v0 = uiA0;
|
||||
} else {
|
||||
uiZ.v64 = uiB64;
|
||||
uiZ.v0 = uiB0;
|
||||
}
|
||||
uiZ.v64 |= UINT64_C( 0x0000800000000000 );
|
||||
return uiZ;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,63 +1,63 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting `uiA' and `uiB' as the bit patterns of two 16-bit floating-
|
||||
| point values, at least one of which is a NaN, returns the bit pattern of
|
||||
| the combined NaN result. If either `uiA' or `uiB' has the pattern of a
|
||||
| signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast16_t
|
||||
softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB )
|
||||
{
|
||||
bool isSigNaNA;
|
||||
|
||||
isSigNaNA = softfloat_isSigNaNF16UI( uiA );
|
||||
if ( isSigNaNA || softfloat_isSigNaNF16UI( uiB ) ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
if ( isSigNaNA ) return uiA | 0x0200;
|
||||
}
|
||||
return (isNaNF16UI( uiA ) ? uiA : uiB) | 0x0200;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting `uiA' and `uiB' as the bit patterns of two 16-bit floating-
|
||||
| point values, at least one of which is a NaN, returns the bit pattern of
|
||||
| the combined NaN result. If either `uiA' or `uiB' has the pattern of a
|
||||
| signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast16_t
|
||||
softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB )
|
||||
{
|
||||
bool isSigNaNA;
|
||||
|
||||
isSigNaNA = softfloat_isSigNaNF16UI( uiA );
|
||||
if ( isSigNaNA || softfloat_isSigNaNF16UI( uiB ) ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
if ( isSigNaNA ) return uiA | 0x0200;
|
||||
}
|
||||
return (isNaNF16UI( uiA ) ? uiA : uiB) | 0x0200;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,63 +1,63 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting `uiA' and `uiB' as the bit patterns of two 32-bit floating-
|
||||
| point values, at least one of which is a NaN, returns the bit pattern of
|
||||
| the combined NaN result. If either `uiA' or `uiB' has the pattern of a
|
||||
| signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast32_t
|
||||
softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB )
|
||||
{
|
||||
bool isSigNaNA;
|
||||
|
||||
isSigNaNA = softfloat_isSigNaNF32UI( uiA );
|
||||
if ( isSigNaNA || softfloat_isSigNaNF32UI( uiB ) ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
if ( isSigNaNA ) return uiA | 0x00400000;
|
||||
}
|
||||
return (isNaNF32UI( uiA ) ? uiA : uiB) | 0x00400000;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting `uiA' and `uiB' as the bit patterns of two 32-bit floating-
|
||||
| point values, at least one of which is a NaN, returns the bit pattern of
|
||||
| the combined NaN result. If either `uiA' or `uiB' has the pattern of a
|
||||
| signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast32_t
|
||||
softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB )
|
||||
{
|
||||
bool isSigNaNA;
|
||||
|
||||
isSigNaNA = softfloat_isSigNaNF32UI( uiA );
|
||||
if ( isSigNaNA || softfloat_isSigNaNF32UI( uiB ) ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
if ( isSigNaNA ) return uiA | 0x00400000;
|
||||
}
|
||||
return (isNaNF32UI( uiA ) ? uiA : uiB) | 0x00400000;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,63 +1,63 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting `uiA' and `uiB' as the bit patterns of two 64-bit floating-
|
||||
| point values, at least one of which is a NaN, returns the bit pattern of
|
||||
| the combined NaN result. If either `uiA' or `uiB' has the pattern of a
|
||||
| signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast64_t
|
||||
softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB )
|
||||
{
|
||||
bool isSigNaNA;
|
||||
|
||||
isSigNaNA = softfloat_isSigNaNF64UI( uiA );
|
||||
if ( isSigNaNA || softfloat_isSigNaNF64UI( uiB ) ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
if ( isSigNaNA ) return uiA | UINT64_C( 0x0008000000000000 );
|
||||
}
|
||||
return (isNaNF64UI( uiA ) ? uiA : uiB) | UINT64_C( 0x0008000000000000 );
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting `uiA' and `uiB' as the bit patterns of two 64-bit floating-
|
||||
| point values, at least one of which is a NaN, returns the bit pattern of
|
||||
| the combined NaN result. If either `uiA' or `uiB' has the pattern of a
|
||||
| signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast64_t
|
||||
softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB )
|
||||
{
|
||||
bool isSigNaNA;
|
||||
|
||||
isSigNaNA = softfloat_isSigNaNF64UI( uiA );
|
||||
if ( isSigNaNA || softfloat_isSigNaNF64UI( uiB ) ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
if ( isSigNaNA ) return uiA | UINT64_C( 0x0008000000000000 );
|
||||
}
|
||||
return (isNaNF64UI( uiA ) ? uiA : uiB) | UINT64_C( 0x0008000000000000 );
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,52 +1,52 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include "platform.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Raises the exceptions specified by `flags'. Floating-point traps can be
|
||||
| defined here if desired. It is currently not possible for such a trap
|
||||
| to substitute a result value. If traps are not implemented, this routine
|
||||
| should be simply `softfloat_exceptionFlags |= flags;'.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_raiseFlags( uint_fast8_t flags )
|
||||
{
|
||||
|
||||
softfloat_exceptionFlags |= flags;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include "platform.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Raises the exceptions specified by `flags'. Floating-point traps can be
|
||||
| defined here if desired. It is currently not possible for such a trap
|
||||
| to substitute a result value. If traps are not implemented, this routine
|
||||
| should be simply `softfloat_exceptionFlags |= flags;'.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_raiseFlags( uint_fast8_t flags )
|
||||
{
|
||||
|
||||
softfloat_exceptionFlags |= flags;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,346 +1,367 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2018 The Regents of the
|
||||
University of California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#ifndef specialize_h
|
||||
#define specialize_h 1
|
||||
|
||||
#include "primitiveTypes.h"
|
||||
#include "softfloat.h"
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Default value for 'softfloat_detectTininess'.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define init_detectTininess softfloat_tininess_afterRounding
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The values to return on conversions to 32-bit integer formats that raise an
|
||||
| invalid exception.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define ui32_fromPosOverflow 0xFFFFFFFF
|
||||
#define ui32_fromNegOverflow 0xFFFFFFFF
|
||||
#define ui32_fromNaN 0xFFFFFFFF
|
||||
#define i32_fromPosOverflow (-0x7FFFFFFF - 1)
|
||||
#define i32_fromNegOverflow (-0x7FFFFFFF - 1)
|
||||
#define i32_fromNaN (-0x7FFFFFFF - 1)
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The values to return on conversions to 64-bit integer formats that raise an
|
||||
| invalid exception.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define ui64_fromPosOverflow UINT64_C(0xFFFFFFFFFFFFFFFF)
|
||||
#define ui64_fromNegOverflow UINT64_C(0xFFFFFFFFFFFFFFFF)
|
||||
#define ui64_fromNaN UINT64_C(0xFFFFFFFFFFFFFFFF)
|
||||
#define i64_fromPosOverflow (-INT64_C(0x7FFFFFFFFFFFFFFF) - 1)
|
||||
#define i64_fromNegOverflow (-INT64_C(0x7FFFFFFFFFFFFFFF) - 1)
|
||||
#define i64_fromNaN (-INT64_C(0x7FFFFFFFFFFFFFFF) - 1)
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| "Common NaN" structure, used to transfer NaN representations from one format
|
||||
| to another.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct commonNaN {
|
||||
bool sign;
|
||||
#ifdef LITTLEENDIAN
|
||||
uint64_t v0, v64;
|
||||
#else
|
||||
uint64_t v64, v0;
|
||||
#endif
|
||||
};
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 16-bit floating-point NaN.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define defaultNaNF16UI 0xFE00
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Returns true when 16-bit unsigned integer 'uiA' has the bit pattern of a
|
||||
| 16-bit floating-point signaling NaN.
|
||||
| Note: This macro evaluates its argument more than once.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_isSigNaNF16UI(uiA) ((((uiA)&0x7E00) == 0x7C00) && ((uiA)&0x01FF))
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming 'uiA' has the bit pattern of a 16-bit floating-point NaN, converts
|
||||
| this NaN to the common NaN form, and stores the resulting common NaN at the
|
||||
| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f16UIToCommonNaN(uint_fast16_t uiA, struct commonNaN* zPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast16_t softfloat_commonNaNToF16UI(const struct commonNaN* aPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting 'uiA' and 'uiB' as the bit patterns of two 16-bit floating-
|
||||
| point values, at least one of which is a NaN, returns the bit pattern of
|
||||
| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
|
||||
| signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast16_t softfloat_propagateNaNF16UI(uint_fast16_t uiA, uint_fast16_t uiB);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 32-bit floating-point NaN.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define defaultNaNF32UI 0xFFC00000
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Returns true when 32-bit unsigned integer 'uiA' has the bit pattern of a
|
||||
| 32-bit floating-point signaling NaN.
|
||||
| Note: This macro evaluates its argument more than once.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_isSigNaNF32UI(uiA) ((((uiA)&0x7FC00000) == 0x7F800000) && ((uiA)&0x003FFFFF))
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming 'uiA' has the bit pattern of a 32-bit floating-point NaN, converts
|
||||
| this NaN to the common NaN form, and stores the resulting common NaN at the
|
||||
| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f32UIToCommonNaN(uint_fast32_t uiA, struct commonNaN* zPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 32-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast32_t softfloat_commonNaNToF32UI(const struct commonNaN* aPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting 'uiA' and 'uiB' as the bit patterns of two 32-bit floating-
|
||||
| point values, at least one of which is a NaN, returns the bit pattern of
|
||||
| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
|
||||
| signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast32_t softfloat_propagateNaNF32UI(uint_fast32_t uiA, uint_fast32_t uiB);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 64-bit floating-point NaN.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define defaultNaNF64UI UINT64_C(0xFFF8000000000000)
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Returns true when 64-bit unsigned integer 'uiA' has the bit pattern of a
|
||||
| 64-bit floating-point signaling NaN.
|
||||
| Note: This macro evaluates its argument more than once.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_isSigNaNF64UI(uiA) \
|
||||
((((uiA)&UINT64_C(0x7FF8000000000000)) == UINT64_C(0x7FF0000000000000)) && ((uiA)&UINT64_C(0x0007FFFFFFFFFFFF)))
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming 'uiA' has the bit pattern of a 64-bit floating-point NaN, converts
|
||||
| this NaN to the common NaN form, and stores the resulting common NaN at the
|
||||
| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f64UIToCommonNaN(uint_fast64_t uiA, struct commonNaN* zPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 64-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast64_t softfloat_commonNaNToF64UI(const struct commonNaN* aPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting 'uiA' and 'uiB' as the bit patterns of two 64-bit floating-
|
||||
| point values, at least one of which is a NaN, returns the bit pattern of
|
||||
| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
|
||||
| signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast64_t softfloat_propagateNaNF64UI(uint_fast64_t uiA, uint_fast64_t uiB);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 80-bit extended floating-point NaN.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define defaultNaNExtF80UI64 0xFFFF
|
||||
#define defaultNaNExtF80UI0 UINT64_C(0xC000000000000000)
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Returns true when the 80-bit unsigned integer formed from concatenating
|
||||
| 16-bit 'uiA64' and 64-bit 'uiA0' has the bit pattern of an 80-bit extended
|
||||
| floating-point signaling NaN.
|
||||
| Note: This macro evaluates its arguments more than once.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_isSigNaNExtF80UI(uiA64, uiA0) \
|
||||
((((uiA64)&0x7FFF) == 0x7FFF) && !((uiA0)&UINT64_C(0x4000000000000000)) && ((uiA0)&UINT64_C(0x3FFFFFFFFFFFFFFF)))
|
||||
|
||||
#ifdef SOFTFLOAT_FAST_INT64
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is
|
||||
| defined.
|
||||
*----------------------------------------------------------------------------*/
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
|
||||
| has the bit pattern of an 80-bit extended floating-point NaN, converts
|
||||
| this NaN to the common NaN form, and stores the resulting common NaN at the
|
||||
| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_extF80UIToCommonNaN(uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN* zPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
|
||||
| floating-point NaN, and returns the bit pattern of this value as an unsigned
|
||||
| integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128 softfloat_commonNaNToExtF80UI(const struct commonNaN* aPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting the unsigned integer formed from concatenating 'uiA64' and
|
||||
| 'uiA0' as an 80-bit extended floating-point value, and likewise interpreting
|
||||
| the unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
|
||||
| 80-bit extended floating-point value, and assuming at least on of these
|
||||
| floating-point values is a NaN, returns the bit pattern of the combined NaN
|
||||
| result. If either original floating-point value is a signaling NaN, the
|
||||
| invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128 softfloat_propagateNaNExtF80UI(uint_fast16_t uiA64, uint_fast64_t uiA0, uint_fast16_t uiB64, uint_fast64_t uiB0);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 128-bit floating-point NaN.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define defaultNaNF128UI64 UINT64_C(0xFFFF800000000000)
|
||||
#define defaultNaNF128UI0 UINT64_C(0)
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Returns true when the 128-bit unsigned integer formed from concatenating
|
||||
| 64-bit 'uiA64' and 64-bit 'uiA0' has the bit pattern of a 128-bit floating-
|
||||
| point signaling NaN.
|
||||
| Note: This macro evaluates its arguments more than once.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_isSigNaNF128UI(uiA64, uiA0) \
|
||||
((((uiA64)&UINT64_C(0x7FFF800000000000)) == UINT64_C(0x7FFF000000000000)) && ((uiA0) || ((uiA64)&UINT64_C(0x00007FFFFFFFFFFF))))
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
|
||||
| has the bit pattern of a 128-bit floating-point NaN, converts this NaN to
|
||||
| the common NaN form, and stores the resulting common NaN at the location
|
||||
| pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid exception
|
||||
| is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f128UIToCommonNaN(uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN* zPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128 softfloat_commonNaNToF128UI(const struct commonNaN*);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting the unsigned integer formed from concatenating 'uiA64' and
|
||||
| 'uiA0' as a 128-bit floating-point value, and likewise interpreting the
|
||||
| unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
|
||||
| 128-bit floating-point value, and assuming at least on of these floating-
|
||||
| point values is a NaN, returns the bit pattern of the combined NaN result.
|
||||
| If either original floating-point value is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128 softfloat_propagateNaNF128UI(uint_fast64_t uiA64, uint_fast64_t uiA0, uint_fast64_t uiB64, uint_fast64_t uiB0);
|
||||
|
||||
#else
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is not
|
||||
| defined.
|
||||
*----------------------------------------------------------------------------*/
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming the 80-bit extended floating-point value pointed to by 'aSPtr' is
|
||||
| a NaN, converts this NaN to the common NaN form, and stores the resulting
|
||||
| common NaN at the location pointed to by 'zPtr'. If the NaN is a signaling
|
||||
| NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_extF80MToCommonNaN(const struct extFloat80M* aSPtr, struct commonNaN* zPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
|
||||
| floating-point NaN, and stores this NaN at the location pointed to by
|
||||
| 'zSPtr'.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_commonNaNToExtF80M(const struct commonNaN* aPtr, struct extFloat80M* zSPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming at least one of the two 80-bit extended floating-point values
|
||||
| pointed to by 'aSPtr' and 'bSPtr' is a NaN, stores the combined NaN result
|
||||
| at the location pointed to by 'zSPtr'. If either original floating-point
|
||||
| value is a signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_propagateNaNExtF80M(const struct extFloat80M* aSPtr, const struct extFloat80M* bSPtr, struct extFloat80M* zSPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 128-bit floating-point NaN.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define defaultNaNF128UI96 0xFFFF8000
|
||||
#define defaultNaNF128UI64 0
|
||||
#define defaultNaNF128UI32 0
|
||||
#define defaultNaNF128UI0 0
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming the 128-bit floating-point value pointed to by 'aWPtr' is a NaN,
|
||||
| converts this NaN to the common NaN form, and stores the resulting common
|
||||
| NaN at the location pointed to by 'zPtr'. If the NaN is a signaling NaN,
|
||||
| the invalid exception is raised. Argument 'aWPtr' points to an array of
|
||||
| four 32-bit elements that concatenate in the platform's normal endian order
|
||||
| to form a 128-bit floating-point value.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f128MToCommonNaN(const uint32_t* aWPtr, struct commonNaN* zPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
|
||||
| NaN, and stores this NaN at the location pointed to by 'zWPtr'. Argument
|
||||
| 'zWPtr' points to an array of four 32-bit elements that concatenate in the
|
||||
| platform's normal endian order to form a 128-bit floating-point value.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_commonNaNToF128M(const struct commonNaN* aPtr, uint32_t* zWPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming at least one of the two 128-bit floating-point values pointed to by
|
||||
| 'aWPtr' and 'bWPtr' is a NaN, stores the combined NaN result at the location
|
||||
| pointed to by 'zWPtr'. If either original floating-point value is a
|
||||
| signaling NaN, the invalid exception is raised. Each of 'aWPtr', 'bWPtr',
|
||||
| and 'zWPtr' points to an array of four 32-bit elements that concatenate in
|
||||
| the platform's normal endian order to form a 128-bit floating-point value.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_propagateNaNF128M(const uint32_t* aWPtr, const uint32_t* bWPtr, uint32_t* zWPtr);
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2018 The Regents of the
|
||||
University of California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#ifndef specialize_h
|
||||
#define specialize_h 1
|
||||
|
||||
#include "primitiveTypes.h"
|
||||
#include "softfloat.h"
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Default value for 'softfloat_detectTininess'.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define init_detectTininess softfloat_tininess_afterRounding
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The values to return on conversions to 32-bit integer formats that raise an
|
||||
| invalid exception.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define ui32_fromPosOverflow 0xFFFFFFFF
|
||||
#define ui32_fromNegOverflow 0xFFFFFFFF
|
||||
#define ui32_fromNaN 0xFFFFFFFF
|
||||
#define i32_fromPosOverflow (-0x7FFFFFFF - 1)
|
||||
#define i32_fromNegOverflow (-0x7FFFFFFF - 1)
|
||||
#define i32_fromNaN (-0x7FFFFFFF - 1)
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The values to return on conversions to 64-bit integer formats that raise an
|
||||
| invalid exception.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define ui64_fromPosOverflow UINT64_C(0xFFFFFFFFFFFFFFFF)
|
||||
#define ui64_fromNegOverflow UINT64_C(0xFFFFFFFFFFFFFFFF)
|
||||
#define ui64_fromNaN UINT64_C(0xFFFFFFFFFFFFFFFF)
|
||||
#define i64_fromPosOverflow (-INT64_C(0x7FFFFFFFFFFFFFFF) - 1)
|
||||
#define i64_fromNegOverflow (-INT64_C(0x7FFFFFFFFFFFFFFF) - 1)
|
||||
#define i64_fromNaN (-INT64_C(0x7FFFFFFFFFFFFFFF) - 1)
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| "Common NaN" structure, used to transfer NaN representations from one format
|
||||
| to another.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct commonNaN {
|
||||
bool sign;
|
||||
#ifdef LITTLEENDIAN
|
||||
uint64_t v0, v64;
|
||||
#else
|
||||
uint64_t v64, v0;
|
||||
#endif
|
||||
};
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 16-bit floating-point NaN.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define defaultNaNF16UI 0xFE00
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Returns true when 16-bit unsigned integer 'uiA' has the bit pattern of a
|
||||
| 16-bit floating-point signaling NaN.
|
||||
| Note: This macro evaluates its argument more than once.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_isSigNaNF16UI(uiA) ((((uiA)&0x7E00) == 0x7C00) && ((uiA)&0x01FF))
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming 'uiA' has the bit pattern of a 16-bit floating-point NaN, converts
|
||||
| this NaN to the common NaN form, and stores the resulting common NaN at the
|
||||
| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f16UIToCommonNaN(uint_fast16_t uiA, struct commonNaN* zPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast16_t softfloat_commonNaNToF16UI(const struct commonNaN* aPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting 'uiA' and 'uiB' as the bit patterns of two 16-bit floating-
|
||||
| point values, at least one of which is a NaN, returns the bit pattern of
|
||||
| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
|
||||
| signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast16_t softfloat_propagateNaNF16UI(uint_fast16_t uiA, uint_fast16_t uiB);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Returns true when 16-bit unsigned integer 'uiA' has the bit pattern of a
|
||||
| 16-bit brain floating-point (BF16) signaling NaN.
|
||||
| Note: This macro evaluates its argument more than once.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_isSigNaNBF16UI(uiA) ((((uiA)&0x7FC0) == 0x7F80) && ((uiA)&0x003F))
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming 'uiA' has the bit pattern of a 16-bit BF16 floating-point NaN, converts
|
||||
| this NaN to the common NaN form, and stores the resulting common NaN at the
|
||||
| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_bf16UIToCommonNaN(uint_fast16_t uiA, struct commonNaN* zPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast16_t softfloat_commonNaNToBF16UI(const struct commonNaN* aPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 32-bit floating-point NaN.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define defaultNaNF32UI 0xFFC00000
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Returns true when 32-bit unsigned integer 'uiA' has the bit pattern of a
|
||||
| 32-bit floating-point signaling NaN.
|
||||
| Note: This macro evaluates its argument more than once.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_isSigNaNF32UI(uiA) ((((uiA)&0x7FC00000) == 0x7F800000) && ((uiA)&0x003FFFFF))
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming 'uiA' has the bit pattern of a 32-bit floating-point NaN, converts
|
||||
| this NaN to the common NaN form, and stores the resulting common NaN at the
|
||||
| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f32UIToCommonNaN(uint_fast32_t uiA, struct commonNaN* zPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 32-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast32_t softfloat_commonNaNToF32UI(const struct commonNaN* aPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting 'uiA' and 'uiB' as the bit patterns of two 32-bit floating-
|
||||
| point values, at least one of which is a NaN, returns the bit pattern of
|
||||
| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
|
||||
| signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast32_t softfloat_propagateNaNF32UI(uint_fast32_t uiA, uint_fast32_t uiB);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 64-bit floating-point NaN.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define defaultNaNF64UI UINT64_C(0xFFF8000000000000)
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Returns true when 64-bit unsigned integer 'uiA' has the bit pattern of a
|
||||
| 64-bit floating-point signaling NaN.
|
||||
| Note: This macro evaluates its argument more than once.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_isSigNaNF64UI(uiA) \
|
||||
((((uiA)&UINT64_C(0x7FF8000000000000)) == UINT64_C(0x7FF0000000000000)) && ((uiA)&UINT64_C(0x0007FFFFFFFFFFFF)))
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming 'uiA' has the bit pattern of a 64-bit floating-point NaN, converts
|
||||
| this NaN to the common NaN form, and stores the resulting common NaN at the
|
||||
| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f64UIToCommonNaN(uint_fast64_t uiA, struct commonNaN* zPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 64-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast64_t softfloat_commonNaNToF64UI(const struct commonNaN* aPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting 'uiA' and 'uiB' as the bit patterns of two 64-bit floating-
|
||||
| point values, at least one of which is a NaN, returns the bit pattern of
|
||||
| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
|
||||
| signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast64_t softfloat_propagateNaNF64UI(uint_fast64_t uiA, uint_fast64_t uiB);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 80-bit extended floating-point NaN.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define defaultNaNExtF80UI64 0xFFFF
|
||||
#define defaultNaNExtF80UI0 UINT64_C(0xC000000000000000)
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Returns true when the 80-bit unsigned integer formed from concatenating
|
||||
| 16-bit 'uiA64' and 64-bit 'uiA0' has the bit pattern of an 80-bit extended
|
||||
| floating-point signaling NaN.
|
||||
| Note: This macro evaluates its arguments more than once.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_isSigNaNExtF80UI(uiA64, uiA0) \
|
||||
((((uiA64)&0x7FFF) == 0x7FFF) && !((uiA0)&UINT64_C(0x4000000000000000)) && ((uiA0)&UINT64_C(0x3FFFFFFFFFFFFFFF)))
|
||||
|
||||
#ifdef SOFTFLOAT_FAST_INT64
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is
|
||||
| defined.
|
||||
*----------------------------------------------------------------------------*/
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
|
||||
| has the bit pattern of an 80-bit extended floating-point NaN, converts
|
||||
| this NaN to the common NaN form, and stores the resulting common NaN at the
|
||||
| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_extF80UIToCommonNaN(uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN* zPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
|
||||
| floating-point NaN, and returns the bit pattern of this value as an unsigned
|
||||
| integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128 softfloat_commonNaNToExtF80UI(const struct commonNaN* aPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting the unsigned integer formed from concatenating 'uiA64' and
|
||||
| 'uiA0' as an 80-bit extended floating-point value, and likewise interpreting
|
||||
| the unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
|
||||
| 80-bit extended floating-point value, and assuming at least on of these
|
||||
| floating-point values is a NaN, returns the bit pattern of the combined NaN
|
||||
| result. If either original floating-point value is a signaling NaN, the
|
||||
| invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128 softfloat_propagateNaNExtF80UI(uint_fast16_t uiA64, uint_fast64_t uiA0, uint_fast16_t uiB64, uint_fast64_t uiB0);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 128-bit floating-point NaN.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define defaultNaNF128UI64 UINT64_C(0xFFFF800000000000)
|
||||
#define defaultNaNF128UI0 UINT64_C(0)
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Returns true when the 128-bit unsigned integer formed from concatenating
|
||||
| 64-bit 'uiA64' and 64-bit 'uiA0' has the bit pattern of a 128-bit floating-
|
||||
| point signaling NaN.
|
||||
| Note: This macro evaluates its arguments more than once.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_isSigNaNF128UI(uiA64, uiA0) \
|
||||
((((uiA64)&UINT64_C(0x7FFF800000000000)) == UINT64_C(0x7FFF000000000000)) && ((uiA0) || ((uiA64)&UINT64_C(0x00007FFFFFFFFFFF))))
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
|
||||
| has the bit pattern of a 128-bit floating-point NaN, converts this NaN to
|
||||
| the common NaN form, and stores the resulting common NaN at the location
|
||||
| pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid exception
|
||||
| is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f128UIToCommonNaN(uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN* zPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128 softfloat_commonNaNToF128UI(const struct commonNaN*);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting the unsigned integer formed from concatenating 'uiA64' and
|
||||
| 'uiA0' as a 128-bit floating-point value, and likewise interpreting the
|
||||
| unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
|
||||
| 128-bit floating-point value, and assuming at least on of these floating-
|
||||
| point values is a NaN, returns the bit pattern of the combined NaN result.
|
||||
| If either original floating-point value is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128 softfloat_propagateNaNF128UI(uint_fast64_t uiA64, uint_fast64_t uiA0, uint_fast64_t uiB64, uint_fast64_t uiB0);
|
||||
|
||||
#else
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is not
|
||||
| defined.
|
||||
*----------------------------------------------------------------------------*/
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming the 80-bit extended floating-point value pointed to by 'aSPtr' is
|
||||
| a NaN, converts this NaN to the common NaN form, and stores the resulting
|
||||
| common NaN at the location pointed to by 'zPtr'. If the NaN is a signaling
|
||||
| NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_extF80MToCommonNaN(const struct extFloat80M* aSPtr, struct commonNaN* zPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
|
||||
| floating-point NaN, and stores this NaN at the location pointed to by
|
||||
| 'zSPtr'.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_commonNaNToExtF80M(const struct commonNaN* aPtr, struct extFloat80M* zSPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming at least one of the two 80-bit extended floating-point values
|
||||
| pointed to by 'aSPtr' and 'bSPtr' is a NaN, stores the combined NaN result
|
||||
| at the location pointed to by 'zSPtr'. If either original floating-point
|
||||
| value is a signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_propagateNaNExtF80M(const struct extFloat80M* aSPtr, const struct extFloat80M* bSPtr, struct extFloat80M* zSPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 128-bit floating-point NaN.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define defaultNaNF128UI96 0xFFFF8000
|
||||
#define defaultNaNF128UI64 0
|
||||
#define defaultNaNF128UI32 0
|
||||
#define defaultNaNF128UI0 0
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming the 128-bit floating-point value pointed to by 'aWPtr' is a NaN,
|
||||
| converts this NaN to the common NaN form, and stores the resulting common
|
||||
| NaN at the location pointed to by 'zPtr'. If the NaN is a signaling NaN,
|
||||
| the invalid exception is raised. Argument 'aWPtr' points to an array of
|
||||
| four 32-bit elements that concatenate in the platform's normal endian order
|
||||
| to form a 128-bit floating-point value.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f128MToCommonNaN(const uint32_t* aWPtr, struct commonNaN* zPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
|
||||
| NaN, and stores this NaN at the location pointed to by 'zWPtr'. Argument
|
||||
| 'zWPtr' points to an array of four 32-bit elements that concatenate in the
|
||||
| platform's normal endian order to form a 128-bit floating-point value.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_commonNaNToF128M(const struct commonNaN* aPtr, uint32_t* zWPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming at least one of the two 128-bit floating-point values pointed to by
|
||||
| 'aWPtr' and 'bWPtr' is a NaN, stores the combined NaN result at the location
|
||||
| pointed to by 'zWPtr'. If either original floating-point value is a
|
||||
| signaling NaN, the invalid exception is raised. Each of 'aWPtr', 'bWPtr',
|
||||
| and 'zWPtr' points to an array of four 32-bit elements that concatenate in
|
||||
| the platform's normal endian order to form a 128-bit floating-point value.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_propagateNaNF128M(const uint32_t* aWPtr, const uint32_t* bWPtr, uint32_t* zWPtr);
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
@ -1,57 +1,57 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
bool extF80M_isSignalingNaN( const extFloat80_t *aPtr )
|
||||
{
|
||||
const struct extFloat80M *aSPtr;
|
||||
uint64_t uiA0;
|
||||
|
||||
aSPtr = (const struct extFloat80M *) aPtr;
|
||||
if ( (aSPtr->signExp & 0x7FFF) != 0x7FFF ) return false;
|
||||
uiA0 = aSPtr->signif;
|
||||
return
|
||||
! (uiA0 & UINT64_C( 0x4000000000000000 ))
|
||||
&& (uiA0 & UINT64_C( 0x3FFFFFFFFFFFFFFF));
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
bool extF80M_isSignalingNaN( const extFloat80_t *aPtr )
|
||||
{
|
||||
const struct extFloat80M *aSPtr;
|
||||
uint64_t uiA0;
|
||||
|
||||
aSPtr = (const struct extFloat80M *) aPtr;
|
||||
if ( (aSPtr->signExp & 0x7FFF) != 0x7FFF ) return false;
|
||||
uiA0 = aSPtr->signif;
|
||||
return
|
||||
! (uiA0 & UINT64_C( 0x4000000000000000 ))
|
||||
&& (uiA0 & UINT64_C( 0x3FFFFFFFFFFFFFFF));
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,60 +1,60 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "primitives.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
bool f128M_isSignalingNaN( const float128_t *aPtr )
|
||||
{
|
||||
const uint32_t *aWPtr;
|
||||
uint32_t uiA96;
|
||||
|
||||
aWPtr = (const uint32_t *) aPtr;
|
||||
uiA96 = aWPtr[indexWordHi( 4 )];
|
||||
if ( (uiA96 & 0x7FFF8000) != 0x7FFF0000 ) return false;
|
||||
return
|
||||
((uiA96 & 0x00007FFF) != 0)
|
||||
|| ((aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )]
|
||||
| aWPtr[indexWord( 4, 0 )])
|
||||
!= 0);
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "primitives.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
bool f128M_isSignalingNaN( const float128_t *aPtr )
|
||||
{
|
||||
const uint32_t *aWPtr;
|
||||
uint32_t uiA96;
|
||||
|
||||
aWPtr = (const uint32_t *) aPtr;
|
||||
uiA96 = aWPtr[indexWordHi( 4 )];
|
||||
if ( (uiA96 & 0x7FFF8000) != 0x7FFF0000 ) return false;
|
||||
return
|
||||
((uiA96 & 0x00007FFF) != 0)
|
||||
|| ((aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )]
|
||||
| aWPtr[indexWord( 4, 0 )])
|
||||
!= 0);
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,56 +1,56 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "specialize.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by `aPtr' into an 80-bit extended
|
||||
| floating-point NaN, and stores this NaN at the location pointed to by
|
||||
| `zSPtr'.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void
|
||||
softfloat_commonNaNToExtF80M(
|
||||
const struct commonNaN *aPtr, struct extFloat80M *zSPtr )
|
||||
{
|
||||
|
||||
zSPtr->signExp = packToExtF80UI64( aPtr->sign, 0x7FFF );
|
||||
zSPtr->signif = UINT64_C( 0xC000000000000000 ) | aPtr->v64>>1;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "specialize.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by `aPtr' into an 80-bit extended
|
||||
| floating-point NaN, and stores this NaN at the location pointed to by
|
||||
| `zSPtr'.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void
|
||||
softfloat_commonNaNToExtF80M(
|
||||
const struct commonNaN *aPtr, struct extFloat80M *zSPtr )
|
||||
{
|
||||
|
||||
zSPtr->signExp = packToExtF80UI64( aPtr->sign, 0x7FFF );
|
||||
zSPtr->signif = UINT64_C( 0xC000000000000000 ) | aPtr->v64>>1;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,56 +1,56 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "primitives.h"
|
||||
#include "specialize.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by `aPtr' into an 80-bit extended
|
||||
| floating-point NaN, and returns the bit pattern of this value as an unsigned
|
||||
| integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr )
|
||||
{
|
||||
struct uint128 uiZ;
|
||||
|
||||
uiZ.v64 = (uint_fast16_t) aPtr->sign<<15 | 0x7FFF;
|
||||
uiZ.v0 = UINT64_C( 0xC000000000000000 ) | aPtr->v64>>1;
|
||||
return uiZ;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "primitives.h"
|
||||
#include "specialize.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by `aPtr' into an 80-bit extended
|
||||
| floating-point NaN, and returns the bit pattern of this value as an unsigned
|
||||
| integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr )
|
||||
{
|
||||
struct uint128 uiZ;
|
||||
|
||||
uiZ.v64 = (uint_fast16_t) aPtr->sign<<15 | 0x7FFF;
|
||||
uiZ.v0 = UINT64_C( 0xC000000000000000 ) | aPtr->v64>>1;
|
||||
return uiZ;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,56 +1,56 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "primitives.h"
|
||||
#include "specialize.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by `aPtr' into a 128-bit floating-point
|
||||
| NaN, and stores this NaN at the location pointed to by `zWPtr'. Argument
|
||||
| `zWPtr' points to an array of four 32-bit elements that concatenate in the
|
||||
| platform's normal endian order to form a 128-bit floating-point value.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void
|
||||
softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr )
|
||||
{
|
||||
|
||||
softfloat_shortShiftRight128M( (const uint32_t *) &aPtr->v0, 16, zWPtr );
|
||||
zWPtr[indexWordHi( 4 )] |= (uint32_t) aPtr->sign<<31 | 0x7FFF8000;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "primitives.h"
|
||||
#include "specialize.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by `aPtr' into a 128-bit floating-point
|
||||
| NaN, and stores this NaN at the location pointed to by `zWPtr'. Argument
|
||||
| `zWPtr' points to an array of four 32-bit elements that concatenate in the
|
||||
| platform's normal endian order to form a 128-bit floating-point value.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void
|
||||
softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr )
|
||||
{
|
||||
|
||||
softfloat_shortShiftRight128M( (const uint32_t *) &aPtr->v0, 16, zWPtr );
|
||||
zWPtr[indexWordHi( 4 )] |= (uint32_t) aPtr->sign<<31 | 0x7FFF8000;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,55 +1,55 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "primitives.h"
|
||||
#include "specialize.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by `aPtr' into a 128-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN *aPtr )
|
||||
{
|
||||
struct uint128 uiZ;
|
||||
|
||||
uiZ = softfloat_shortShiftRight128( aPtr->v64, aPtr->v0, 16 );
|
||||
uiZ.v64 |= (uint_fast64_t) aPtr->sign<<63 | UINT64_C( 0x7FFF800000000000 );
|
||||
return uiZ;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "primitives.h"
|
||||
#include "specialize.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by `aPtr' into a 128-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN *aPtr )
|
||||
{
|
||||
struct uint128 uiZ;
|
||||
|
||||
uiZ = softfloat_shortShiftRight128( aPtr->v64, aPtr->v0, 16 );
|
||||
uiZ.v64 |= (uint_fast64_t) aPtr->sign<<63 | UINT64_C( 0x7FFF800000000000 );
|
||||
return uiZ;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,51 +1,51 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "specialize.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by `aPtr' into a 16-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast16_t softfloat_commonNaNToF16UI( const struct commonNaN *aPtr )
|
||||
{
|
||||
|
||||
return (uint_fast16_t) aPtr->sign<<15 | 0x7E00 | aPtr->v64>>54;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "specialize.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by `aPtr' into a 16-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast16_t softfloat_commonNaNToF16UI( const struct commonNaN *aPtr )
|
||||
{
|
||||
|
||||
return (uint_fast16_t) aPtr->sign<<15 | 0x7E00 | aPtr->v64>>54;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,51 +1,51 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "specialize.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by `aPtr' into a 32-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast32_t softfloat_commonNaNToF32UI( const struct commonNaN *aPtr )
|
||||
{
|
||||
|
||||
return (uint_fast32_t) aPtr->sign<<31 | 0x7FC00000 | aPtr->v64>>41;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "specialize.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by `aPtr' into a 32-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast32_t softfloat_commonNaNToF32UI( const struct commonNaN *aPtr )
|
||||
{
|
||||
|
||||
return (uint_fast32_t) aPtr->sign<<31 | 0x7FC00000 | aPtr->v64>>41;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,53 +1,53 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "specialize.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by `aPtr' into a 64-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast64_t softfloat_commonNaNToF64UI( const struct commonNaN *aPtr )
|
||||
{
|
||||
|
||||
return
|
||||
(uint_fast64_t) aPtr->sign<<63 | UINT64_C( 0x7FF8000000000000 )
|
||||
| aPtr->v64>>12;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "specialize.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by `aPtr' into a 64-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast64_t softfloat_commonNaNToF64UI( const struct commonNaN *aPtr )
|
||||
{
|
||||
|
||||
return
|
||||
(uint_fast64_t) aPtr->sign<<63 | UINT64_C( 0x7FF8000000000000 )
|
||||
| aPtr->v64>>12;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,62 +1,62 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming the 80-bit extended floating-point value pointed to by `aSPtr' is
|
||||
| a NaN, converts this NaN to the common NaN form, and stores the resulting
|
||||
| common NaN at the location pointed to by `zPtr'. If the NaN is a signaling
|
||||
| NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void
|
||||
softfloat_extF80MToCommonNaN(
|
||||
const struct extFloat80M *aSPtr, struct commonNaN *zPtr )
|
||||
{
|
||||
|
||||
if ( extF80M_isSignalingNaN( (const extFloat80_t *) aSPtr ) ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
}
|
||||
zPtr->sign = signExtF80UI64( aSPtr->signExp );
|
||||
zPtr->v64 = aSPtr->signif<<1;
|
||||
zPtr->v0 = 0;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming the 80-bit extended floating-point value pointed to by `aSPtr' is
|
||||
| a NaN, converts this NaN to the common NaN form, and stores the resulting
|
||||
| common NaN at the location pointed to by `zPtr'. If the NaN is a signaling
|
||||
| NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void
|
||||
softfloat_extF80MToCommonNaN(
|
||||
const struct extFloat80M *aSPtr, struct commonNaN *zPtr )
|
||||
{
|
||||
|
||||
if ( extF80M_isSignalingNaN( (const extFloat80_t *) aSPtr ) ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
}
|
||||
zPtr->sign = signExtF80UI64( aSPtr->signExp );
|
||||
zPtr->v64 = aSPtr->signif<<1;
|
||||
zPtr->v0 = 0;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,62 +1,62 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming the unsigned integer formed from concatenating `uiA64' and `uiA0'
|
||||
| has the bit pattern of an 80-bit extended floating-point NaN, converts
|
||||
| this NaN to the common NaN form, and stores the resulting common NaN at the
|
||||
| location pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void
|
||||
softfloat_extF80UIToCommonNaN(
|
||||
uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )
|
||||
{
|
||||
|
||||
if ( softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
}
|
||||
zPtr->sign = uiA64>>15;
|
||||
zPtr->v64 = uiA0<<1;
|
||||
zPtr->v0 = 0;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming the unsigned integer formed from concatenating `uiA64' and `uiA0'
|
||||
| has the bit pattern of an 80-bit extended floating-point NaN, converts
|
||||
| this NaN to the common NaN form, and stores the resulting common NaN at the
|
||||
| location pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void
|
||||
softfloat_extF80UIToCommonNaN(
|
||||
uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )
|
||||
{
|
||||
|
||||
if ( softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
}
|
||||
zPtr->sign = uiA64>>15;
|
||||
zPtr->v64 = uiA0<<1;
|
||||
zPtr->v0 = 0;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,62 +1,62 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "primitives.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming the 128-bit floating-point value pointed to by `aWPtr' is a NaN,
|
||||
| converts this NaN to the common NaN form, and stores the resulting common
|
||||
| NaN at the location pointed to by `zPtr'. If the NaN is a signaling NaN,
|
||||
| the invalid exception is raised. Argument `aWPtr' points to an array of
|
||||
| four 32-bit elements that concatenate in the platform's normal endian order
|
||||
| to form a 128-bit floating-point value.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void
|
||||
softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr )
|
||||
{
|
||||
|
||||
if ( f128M_isSignalingNaN( (const float128_t *) aWPtr ) ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
}
|
||||
zPtr->sign = aWPtr[indexWordHi( 4 )]>>31;
|
||||
softfloat_shortShiftLeft128M( aWPtr, 16, (uint32_t *) &zPtr->v0 );
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "primitives.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming the 128-bit floating-point value pointed to by `aWPtr' is a NaN,
|
||||
| converts this NaN to the common NaN form, and stores the resulting common
|
||||
| NaN at the location pointed to by `zPtr'. If the NaN is a signaling NaN,
|
||||
| the invalid exception is raised. Argument `aWPtr' points to an array of
|
||||
| four 32-bit elements that concatenate in the platform's normal endian order
|
||||
| to form a 128-bit floating-point value.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void
|
||||
softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr )
|
||||
{
|
||||
|
||||
if ( f128M_isSignalingNaN( (const float128_t *) aWPtr ) ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
}
|
||||
zPtr->sign = aWPtr[indexWordHi( 4 )]>>31;
|
||||
softfloat_shortShiftLeft128M( aWPtr, 16, (uint32_t *) &zPtr->v0 );
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,65 +1,65 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "primitives.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming the unsigned integer formed from concatenating `uiA64' and `uiA0'
|
||||
| has the bit pattern of a 128-bit floating-point NaN, converts this NaN to
|
||||
| the common NaN form, and stores the resulting common NaN at the location
|
||||
| pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid exception
|
||||
| is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void
|
||||
softfloat_f128UIToCommonNaN(
|
||||
uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )
|
||||
{
|
||||
struct uint128 NaNSig;
|
||||
|
||||
if ( softfloat_isSigNaNF128UI( uiA64, uiA0 ) ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
}
|
||||
NaNSig = softfloat_shortShiftLeft128( uiA64, uiA0, 16 );
|
||||
zPtr->sign = uiA64>>63;
|
||||
zPtr->v64 = NaNSig.v64;
|
||||
zPtr->v0 = NaNSig.v0;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "primitives.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming the unsigned integer formed from concatenating `uiA64' and `uiA0'
|
||||
| has the bit pattern of a 128-bit floating-point NaN, converts this NaN to
|
||||
| the common NaN form, and stores the resulting common NaN at the location
|
||||
| pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid exception
|
||||
| is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void
|
||||
softfloat_f128UIToCommonNaN(
|
||||
uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )
|
||||
{
|
||||
struct uint128 NaNSig;
|
||||
|
||||
if ( softfloat_isSigNaNF128UI( uiA64, uiA0 ) ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
}
|
||||
NaNSig = softfloat_shortShiftLeft128( uiA64, uiA0, 16 );
|
||||
zPtr->sign = uiA64>>63;
|
||||
zPtr->v64 = NaNSig.v64;
|
||||
zPtr->v0 = NaNSig.v0;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,59 +1,59 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming `uiA' has the bit pattern of a 16-bit floating-point NaN, converts
|
||||
| this NaN to the common NaN form, and stores the resulting common NaN at the
|
||||
| location pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr )
|
||||
{
|
||||
|
||||
if ( softfloat_isSigNaNF16UI( uiA ) ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
}
|
||||
zPtr->sign = uiA>>15;
|
||||
zPtr->v64 = (uint_fast64_t) uiA<<54;
|
||||
zPtr->v0 = 0;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming `uiA' has the bit pattern of a 16-bit floating-point NaN, converts
|
||||
| this NaN to the common NaN form, and stores the resulting common NaN at the
|
||||
| location pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr )
|
||||
{
|
||||
|
||||
if ( softfloat_isSigNaNF16UI( uiA ) ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
}
|
||||
zPtr->sign = uiA>>15;
|
||||
zPtr->v64 = (uint_fast64_t) uiA<<54;
|
||||
zPtr->v0 = 0;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,59 +1,59 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming `uiA' has the bit pattern of a 32-bit floating-point NaN, converts
|
||||
| this NaN to the common NaN form, and stores the resulting common NaN at the
|
||||
| location pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr )
|
||||
{
|
||||
|
||||
if ( softfloat_isSigNaNF32UI( uiA ) ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
}
|
||||
zPtr->sign = uiA>>31;
|
||||
zPtr->v64 = (uint_fast64_t) uiA<<41;
|
||||
zPtr->v0 = 0;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming `uiA' has the bit pattern of a 32-bit floating-point NaN, converts
|
||||
| this NaN to the common NaN form, and stores the resulting common NaN at the
|
||||
| location pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr )
|
||||
{
|
||||
|
||||
if ( softfloat_isSigNaNF32UI( uiA ) ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
}
|
||||
zPtr->sign = uiA>>31;
|
||||
zPtr->v64 = (uint_fast64_t) uiA<<41;
|
||||
zPtr->v0 = 0;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,59 +1,59 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming `uiA' has the bit pattern of a 64-bit floating-point NaN, converts
|
||||
| this NaN to the common NaN form, and stores the resulting common NaN at the
|
||||
| location pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr )
|
||||
{
|
||||
|
||||
if ( softfloat_isSigNaNF64UI( uiA ) ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
}
|
||||
zPtr->sign = uiA>>63;
|
||||
zPtr->v64 = uiA<<12;
|
||||
zPtr->v0 = 0;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming `uiA' has the bit pattern of a 64-bit floating-point NaN, converts
|
||||
| this NaN to the common NaN form, and stores the resulting common NaN at the
|
||||
| location pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr )
|
||||
{
|
||||
|
||||
if ( softfloat_isSigNaNF64UI( uiA ) ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
}
|
||||
zPtr->sign = uiA>>63;
|
||||
zPtr->v64 = uiA<<12;
|
||||
zPtr->v0 = 0;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,107 +1,107 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming at least one of the two 80-bit extended floating-point values
|
||||
| pointed to by `aSPtr' and `bSPtr' is a NaN, stores the combined NaN result
|
||||
| at the location pointed to by `zSPtr'. If either original floating-point
|
||||
| value is a signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void
|
||||
softfloat_propagateNaNExtF80M(
|
||||
const struct extFloat80M *aSPtr,
|
||||
const struct extFloat80M *bSPtr,
|
||||
struct extFloat80M *zSPtr
|
||||
)
|
||||
{
|
||||
bool isSigNaNA;
|
||||
const struct extFloat80M *sPtr;
|
||||
bool isSigNaNB;
|
||||
uint_fast16_t uiB64;
|
||||
uint64_t uiB0;
|
||||
uint_fast16_t uiA64;
|
||||
uint64_t uiA0;
|
||||
uint_fast16_t uiMagA64, uiMagB64;
|
||||
|
||||
isSigNaNA = extF80M_isSignalingNaN( (const extFloat80_t *) aSPtr );
|
||||
sPtr = aSPtr;
|
||||
if ( ! bSPtr ) {
|
||||
if ( isSigNaNA ) softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
goto copy;
|
||||
}
|
||||
isSigNaNB = extF80M_isSignalingNaN( (const extFloat80_t *) bSPtr );
|
||||
if ( isSigNaNA | isSigNaNB ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
if ( isSigNaNA ) {
|
||||
uiB64 = bSPtr->signExp;
|
||||
if ( isSigNaNB ) goto returnLargerUIMag;
|
||||
uiB0 = bSPtr->signif;
|
||||
if ( isNaNExtF80UI( uiB64, uiB0 ) ) goto copyB;
|
||||
goto copy;
|
||||
} else {
|
||||
uiA64 = aSPtr->signExp;
|
||||
uiA0 = aSPtr->signif;
|
||||
if ( isNaNExtF80UI( uiA64, uiA0 ) ) goto copy;
|
||||
goto copyB;
|
||||
}
|
||||
}
|
||||
uiB64 = bSPtr->signExp;
|
||||
returnLargerUIMag:
|
||||
uiA64 = aSPtr->signExp;
|
||||
uiMagA64 = uiA64 & 0x7FFF;
|
||||
uiMagB64 = uiB64 & 0x7FFF;
|
||||
if ( uiMagA64 < uiMagB64 ) goto copyB;
|
||||
if ( uiMagB64 < uiMagA64 ) goto copy;
|
||||
uiA0 = aSPtr->signif;
|
||||
uiB0 = bSPtr->signif;
|
||||
if ( uiA0 < uiB0 ) goto copyB;
|
||||
if ( uiB0 < uiA0 ) goto copy;
|
||||
if ( uiA64 < uiB64 ) goto copy;
|
||||
copyB:
|
||||
sPtr = bSPtr;
|
||||
copy:
|
||||
zSPtr->signExp = sPtr->signExp;
|
||||
zSPtr->signif = sPtr->signif | UINT64_C( 0xC000000000000000 );
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming at least one of the two 80-bit extended floating-point values
|
||||
| pointed to by `aSPtr' and `bSPtr' is a NaN, stores the combined NaN result
|
||||
| at the location pointed to by `zSPtr'. If either original floating-point
|
||||
| value is a signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void
|
||||
softfloat_propagateNaNExtF80M(
|
||||
const struct extFloat80M *aSPtr,
|
||||
const struct extFloat80M *bSPtr,
|
||||
struct extFloat80M *zSPtr
|
||||
)
|
||||
{
|
||||
bool isSigNaNA;
|
||||
const struct extFloat80M *sPtr;
|
||||
bool isSigNaNB;
|
||||
uint_fast16_t uiB64;
|
||||
uint64_t uiB0;
|
||||
uint_fast16_t uiA64;
|
||||
uint64_t uiA0;
|
||||
uint_fast16_t uiMagA64, uiMagB64;
|
||||
|
||||
isSigNaNA = extF80M_isSignalingNaN( (const extFloat80_t *) aSPtr );
|
||||
sPtr = aSPtr;
|
||||
if ( ! bSPtr ) {
|
||||
if ( isSigNaNA ) softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
goto copy;
|
||||
}
|
||||
isSigNaNB = extF80M_isSignalingNaN( (const extFloat80_t *) bSPtr );
|
||||
if ( isSigNaNA | isSigNaNB ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
if ( isSigNaNA ) {
|
||||
uiB64 = bSPtr->signExp;
|
||||
if ( isSigNaNB ) goto returnLargerUIMag;
|
||||
uiB0 = bSPtr->signif;
|
||||
if ( isNaNExtF80UI( uiB64, uiB0 ) ) goto copyB;
|
||||
goto copy;
|
||||
} else {
|
||||
uiA64 = aSPtr->signExp;
|
||||
uiA0 = aSPtr->signif;
|
||||
if ( isNaNExtF80UI( uiA64, uiA0 ) ) goto copy;
|
||||
goto copyB;
|
||||
}
|
||||
}
|
||||
uiB64 = bSPtr->signExp;
|
||||
returnLargerUIMag:
|
||||
uiA64 = aSPtr->signExp;
|
||||
uiMagA64 = uiA64 & 0x7FFF;
|
||||
uiMagB64 = uiB64 & 0x7FFF;
|
||||
if ( uiMagA64 < uiMagB64 ) goto copyB;
|
||||
if ( uiMagB64 < uiMagA64 ) goto copy;
|
||||
uiA0 = aSPtr->signif;
|
||||
uiB0 = bSPtr->signif;
|
||||
if ( uiA0 < uiB0 ) goto copyB;
|
||||
if ( uiB0 < uiA0 ) goto copy;
|
||||
if ( uiA64 < uiB64 ) goto copy;
|
||||
copyB:
|
||||
sPtr = bSPtr;
|
||||
copy:
|
||||
zSPtr->signExp = sPtr->signExp;
|
||||
zSPtr->signif = sPtr->signif | UINT64_C( 0xC000000000000000 );
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,106 +1,106 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting the unsigned integer formed from concatenating 'uiA64' and
|
||||
| 'uiA0' as an 80-bit extended floating-point value, and likewise interpreting
|
||||
| the unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
|
||||
| 80-bit extended floating-point value, and assuming at least on of these
|
||||
| floating-point values is a NaN, returns the bit pattern of the combined NaN
|
||||
| result. If either original floating-point value is a signaling NaN, the
|
||||
| invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128
|
||||
softfloat_propagateNaNExtF80UI(
|
||||
uint_fast16_t uiA64,
|
||||
uint_fast64_t uiA0,
|
||||
uint_fast16_t uiB64,
|
||||
uint_fast64_t uiB0
|
||||
)
|
||||
{
|
||||
bool isSigNaNA, isSigNaNB;
|
||||
uint_fast64_t uiNonsigA0, uiNonsigB0;
|
||||
uint_fast16_t uiMagA64, uiMagB64;
|
||||
struct uint128 uiZ;
|
||||
|
||||
/*------------------------------------------------------------------------
|
||||
*------------------------------------------------------------------------*/
|
||||
isSigNaNA = softfloat_isSigNaNExtF80UI( uiA64, uiA0 );
|
||||
isSigNaNB = softfloat_isSigNaNExtF80UI( uiB64, uiB0 );
|
||||
/*------------------------------------------------------------------------
|
||||
| Make NaNs non-signaling.
|
||||
*------------------------------------------------------------------------*/
|
||||
uiNonsigA0 = uiA0 | UINT64_C( 0xC000000000000000 );
|
||||
uiNonsigB0 = uiB0 | UINT64_C( 0xC000000000000000 );
|
||||
/*------------------------------------------------------------------------
|
||||
*------------------------------------------------------------------------*/
|
||||
if ( isSigNaNA | isSigNaNB ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
if ( isSigNaNA ) {
|
||||
if ( isSigNaNB ) goto returnLargerMag;
|
||||
if ( isNaNExtF80UI( uiB64, uiB0 ) ) goto returnB;
|
||||
goto returnA;
|
||||
} else {
|
||||
if ( isNaNExtF80UI( uiA64, uiA0 ) ) goto returnA;
|
||||
goto returnB;
|
||||
}
|
||||
}
|
||||
returnLargerMag:
|
||||
uiMagA64 = uiA64 & 0x7FFF;
|
||||
uiMagB64 = uiB64 & 0x7FFF;
|
||||
if ( uiMagA64 < uiMagB64 ) goto returnB;
|
||||
if ( uiMagB64 < uiMagA64 ) goto returnA;
|
||||
if ( uiA0 < uiB0 ) goto returnB;
|
||||
if ( uiB0 < uiA0 ) goto returnA;
|
||||
if ( uiA64 < uiB64 ) goto returnA;
|
||||
returnB:
|
||||
uiZ.v64 = uiB64;
|
||||
uiZ.v0 = uiNonsigB0;
|
||||
return uiZ;
|
||||
returnA:
|
||||
uiZ.v64 = uiA64;
|
||||
uiZ.v0 = uiNonsigA0;
|
||||
return uiZ;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting the unsigned integer formed from concatenating 'uiA64' and
|
||||
| 'uiA0' as an 80-bit extended floating-point value, and likewise interpreting
|
||||
| the unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
|
||||
| 80-bit extended floating-point value, and assuming at least on of these
|
||||
| floating-point values is a NaN, returns the bit pattern of the combined NaN
|
||||
| result. If either original floating-point value is a signaling NaN, the
|
||||
| invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128
|
||||
softfloat_propagateNaNExtF80UI(
|
||||
uint_fast16_t uiA64,
|
||||
uint_fast64_t uiA0,
|
||||
uint_fast16_t uiB64,
|
||||
uint_fast64_t uiB0
|
||||
)
|
||||
{
|
||||
bool isSigNaNA, isSigNaNB;
|
||||
uint_fast64_t uiNonsigA0, uiNonsigB0;
|
||||
uint_fast16_t uiMagA64, uiMagB64;
|
||||
struct uint128 uiZ;
|
||||
|
||||
/*------------------------------------------------------------------------
|
||||
*------------------------------------------------------------------------*/
|
||||
isSigNaNA = softfloat_isSigNaNExtF80UI( uiA64, uiA0 );
|
||||
isSigNaNB = softfloat_isSigNaNExtF80UI( uiB64, uiB0 );
|
||||
/*------------------------------------------------------------------------
|
||||
| Make NaNs non-signaling.
|
||||
*------------------------------------------------------------------------*/
|
||||
uiNonsigA0 = uiA0 | UINT64_C( 0xC000000000000000 );
|
||||
uiNonsigB0 = uiB0 | UINT64_C( 0xC000000000000000 );
|
||||
/*------------------------------------------------------------------------
|
||||
*------------------------------------------------------------------------*/
|
||||
if ( isSigNaNA | isSigNaNB ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
if ( isSigNaNA ) {
|
||||
if ( isSigNaNB ) goto returnLargerMag;
|
||||
if ( isNaNExtF80UI( uiB64, uiB0 ) ) goto returnB;
|
||||
goto returnA;
|
||||
} else {
|
||||
if ( isNaNExtF80UI( uiA64, uiA0 ) ) goto returnA;
|
||||
goto returnB;
|
||||
}
|
||||
}
|
||||
returnLargerMag:
|
||||
uiMagA64 = uiA64 & 0x7FFF;
|
||||
uiMagB64 = uiB64 & 0x7FFF;
|
||||
if ( uiMagA64 < uiMagB64 ) goto returnB;
|
||||
if ( uiMagB64 < uiMagA64 ) goto returnA;
|
||||
if ( uiA0 < uiB0 ) goto returnB;
|
||||
if ( uiB0 < uiA0 ) goto returnA;
|
||||
if ( uiA64 < uiB64 ) goto returnA;
|
||||
returnB:
|
||||
uiZ.v64 = uiB64;
|
||||
uiZ.v0 = uiNonsigB0;
|
||||
return uiZ;
|
||||
returnA:
|
||||
uiZ.v64 = uiA64;
|
||||
uiZ.v0 = uiNonsigA0;
|
||||
return uiZ;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,108 +1,108 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming at least one of the two 128-bit floating-point values pointed to by
|
||||
| `aWPtr' and `bWPtr' is a NaN, stores the combined NaN result at the location
|
||||
| pointed to by `zWPtr'. If either original floating-point value is a
|
||||
| signaling NaN, the invalid exception is raised. Each of `aWPtr', `bWPtr',
|
||||
| and `zWPtr' points to an array of four 32-bit elements that concatenate in
|
||||
| the platform's normal endian order to form a 128-bit floating-point value.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void
|
||||
softfloat_propagateNaNF128M(
|
||||
const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr )
|
||||
{
|
||||
bool isSigNaNA;
|
||||
const uint32_t *ptr;
|
||||
bool isSigNaNB;
|
||||
uint32_t uiA96, uiB96, wordMagA, wordMagB;
|
||||
|
||||
isSigNaNA = f128M_isSignalingNaN( (const float128_t *) aWPtr );
|
||||
ptr = aWPtr;
|
||||
if ( ! bWPtr ) {
|
||||
if ( isSigNaNA ) softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
goto copy;
|
||||
}
|
||||
isSigNaNB = f128M_isSignalingNaN( (const float128_t *) bWPtr );
|
||||
if ( isSigNaNA | isSigNaNB ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
if ( isSigNaNA ) {
|
||||
if ( isSigNaNB ) goto returnLargerUIMag;
|
||||
if ( softfloat_isNaNF128M( bWPtr ) ) goto copyB;
|
||||
goto copy;
|
||||
} else {
|
||||
if ( softfloat_isNaNF128M( aWPtr ) ) goto copy;
|
||||
goto copyB;
|
||||
}
|
||||
}
|
||||
returnLargerUIMag:
|
||||
uiA96 = aWPtr[indexWordHi( 4 )];
|
||||
uiB96 = bWPtr[indexWordHi( 4 )];
|
||||
wordMagA = uiA96 & 0x7FFFFFFF;
|
||||
wordMagB = uiB96 & 0x7FFFFFFF;
|
||||
if ( wordMagA < wordMagB ) goto copyB;
|
||||
if ( wordMagB < wordMagA ) goto copy;
|
||||
wordMagA = aWPtr[indexWord( 4, 2 )];
|
||||
wordMagB = bWPtr[indexWord( 4, 2 )];
|
||||
if ( wordMagA < wordMagB ) goto copyB;
|
||||
if ( wordMagB < wordMagA ) goto copy;
|
||||
wordMagA = aWPtr[indexWord( 4, 1 )];
|
||||
wordMagB = bWPtr[indexWord( 4, 1 )];
|
||||
if ( wordMagA < wordMagB ) goto copyB;
|
||||
if ( wordMagB < wordMagA ) goto copy;
|
||||
wordMagA = aWPtr[indexWord( 4, 0 )];
|
||||
wordMagB = bWPtr[indexWord( 4, 0 )];
|
||||
if ( wordMagA < wordMagB ) goto copyB;
|
||||
if ( wordMagB < wordMagA ) goto copy;
|
||||
if ( uiA96 < uiB96 ) goto copy;
|
||||
copyB:
|
||||
ptr = bWPtr;
|
||||
copy:
|
||||
zWPtr[indexWordHi( 4 )] = ptr[indexWordHi( 4 )] | 0x00008000;
|
||||
zWPtr[indexWord( 4, 2 )] = ptr[indexWord( 4, 2 )];
|
||||
zWPtr[indexWord( 4, 1 )] = ptr[indexWord( 4, 1 )];
|
||||
zWPtr[indexWord( 4, 0 )] = ptr[indexWord( 4, 0 )];
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming at least one of the two 128-bit floating-point values pointed to by
|
||||
| `aWPtr' and `bWPtr' is a NaN, stores the combined NaN result at the location
|
||||
| pointed to by `zWPtr'. If either original floating-point value is a
|
||||
| signaling NaN, the invalid exception is raised. Each of `aWPtr', `bWPtr',
|
||||
| and `zWPtr' points to an array of four 32-bit elements that concatenate in
|
||||
| the platform's normal endian order to form a 128-bit floating-point value.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void
|
||||
softfloat_propagateNaNF128M(
|
||||
const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr )
|
||||
{
|
||||
bool isSigNaNA;
|
||||
const uint32_t *ptr;
|
||||
bool isSigNaNB;
|
||||
uint32_t uiA96, uiB96, wordMagA, wordMagB;
|
||||
|
||||
isSigNaNA = f128M_isSignalingNaN( (const float128_t *) aWPtr );
|
||||
ptr = aWPtr;
|
||||
if ( ! bWPtr ) {
|
||||
if ( isSigNaNA ) softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
goto copy;
|
||||
}
|
||||
isSigNaNB = f128M_isSignalingNaN( (const float128_t *) bWPtr );
|
||||
if ( isSigNaNA | isSigNaNB ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
if ( isSigNaNA ) {
|
||||
if ( isSigNaNB ) goto returnLargerUIMag;
|
||||
if ( softfloat_isNaNF128M( bWPtr ) ) goto copyB;
|
||||
goto copy;
|
||||
} else {
|
||||
if ( softfloat_isNaNF128M( aWPtr ) ) goto copy;
|
||||
goto copyB;
|
||||
}
|
||||
}
|
||||
returnLargerUIMag:
|
||||
uiA96 = aWPtr[indexWordHi( 4 )];
|
||||
uiB96 = bWPtr[indexWordHi( 4 )];
|
||||
wordMagA = uiA96 & 0x7FFFFFFF;
|
||||
wordMagB = uiB96 & 0x7FFFFFFF;
|
||||
if ( wordMagA < wordMagB ) goto copyB;
|
||||
if ( wordMagB < wordMagA ) goto copy;
|
||||
wordMagA = aWPtr[indexWord( 4, 2 )];
|
||||
wordMagB = bWPtr[indexWord( 4, 2 )];
|
||||
if ( wordMagA < wordMagB ) goto copyB;
|
||||
if ( wordMagB < wordMagA ) goto copy;
|
||||
wordMagA = aWPtr[indexWord( 4, 1 )];
|
||||
wordMagB = bWPtr[indexWord( 4, 1 )];
|
||||
if ( wordMagA < wordMagB ) goto copyB;
|
||||
if ( wordMagB < wordMagA ) goto copy;
|
||||
wordMagA = aWPtr[indexWord( 4, 0 )];
|
||||
wordMagB = bWPtr[indexWord( 4, 0 )];
|
||||
if ( wordMagA < wordMagB ) goto copyB;
|
||||
if ( wordMagB < wordMagA ) goto copy;
|
||||
if ( uiA96 < uiB96 ) goto copy;
|
||||
copyB:
|
||||
ptr = bWPtr;
|
||||
copy:
|
||||
zWPtr[indexWordHi( 4 )] = ptr[indexWordHi( 4 )] | 0x00008000;
|
||||
zWPtr[indexWord( 4, 2 )] = ptr[indexWord( 4, 2 )];
|
||||
zWPtr[indexWord( 4, 1 )] = ptr[indexWord( 4, 1 )];
|
||||
zWPtr[indexWord( 4, 0 )] = ptr[indexWord( 4, 0 )];
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,105 +1,105 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting the unsigned integer formed from concatenating 'uiA64' and
|
||||
| 'uiA0' as a 128-bit floating-point value, and likewise interpreting the
|
||||
| unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
|
||||
| 128-bit floating-point value, and assuming at least on of these floating-
|
||||
| point values is a NaN, returns the bit pattern of the combined NaN result.
|
||||
| If either original floating-point value is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128
|
||||
softfloat_propagateNaNF128UI(
|
||||
uint_fast64_t uiA64,
|
||||
uint_fast64_t uiA0,
|
||||
uint_fast64_t uiB64,
|
||||
uint_fast64_t uiB0
|
||||
)
|
||||
{
|
||||
bool isSigNaNA, isSigNaNB;
|
||||
uint_fast64_t uiNonsigA64, uiNonsigB64, uiMagA64, uiMagB64;
|
||||
struct uint128 uiZ;
|
||||
|
||||
/*------------------------------------------------------------------------
|
||||
*------------------------------------------------------------------------*/
|
||||
isSigNaNA = softfloat_isSigNaNF128UI( uiA64, uiA0 );
|
||||
isSigNaNB = softfloat_isSigNaNF128UI( uiB64, uiB0 );
|
||||
/*------------------------------------------------------------------------
|
||||
| Make NaNs non-signaling.
|
||||
*------------------------------------------------------------------------*/
|
||||
uiNonsigA64 = uiA64 | UINT64_C( 0x0000800000000000 );
|
||||
uiNonsigB64 = uiB64 | UINT64_C( 0x0000800000000000 );
|
||||
/*------------------------------------------------------------------------
|
||||
*------------------------------------------------------------------------*/
|
||||
if ( isSigNaNA | isSigNaNB ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
if ( isSigNaNA ) {
|
||||
if ( isSigNaNB ) goto returnLargerMag;
|
||||
if ( isNaNF128UI( uiB64, uiB0 ) ) goto returnB;
|
||||
goto returnA;
|
||||
} else {
|
||||
if ( isNaNF128UI( uiA64, uiA0 ) ) goto returnA;
|
||||
goto returnB;
|
||||
}
|
||||
}
|
||||
returnLargerMag:
|
||||
uiMagA64 = uiA64 & UINT64_C( 0x7FFFFFFFFFFFFFFF );
|
||||
uiMagB64 = uiB64 & UINT64_C( 0x7FFFFFFFFFFFFFFF );
|
||||
if ( uiMagA64 < uiMagB64 ) goto returnB;
|
||||
if ( uiMagB64 < uiMagA64 ) goto returnA;
|
||||
if ( uiA0 < uiB0 ) goto returnB;
|
||||
if ( uiB0 < uiA0 ) goto returnA;
|
||||
if ( uiNonsigA64 < uiNonsigB64 ) goto returnA;
|
||||
returnB:
|
||||
uiZ.v64 = uiNonsigB64;
|
||||
uiZ.v0 = uiB0;
|
||||
return uiZ;
|
||||
returnA:
|
||||
uiZ.v64 = uiNonsigA64;
|
||||
uiZ.v0 = uiA0;
|
||||
return uiZ;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting the unsigned integer formed from concatenating 'uiA64' and
|
||||
| 'uiA0' as a 128-bit floating-point value, and likewise interpreting the
|
||||
| unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
|
||||
| 128-bit floating-point value, and assuming at least on of these floating-
|
||||
| point values is a NaN, returns the bit pattern of the combined NaN result.
|
||||
| If either original floating-point value is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128
|
||||
softfloat_propagateNaNF128UI(
|
||||
uint_fast64_t uiA64,
|
||||
uint_fast64_t uiA0,
|
||||
uint_fast64_t uiB64,
|
||||
uint_fast64_t uiB0
|
||||
)
|
||||
{
|
||||
bool isSigNaNA, isSigNaNB;
|
||||
uint_fast64_t uiNonsigA64, uiNonsigB64, uiMagA64, uiMagB64;
|
||||
struct uint128 uiZ;
|
||||
|
||||
/*------------------------------------------------------------------------
|
||||
*------------------------------------------------------------------------*/
|
||||
isSigNaNA = softfloat_isSigNaNF128UI( uiA64, uiA0 );
|
||||
isSigNaNB = softfloat_isSigNaNF128UI( uiB64, uiB0 );
|
||||
/*------------------------------------------------------------------------
|
||||
| Make NaNs non-signaling.
|
||||
*------------------------------------------------------------------------*/
|
||||
uiNonsigA64 = uiA64 | UINT64_C( 0x0000800000000000 );
|
||||
uiNonsigB64 = uiB64 | UINT64_C( 0x0000800000000000 );
|
||||
/*------------------------------------------------------------------------
|
||||
*------------------------------------------------------------------------*/
|
||||
if ( isSigNaNA | isSigNaNB ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
if ( isSigNaNA ) {
|
||||
if ( isSigNaNB ) goto returnLargerMag;
|
||||
if ( isNaNF128UI( uiB64, uiB0 ) ) goto returnB;
|
||||
goto returnA;
|
||||
} else {
|
||||
if ( isNaNF128UI( uiA64, uiA0 ) ) goto returnA;
|
||||
goto returnB;
|
||||
}
|
||||
}
|
||||
returnLargerMag:
|
||||
uiMagA64 = uiA64 & UINT64_C( 0x7FFFFFFFFFFFFFFF );
|
||||
uiMagB64 = uiB64 & UINT64_C( 0x7FFFFFFFFFFFFFFF );
|
||||
if ( uiMagA64 < uiMagB64 ) goto returnB;
|
||||
if ( uiMagB64 < uiMagA64 ) goto returnA;
|
||||
if ( uiA0 < uiB0 ) goto returnB;
|
||||
if ( uiB0 < uiA0 ) goto returnA;
|
||||
if ( uiNonsigA64 < uiNonsigB64 ) goto returnA;
|
||||
returnB:
|
||||
uiZ.v64 = uiNonsigB64;
|
||||
uiZ.v0 = uiB0;
|
||||
return uiZ;
|
||||
returnA:
|
||||
uiZ.v64 = uiNonsigA64;
|
||||
uiZ.v0 = uiA0;
|
||||
return uiZ;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,84 +1,84 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2018 The Regents of the
|
||||
University of California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting 'uiA' and 'uiB' as the bit patterns of two 16-bit floating-
|
||||
| point values, at least one of which is a NaN, returns the bit pattern of
|
||||
| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
|
||||
| signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast16_t
|
||||
softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB )
|
||||
{
|
||||
bool isSigNaNA, isSigNaNB;
|
||||
uint_fast16_t uiNonsigA, uiNonsigB, uiMagA, uiMagB;
|
||||
|
||||
/*------------------------------------------------------------------------
|
||||
*------------------------------------------------------------------------*/
|
||||
isSigNaNA = softfloat_isSigNaNF16UI( uiA );
|
||||
isSigNaNB = softfloat_isSigNaNF16UI( uiB );
|
||||
/*------------------------------------------------------------------------
|
||||
| Make NaNs non-signaling.
|
||||
*------------------------------------------------------------------------*/
|
||||
uiNonsigA = uiA | 0x0200;
|
||||
uiNonsigB = uiB | 0x0200;
|
||||
/*------------------------------------------------------------------------
|
||||
*------------------------------------------------------------------------*/
|
||||
if ( isSigNaNA | isSigNaNB ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
if ( isSigNaNA ) {
|
||||
if ( isSigNaNB ) goto returnLargerMag;
|
||||
return isNaNF16UI( uiB ) ? uiNonsigB : uiNonsigA;
|
||||
} else {
|
||||
return isNaNF16UI( uiA ) ? uiNonsigA : uiNonsigB;
|
||||
}
|
||||
}
|
||||
returnLargerMag:
|
||||
uiMagA = uiA & 0x7FFF;
|
||||
uiMagB = uiB & 0x7FFF;
|
||||
if ( uiMagA < uiMagB ) return uiNonsigB;
|
||||
if ( uiMagB < uiMagA ) return uiNonsigA;
|
||||
return (uiNonsigA < uiNonsigB) ? uiNonsigA : uiNonsigB;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2018 The Regents of the
|
||||
University of California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting 'uiA' and 'uiB' as the bit patterns of two 16-bit floating-
|
||||
| point values, at least one of which is a NaN, returns the bit pattern of
|
||||
| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
|
||||
| signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast16_t
|
||||
softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB )
|
||||
{
|
||||
bool isSigNaNA, isSigNaNB;
|
||||
uint_fast16_t uiNonsigA, uiNonsigB, uiMagA, uiMagB;
|
||||
|
||||
/*------------------------------------------------------------------------
|
||||
*------------------------------------------------------------------------*/
|
||||
isSigNaNA = softfloat_isSigNaNF16UI( uiA );
|
||||
isSigNaNB = softfloat_isSigNaNF16UI( uiB );
|
||||
/*------------------------------------------------------------------------
|
||||
| Make NaNs non-signaling.
|
||||
*------------------------------------------------------------------------*/
|
||||
uiNonsigA = uiA | 0x0200;
|
||||
uiNonsigB = uiB | 0x0200;
|
||||
/*------------------------------------------------------------------------
|
||||
*------------------------------------------------------------------------*/
|
||||
if ( isSigNaNA | isSigNaNB ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
if ( isSigNaNA ) {
|
||||
if ( isSigNaNB ) goto returnLargerMag;
|
||||
return isNaNF16UI( uiB ) ? uiNonsigB : uiNonsigA;
|
||||
} else {
|
||||
return isNaNF16UI( uiA ) ? uiNonsigA : uiNonsigB;
|
||||
}
|
||||
}
|
||||
returnLargerMag:
|
||||
uiMagA = uiA & 0x7FFF;
|
||||
uiMagB = uiB & 0x7FFF;
|
||||
if ( uiMagA < uiMagB ) return uiNonsigB;
|
||||
if ( uiMagB < uiMagA ) return uiNonsigA;
|
||||
return (uiNonsigA < uiNonsigB) ? uiNonsigA : uiNonsigB;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,84 +1,84 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting 'uiA' and 'uiB' as the bit patterns of two 32-bit floating-
|
||||
| point values, at least one of which is a NaN, returns the bit pattern of
|
||||
| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
|
||||
| signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast32_t
|
||||
softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB )
|
||||
{
|
||||
bool isSigNaNA, isSigNaNB;
|
||||
uint_fast32_t uiNonsigA, uiNonsigB, uiMagA, uiMagB;
|
||||
|
||||
/*------------------------------------------------------------------------
|
||||
*------------------------------------------------------------------------*/
|
||||
isSigNaNA = softfloat_isSigNaNF32UI( uiA );
|
||||
isSigNaNB = softfloat_isSigNaNF32UI( uiB );
|
||||
/*------------------------------------------------------------------------
|
||||
| Make NaNs non-signaling.
|
||||
*------------------------------------------------------------------------*/
|
||||
uiNonsigA = uiA | 0x00400000;
|
||||
uiNonsigB = uiB | 0x00400000;
|
||||
/*------------------------------------------------------------------------
|
||||
*------------------------------------------------------------------------*/
|
||||
if ( isSigNaNA | isSigNaNB ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
if ( isSigNaNA ) {
|
||||
if ( isSigNaNB ) goto returnLargerMag;
|
||||
return isNaNF32UI( uiB ) ? uiNonsigB : uiNonsigA;
|
||||
} else {
|
||||
return isNaNF32UI( uiA ) ? uiNonsigA : uiNonsigB;
|
||||
}
|
||||
}
|
||||
returnLargerMag:
|
||||
uiMagA = uiA & 0x7FFFFFFF;
|
||||
uiMagB = uiB & 0x7FFFFFFF;
|
||||
if ( uiMagA < uiMagB ) return uiNonsigB;
|
||||
if ( uiMagB < uiMagA ) return uiNonsigA;
|
||||
return (uiNonsigA < uiNonsigB) ? uiNonsigA : uiNonsigB;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting 'uiA' and 'uiB' as the bit patterns of two 32-bit floating-
|
||||
| point values, at least one of which is a NaN, returns the bit pattern of
|
||||
| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
|
||||
| signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast32_t
|
||||
softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB )
|
||||
{
|
||||
bool isSigNaNA, isSigNaNB;
|
||||
uint_fast32_t uiNonsigA, uiNonsigB, uiMagA, uiMagB;
|
||||
|
||||
/*------------------------------------------------------------------------
|
||||
*------------------------------------------------------------------------*/
|
||||
isSigNaNA = softfloat_isSigNaNF32UI( uiA );
|
||||
isSigNaNB = softfloat_isSigNaNF32UI( uiB );
|
||||
/*------------------------------------------------------------------------
|
||||
| Make NaNs non-signaling.
|
||||
*------------------------------------------------------------------------*/
|
||||
uiNonsigA = uiA | 0x00400000;
|
||||
uiNonsigB = uiB | 0x00400000;
|
||||
/*------------------------------------------------------------------------
|
||||
*------------------------------------------------------------------------*/
|
||||
if ( isSigNaNA | isSigNaNB ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
if ( isSigNaNA ) {
|
||||
if ( isSigNaNB ) goto returnLargerMag;
|
||||
return isNaNF32UI( uiB ) ? uiNonsigB : uiNonsigA;
|
||||
} else {
|
||||
return isNaNF32UI( uiA ) ? uiNonsigA : uiNonsigB;
|
||||
}
|
||||
}
|
||||
returnLargerMag:
|
||||
uiMagA = uiA & 0x7FFFFFFF;
|
||||
uiMagB = uiB & 0x7FFFFFFF;
|
||||
if ( uiMagA < uiMagB ) return uiNonsigB;
|
||||
if ( uiMagB < uiMagA ) return uiNonsigA;
|
||||
return (uiNonsigA < uiNonsigB) ? uiNonsigA : uiNonsigB;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,84 +1,84 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting 'uiA' and 'uiB' as the bit patterns of two 64-bit floating-
|
||||
| point values, at least one of which is a NaN, returns the bit pattern of
|
||||
| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
|
||||
| signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast64_t
|
||||
softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB )
|
||||
{
|
||||
bool isSigNaNA, isSigNaNB;
|
||||
uint_fast64_t uiNonsigA, uiNonsigB, uiMagA, uiMagB;
|
||||
|
||||
/*------------------------------------------------------------------------
|
||||
*------------------------------------------------------------------------*/
|
||||
isSigNaNA = softfloat_isSigNaNF64UI( uiA );
|
||||
isSigNaNB = softfloat_isSigNaNF64UI( uiB );
|
||||
/*------------------------------------------------------------------------
|
||||
| Make NaNs non-signaling.
|
||||
*------------------------------------------------------------------------*/
|
||||
uiNonsigA = uiA | UINT64_C( 0x0008000000000000 );
|
||||
uiNonsigB = uiB | UINT64_C( 0x0008000000000000 );
|
||||
/*------------------------------------------------------------------------
|
||||
*------------------------------------------------------------------------*/
|
||||
if ( isSigNaNA | isSigNaNB ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
if ( isSigNaNA ) {
|
||||
if ( isSigNaNB ) goto returnLargerMag;
|
||||
return isNaNF64UI( uiB ) ? uiNonsigB : uiNonsigA;
|
||||
} else {
|
||||
return isNaNF64UI( uiA ) ? uiNonsigA : uiNonsigB;
|
||||
}
|
||||
}
|
||||
returnLargerMag:
|
||||
uiMagA = uiA & UINT64_C( 0x7FFFFFFFFFFFFFFF );
|
||||
uiMagB = uiB & UINT64_C( 0x7FFFFFFFFFFFFFFF );
|
||||
if ( uiMagA < uiMagB ) return uiNonsigB;
|
||||
if ( uiMagB < uiMagA ) return uiNonsigA;
|
||||
return (uiNonsigA < uiNonsigB) ? uiNonsigA : uiNonsigB;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting 'uiA' and 'uiB' as the bit patterns of two 64-bit floating-
|
||||
| point values, at least one of which is a NaN, returns the bit pattern of
|
||||
| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
|
||||
| signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast64_t
|
||||
softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB )
|
||||
{
|
||||
bool isSigNaNA, isSigNaNB;
|
||||
uint_fast64_t uiNonsigA, uiNonsigB, uiMagA, uiMagB;
|
||||
|
||||
/*------------------------------------------------------------------------
|
||||
*------------------------------------------------------------------------*/
|
||||
isSigNaNA = softfloat_isSigNaNF64UI( uiA );
|
||||
isSigNaNB = softfloat_isSigNaNF64UI( uiB );
|
||||
/*------------------------------------------------------------------------
|
||||
| Make NaNs non-signaling.
|
||||
*------------------------------------------------------------------------*/
|
||||
uiNonsigA = uiA | UINT64_C( 0x0008000000000000 );
|
||||
uiNonsigB = uiB | UINT64_C( 0x0008000000000000 );
|
||||
/*------------------------------------------------------------------------
|
||||
*------------------------------------------------------------------------*/
|
||||
if ( isSigNaNA | isSigNaNB ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
if ( isSigNaNA ) {
|
||||
if ( isSigNaNB ) goto returnLargerMag;
|
||||
return isNaNF64UI( uiB ) ? uiNonsigB : uiNonsigA;
|
||||
} else {
|
||||
return isNaNF64UI( uiA ) ? uiNonsigA : uiNonsigB;
|
||||
}
|
||||
}
|
||||
returnLargerMag:
|
||||
uiMagA = uiA & UINT64_C( 0x7FFFFFFFFFFFFFFF );
|
||||
uiMagB = uiB & UINT64_C( 0x7FFFFFFFFFFFFFFF );
|
||||
if ( uiMagA < uiMagB ) return uiNonsigB;
|
||||
if ( uiMagB < uiMagA ) return uiNonsigA;
|
||||
return (uiNonsigA < uiNonsigB) ? uiNonsigA : uiNonsigB;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,52 +1,52 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include "platform.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Raises the exceptions specified by `flags'. Floating-point traps can be
|
||||
| defined here if desired. It is currently not possible for such a trap
|
||||
| to substitute a result value. If traps are not implemented, this routine
|
||||
| should be simply `softfloat_exceptionFlags |= flags;'.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_raiseFlags( uint_fast8_t flags )
|
||||
{
|
||||
|
||||
softfloat_exceptionFlags |= flags;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include "platform.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Raises the exceptions specified by `flags'. Floating-point traps can be
|
||||
| defined here if desired. It is currently not possible for such a trap
|
||||
| to substitute a result value. If traps are not implemented, this routine
|
||||
| should be simply `softfloat_exceptionFlags |= flags;'.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_raiseFlags( uint_fast8_t flags )
|
||||
{
|
||||
|
||||
softfloat_exceptionFlags |= flags;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,346 +1,346 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2018 The Regents of the
|
||||
University of California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#ifndef specialize_h
|
||||
#define specialize_h 1
|
||||
|
||||
#include "primitiveTypes.h"
|
||||
#include "softfloat.h"
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Default value for 'softfloat_detectTininess'.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define init_detectTininess softfloat_tininess_afterRounding
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The values to return on conversions to 32-bit integer formats that raise an
|
||||
| invalid exception.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define ui32_fromPosOverflow 0xFFFFFFFF
|
||||
#define ui32_fromNegOverflow 0xFFFFFFFF
|
||||
#define ui32_fromNaN 0xFFFFFFFF
|
||||
#define i32_fromPosOverflow (-0x7FFFFFFF - 1)
|
||||
#define i32_fromNegOverflow (-0x7FFFFFFF - 1)
|
||||
#define i32_fromNaN (-0x7FFFFFFF - 1)
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The values to return on conversions to 64-bit integer formats that raise an
|
||||
| invalid exception.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define ui64_fromPosOverflow UINT64_C(0xFFFFFFFFFFFFFFFF)
|
||||
#define ui64_fromNegOverflow UINT64_C(0xFFFFFFFFFFFFFFFF)
|
||||
#define ui64_fromNaN UINT64_C(0xFFFFFFFFFFFFFFFF)
|
||||
#define i64_fromPosOverflow (-INT64_C(0x7FFFFFFFFFFFFFFF) - 1)
|
||||
#define i64_fromNegOverflow (-INT64_C(0x7FFFFFFFFFFFFFFF) - 1)
|
||||
#define i64_fromNaN (-INT64_C(0x7FFFFFFFFFFFFFFF) - 1)
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| "Common NaN" structure, used to transfer NaN representations from one format
|
||||
| to another.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct commonNaN {
|
||||
bool sign;
|
||||
#ifdef LITTLEENDIAN
|
||||
uint64_t v0, v64;
|
||||
#else
|
||||
uint64_t v64, v0;
|
||||
#endif
|
||||
};
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 16-bit floating-point NaN.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define defaultNaNF16UI 0xFE00
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Returns true when 16-bit unsigned integer 'uiA' has the bit pattern of a
|
||||
| 16-bit floating-point signaling NaN.
|
||||
| Note: This macro evaluates its argument more than once.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_isSigNaNF16UI(uiA) ((((uiA)&0x7E00) == 0x7C00) && ((uiA)&0x01FF))
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming 'uiA' has the bit pattern of a 16-bit floating-point NaN, converts
|
||||
| this NaN to the common NaN form, and stores the resulting common NaN at the
|
||||
| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f16UIToCommonNaN(uint_fast16_t uiA, struct commonNaN* zPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast16_t softfloat_commonNaNToF16UI(const struct commonNaN* aPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting 'uiA' and 'uiB' as the bit patterns of two 16-bit floating-
|
||||
| point values, at least one of which is a NaN, returns the bit pattern of
|
||||
| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
|
||||
| signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast16_t softfloat_propagateNaNF16UI(uint_fast16_t uiA, uint_fast16_t uiB);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 32-bit floating-point NaN.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define defaultNaNF32UI 0xFFC00000
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Returns true when 32-bit unsigned integer 'uiA' has the bit pattern of a
|
||||
| 32-bit floating-point signaling NaN.
|
||||
| Note: This macro evaluates its argument more than once.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_isSigNaNF32UI(uiA) ((((uiA)&0x7FC00000) == 0x7F800000) && ((uiA)&0x003FFFFF))
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming 'uiA' has the bit pattern of a 32-bit floating-point NaN, converts
|
||||
| this NaN to the common NaN form, and stores the resulting common NaN at the
|
||||
| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f32UIToCommonNaN(uint_fast32_t uiA, struct commonNaN* zPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 32-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast32_t softfloat_commonNaNToF32UI(const struct commonNaN* aPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting 'uiA' and 'uiB' as the bit patterns of two 32-bit floating-
|
||||
| point values, at least one of which is a NaN, returns the bit pattern of
|
||||
| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
|
||||
| signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast32_t softfloat_propagateNaNF32UI(uint_fast32_t uiA, uint_fast32_t uiB);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 64-bit floating-point NaN.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define defaultNaNF64UI UINT64_C(0xFFF8000000000000)
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Returns true when 64-bit unsigned integer 'uiA' has the bit pattern of a
|
||||
| 64-bit floating-point signaling NaN.
|
||||
| Note: This macro evaluates its argument more than once.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_isSigNaNF64UI(uiA) \
|
||||
((((uiA)&UINT64_C(0x7FF8000000000000)) == UINT64_C(0x7FF0000000000000)) && ((uiA)&UINT64_C(0x0007FFFFFFFFFFFF)))
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming 'uiA' has the bit pattern of a 64-bit floating-point NaN, converts
|
||||
| this NaN to the common NaN form, and stores the resulting common NaN at the
|
||||
| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f64UIToCommonNaN(uint_fast64_t uiA, struct commonNaN* zPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 64-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast64_t softfloat_commonNaNToF64UI(const struct commonNaN* aPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting 'uiA' and 'uiB' as the bit patterns of two 64-bit floating-
|
||||
| point values, at least one of which is a NaN, returns the bit pattern of
|
||||
| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
|
||||
| signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast64_t softfloat_propagateNaNF64UI(uint_fast64_t uiA, uint_fast64_t uiB);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 80-bit extended floating-point NaN.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define defaultNaNExtF80UI64 0xFFFF
|
||||
#define defaultNaNExtF80UI0 UINT64_C(0xC000000000000000)
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Returns true when the 80-bit unsigned integer formed from concatenating
|
||||
| 16-bit 'uiA64' and 64-bit 'uiA0' has the bit pattern of an 80-bit extended
|
||||
| floating-point signaling NaN.
|
||||
| Note: This macro evaluates its arguments more than once.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_isSigNaNExtF80UI(uiA64, uiA0) \
|
||||
((((uiA64)&0x7FFF) == 0x7FFF) && !((uiA0)&UINT64_C(0x4000000000000000)) && ((uiA0)&UINT64_C(0x3FFFFFFFFFFFFFFF)))
|
||||
|
||||
#ifdef SOFTFLOAT_FAST_INT64
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is
|
||||
| defined.
|
||||
*----------------------------------------------------------------------------*/
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
|
||||
| has the bit pattern of an 80-bit extended floating-point NaN, converts
|
||||
| this NaN to the common NaN form, and stores the resulting common NaN at the
|
||||
| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_extF80UIToCommonNaN(uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN* zPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
|
||||
| floating-point NaN, and returns the bit pattern of this value as an unsigned
|
||||
| integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128 softfloat_commonNaNToExtF80UI(const struct commonNaN* aPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting the unsigned integer formed from concatenating 'uiA64' and
|
||||
| 'uiA0' as an 80-bit extended floating-point value, and likewise interpreting
|
||||
| the unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
|
||||
| 80-bit extended floating-point value, and assuming at least on of these
|
||||
| floating-point values is a NaN, returns the bit pattern of the combined NaN
|
||||
| result. If either original floating-point value is a signaling NaN, the
|
||||
| invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128 softfloat_propagateNaNExtF80UI(uint_fast16_t uiA64, uint_fast64_t uiA0, uint_fast16_t uiB64, uint_fast64_t uiB0);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 128-bit floating-point NaN.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define defaultNaNF128UI64 UINT64_C(0xFFFF800000000000)
|
||||
#define defaultNaNF128UI0 UINT64_C(0)
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Returns true when the 128-bit unsigned integer formed from concatenating
|
||||
| 64-bit 'uiA64' and 64-bit 'uiA0' has the bit pattern of a 128-bit floating-
|
||||
| point signaling NaN.
|
||||
| Note: This macro evaluates its arguments more than once.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_isSigNaNF128UI(uiA64, uiA0) \
|
||||
((((uiA64)&UINT64_C(0x7FFF800000000000)) == UINT64_C(0x7FFF000000000000)) && ((uiA0) || ((uiA64)&UINT64_C(0x00007FFFFFFFFFFF))))
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
|
||||
| has the bit pattern of a 128-bit floating-point NaN, converts this NaN to
|
||||
| the common NaN form, and stores the resulting common NaN at the location
|
||||
| pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid exception
|
||||
| is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f128UIToCommonNaN(uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN* zPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128 softfloat_commonNaNToF128UI(const struct commonNaN*);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting the unsigned integer formed from concatenating 'uiA64' and
|
||||
| 'uiA0' as a 128-bit floating-point value, and likewise interpreting the
|
||||
| unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
|
||||
| 128-bit floating-point value, and assuming at least on of these floating-
|
||||
| point values is a NaN, returns the bit pattern of the combined NaN result.
|
||||
| If either original floating-point value is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128 softfloat_propagateNaNF128UI(uint_fast64_t uiA64, uint_fast64_t uiA0, uint_fast64_t uiB64, uint_fast64_t uiB0);
|
||||
|
||||
#else
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is not
|
||||
| defined.
|
||||
*----------------------------------------------------------------------------*/
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming the 80-bit extended floating-point value pointed to by 'aSPtr' is
|
||||
| a NaN, converts this NaN to the common NaN form, and stores the resulting
|
||||
| common NaN at the location pointed to by 'zPtr'. If the NaN is a signaling
|
||||
| NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_extF80MToCommonNaN(const struct extFloat80M* aSPtr, struct commonNaN* zPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
|
||||
| floating-point NaN, and stores this NaN at the location pointed to by
|
||||
| 'zSPtr'.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_commonNaNToExtF80M(const struct commonNaN* aPtr, struct extFloat80M* zSPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming at least one of the two 80-bit extended floating-point values
|
||||
| pointed to by 'aSPtr' and 'bSPtr' is a NaN, stores the combined NaN result
|
||||
| at the location pointed to by 'zSPtr'. If either original floating-point
|
||||
| value is a signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_propagateNaNExtF80M(const struct extFloat80M* aSPtr, const struct extFloat80M* bSPtr, struct extFloat80M* zSPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 128-bit floating-point NaN.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define defaultNaNF128UI96 0xFFFF8000
|
||||
#define defaultNaNF128UI64 0
|
||||
#define defaultNaNF128UI32 0
|
||||
#define defaultNaNF128UI0 0
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming the 128-bit floating-point value pointed to by 'aWPtr' is a NaN,
|
||||
| converts this NaN to the common NaN form, and stores the resulting common
|
||||
| NaN at the location pointed to by 'zPtr'. If the NaN is a signaling NaN,
|
||||
| the invalid exception is raised. Argument 'aWPtr' points to an array of
|
||||
| four 32-bit elements that concatenate in the platform's normal endian order
|
||||
| to form a 128-bit floating-point value.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f128MToCommonNaN(const uint32_t* aWPtr, struct commonNaN* zPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
|
||||
| NaN, and stores this NaN at the location pointed to by 'zWPtr'. Argument
|
||||
| 'zWPtr' points to an array of four 32-bit elements that concatenate in the
|
||||
| platform's normal endian order to form a 128-bit floating-point value.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_commonNaNToF128M(const struct commonNaN* aPtr, uint32_t* zWPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming at least one of the two 128-bit floating-point values pointed to by
|
||||
| 'aWPtr' and 'bWPtr' is a NaN, stores the combined NaN result at the location
|
||||
| pointed to by 'zWPtr'. If either original floating-point value is a
|
||||
| signaling NaN, the invalid exception is raised. Each of 'aWPtr', 'bWPtr',
|
||||
| and 'zWPtr' points to an array of four 32-bit elements that concatenate in
|
||||
| the platform's normal endian order to form a 128-bit floating-point value.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_propagateNaNF128M(const uint32_t* aWPtr, const uint32_t* bWPtr, uint32_t* zWPtr);
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2018 The Regents of the
|
||||
University of California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#ifndef specialize_h
|
||||
#define specialize_h 1
|
||||
|
||||
#include "primitiveTypes.h"
|
||||
#include "softfloat.h"
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Default value for 'softfloat_detectTininess'.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define init_detectTininess softfloat_tininess_afterRounding
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The values to return on conversions to 32-bit integer formats that raise an
|
||||
| invalid exception.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define ui32_fromPosOverflow 0xFFFFFFFF
|
||||
#define ui32_fromNegOverflow 0xFFFFFFFF
|
||||
#define ui32_fromNaN 0xFFFFFFFF
|
||||
#define i32_fromPosOverflow (-0x7FFFFFFF - 1)
|
||||
#define i32_fromNegOverflow (-0x7FFFFFFF - 1)
|
||||
#define i32_fromNaN (-0x7FFFFFFF - 1)
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The values to return on conversions to 64-bit integer formats that raise an
|
||||
| invalid exception.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define ui64_fromPosOverflow UINT64_C(0xFFFFFFFFFFFFFFFF)
|
||||
#define ui64_fromNegOverflow UINT64_C(0xFFFFFFFFFFFFFFFF)
|
||||
#define ui64_fromNaN UINT64_C(0xFFFFFFFFFFFFFFFF)
|
||||
#define i64_fromPosOverflow (-INT64_C(0x7FFFFFFFFFFFFFFF) - 1)
|
||||
#define i64_fromNegOverflow (-INT64_C(0x7FFFFFFFFFFFFFFF) - 1)
|
||||
#define i64_fromNaN (-INT64_C(0x7FFFFFFFFFFFFFFF) - 1)
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| "Common NaN" structure, used to transfer NaN representations from one format
|
||||
| to another.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct commonNaN {
|
||||
bool sign;
|
||||
#ifdef LITTLEENDIAN
|
||||
uint64_t v0, v64;
|
||||
#else
|
||||
uint64_t v64, v0;
|
||||
#endif
|
||||
};
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 16-bit floating-point NaN.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define defaultNaNF16UI 0xFE00
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Returns true when 16-bit unsigned integer 'uiA' has the bit pattern of a
|
||||
| 16-bit floating-point signaling NaN.
|
||||
| Note: This macro evaluates its argument more than once.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_isSigNaNF16UI(uiA) ((((uiA)&0x7E00) == 0x7C00) && ((uiA)&0x01FF))
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming 'uiA' has the bit pattern of a 16-bit floating-point NaN, converts
|
||||
| this NaN to the common NaN form, and stores the resulting common NaN at the
|
||||
| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f16UIToCommonNaN(uint_fast16_t uiA, struct commonNaN* zPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast16_t softfloat_commonNaNToF16UI(const struct commonNaN* aPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting 'uiA' and 'uiB' as the bit patterns of two 16-bit floating-
|
||||
| point values, at least one of which is a NaN, returns the bit pattern of
|
||||
| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
|
||||
| signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast16_t softfloat_propagateNaNF16UI(uint_fast16_t uiA, uint_fast16_t uiB);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 32-bit floating-point NaN.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define defaultNaNF32UI 0xFFC00000
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Returns true when 32-bit unsigned integer 'uiA' has the bit pattern of a
|
||||
| 32-bit floating-point signaling NaN.
|
||||
| Note: This macro evaluates its argument more than once.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_isSigNaNF32UI(uiA) ((((uiA)&0x7FC00000) == 0x7F800000) && ((uiA)&0x003FFFFF))
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming 'uiA' has the bit pattern of a 32-bit floating-point NaN, converts
|
||||
| this NaN to the common NaN form, and stores the resulting common NaN at the
|
||||
| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f32UIToCommonNaN(uint_fast32_t uiA, struct commonNaN* zPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 32-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast32_t softfloat_commonNaNToF32UI(const struct commonNaN* aPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting 'uiA' and 'uiB' as the bit patterns of two 32-bit floating-
|
||||
| point values, at least one of which is a NaN, returns the bit pattern of
|
||||
| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
|
||||
| signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast32_t softfloat_propagateNaNF32UI(uint_fast32_t uiA, uint_fast32_t uiB);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 64-bit floating-point NaN.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define defaultNaNF64UI UINT64_C(0xFFF8000000000000)
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Returns true when 64-bit unsigned integer 'uiA' has the bit pattern of a
|
||||
| 64-bit floating-point signaling NaN.
|
||||
| Note: This macro evaluates its argument more than once.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_isSigNaNF64UI(uiA) \
|
||||
((((uiA)&UINT64_C(0x7FF8000000000000)) == UINT64_C(0x7FF0000000000000)) && ((uiA)&UINT64_C(0x0007FFFFFFFFFFFF)))
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming 'uiA' has the bit pattern of a 64-bit floating-point NaN, converts
|
||||
| this NaN to the common NaN form, and stores the resulting common NaN at the
|
||||
| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f64UIToCommonNaN(uint_fast64_t uiA, struct commonNaN* zPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 64-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast64_t softfloat_commonNaNToF64UI(const struct commonNaN* aPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting 'uiA' and 'uiB' as the bit patterns of two 64-bit floating-
|
||||
| point values, at least one of which is a NaN, returns the bit pattern of
|
||||
| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
|
||||
| signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast64_t softfloat_propagateNaNF64UI(uint_fast64_t uiA, uint_fast64_t uiB);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 80-bit extended floating-point NaN.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define defaultNaNExtF80UI64 0xFFFF
|
||||
#define defaultNaNExtF80UI0 UINT64_C(0xC000000000000000)
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Returns true when the 80-bit unsigned integer formed from concatenating
|
||||
| 16-bit 'uiA64' and 64-bit 'uiA0' has the bit pattern of an 80-bit extended
|
||||
| floating-point signaling NaN.
|
||||
| Note: This macro evaluates its arguments more than once.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_isSigNaNExtF80UI(uiA64, uiA0) \
|
||||
((((uiA64)&0x7FFF) == 0x7FFF) && !((uiA0)&UINT64_C(0x4000000000000000)) && ((uiA0)&UINT64_C(0x3FFFFFFFFFFFFFFF)))
|
||||
|
||||
#ifdef SOFTFLOAT_FAST_INT64
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is
|
||||
| defined.
|
||||
*----------------------------------------------------------------------------*/
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
|
||||
| has the bit pattern of an 80-bit extended floating-point NaN, converts
|
||||
| this NaN to the common NaN form, and stores the resulting common NaN at the
|
||||
| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_extF80UIToCommonNaN(uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN* zPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
|
||||
| floating-point NaN, and returns the bit pattern of this value as an unsigned
|
||||
| integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128 softfloat_commonNaNToExtF80UI(const struct commonNaN* aPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting the unsigned integer formed from concatenating 'uiA64' and
|
||||
| 'uiA0' as an 80-bit extended floating-point value, and likewise interpreting
|
||||
| the unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
|
||||
| 80-bit extended floating-point value, and assuming at least on of these
|
||||
| floating-point values is a NaN, returns the bit pattern of the combined NaN
|
||||
| result. If either original floating-point value is a signaling NaN, the
|
||||
| invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128 softfloat_propagateNaNExtF80UI(uint_fast16_t uiA64, uint_fast64_t uiA0, uint_fast16_t uiB64, uint_fast64_t uiB0);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 128-bit floating-point NaN.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define defaultNaNF128UI64 UINT64_C(0xFFFF800000000000)
|
||||
#define defaultNaNF128UI0 UINT64_C(0)
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Returns true when the 128-bit unsigned integer formed from concatenating
|
||||
| 64-bit 'uiA64' and 64-bit 'uiA0' has the bit pattern of a 128-bit floating-
|
||||
| point signaling NaN.
|
||||
| Note: This macro evaluates its arguments more than once.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_isSigNaNF128UI(uiA64, uiA0) \
|
||||
((((uiA64)&UINT64_C(0x7FFF800000000000)) == UINT64_C(0x7FFF000000000000)) && ((uiA0) || ((uiA64)&UINT64_C(0x00007FFFFFFFFFFF))))
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
|
||||
| has the bit pattern of a 128-bit floating-point NaN, converts this NaN to
|
||||
| the common NaN form, and stores the resulting common NaN at the location
|
||||
| pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid exception
|
||||
| is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f128UIToCommonNaN(uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN* zPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128 softfloat_commonNaNToF128UI(const struct commonNaN*);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting the unsigned integer formed from concatenating 'uiA64' and
|
||||
| 'uiA0' as a 128-bit floating-point value, and likewise interpreting the
|
||||
| unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
|
||||
| 128-bit floating-point value, and assuming at least on of these floating-
|
||||
| point values is a NaN, returns the bit pattern of the combined NaN result.
|
||||
| If either original floating-point value is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128 softfloat_propagateNaNF128UI(uint_fast64_t uiA64, uint_fast64_t uiA0, uint_fast64_t uiB64, uint_fast64_t uiB0);
|
||||
|
||||
#else
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is not
|
||||
| defined.
|
||||
*----------------------------------------------------------------------------*/
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming the 80-bit extended floating-point value pointed to by 'aSPtr' is
|
||||
| a NaN, converts this NaN to the common NaN form, and stores the resulting
|
||||
| common NaN at the location pointed to by 'zPtr'. If the NaN is a signaling
|
||||
| NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_extF80MToCommonNaN(const struct extFloat80M* aSPtr, struct commonNaN* zPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
|
||||
| floating-point NaN, and stores this NaN at the location pointed to by
|
||||
| 'zSPtr'.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_commonNaNToExtF80M(const struct commonNaN* aPtr, struct extFloat80M* zSPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming at least one of the two 80-bit extended floating-point values
|
||||
| pointed to by 'aSPtr' and 'bSPtr' is a NaN, stores the combined NaN result
|
||||
| at the location pointed to by 'zSPtr'. If either original floating-point
|
||||
| value is a signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_propagateNaNExtF80M(const struct extFloat80M* aSPtr, const struct extFloat80M* bSPtr, struct extFloat80M* zSPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 128-bit floating-point NaN.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define defaultNaNF128UI96 0xFFFF8000
|
||||
#define defaultNaNF128UI64 0
|
||||
#define defaultNaNF128UI32 0
|
||||
#define defaultNaNF128UI0 0
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming the 128-bit floating-point value pointed to by 'aWPtr' is a NaN,
|
||||
| converts this NaN to the common NaN form, and stores the resulting common
|
||||
| NaN at the location pointed to by 'zPtr'. If the NaN is a signaling NaN,
|
||||
| the invalid exception is raised. Argument 'aWPtr' points to an array of
|
||||
| four 32-bit elements that concatenate in the platform's normal endian order
|
||||
| to form a 128-bit floating-point value.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f128MToCommonNaN(const uint32_t* aWPtr, struct commonNaN* zPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
|
||||
| NaN, and stores this NaN at the location pointed to by 'zWPtr'. Argument
|
||||
| 'zWPtr' points to an array of four 32-bit elements that concatenate in the
|
||||
| platform's normal endian order to form a 128-bit floating-point value.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_commonNaNToF128M(const struct commonNaN* aPtr, uint32_t* zWPtr);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming at least one of the two 128-bit floating-point values pointed to by
|
||||
| 'aWPtr' and 'bWPtr' is a NaN, stores the combined NaN result at the location
|
||||
| pointed to by 'zWPtr'. If either original floating-point value is a
|
||||
| signaling NaN, the invalid exception is raised. Each of 'aWPtr', 'bWPtr',
|
||||
| and 'zWPtr' points to an array of four 32-bit elements that concatenate in
|
||||
| the platform's normal endian order to form a 128-bit floating-point value.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_propagateNaNF128M(const uint32_t* aWPtr, const uint32_t* bWPtr, uint32_t* zWPtr);
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
@ -1,57 +1,57 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
bool extF80M_isSignalingNaN( const extFloat80_t *aPtr )
|
||||
{
|
||||
const struct extFloat80M *aSPtr;
|
||||
uint64_t uiA0;
|
||||
|
||||
aSPtr = (const struct extFloat80M *) aPtr;
|
||||
if ( (aSPtr->signExp & 0x7FFF) != 0x7FFF ) return false;
|
||||
uiA0 = aSPtr->signif;
|
||||
return
|
||||
! (uiA0 & UINT64_C( 0x4000000000000000 ))
|
||||
&& (uiA0 & UINT64_C( 0x3FFFFFFFFFFFFFFF));
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
bool extF80M_isSignalingNaN( const extFloat80_t *aPtr )
|
||||
{
|
||||
const struct extFloat80M *aSPtr;
|
||||
uint64_t uiA0;
|
||||
|
||||
aSPtr = (const struct extFloat80M *) aPtr;
|
||||
if ( (aSPtr->signExp & 0x7FFF) != 0x7FFF ) return false;
|
||||
uiA0 = aSPtr->signif;
|
||||
return
|
||||
! (uiA0 & UINT64_C( 0x4000000000000000 ))
|
||||
&& (uiA0 & UINT64_C( 0x3FFFFFFFFFFFFFFF));
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,60 +1,60 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "primitives.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
bool f128M_isSignalingNaN( const float128_t *aPtr )
|
||||
{
|
||||
const uint32_t *aWPtr;
|
||||
uint32_t uiA96;
|
||||
|
||||
aWPtr = (const uint32_t *) aPtr;
|
||||
uiA96 = aWPtr[indexWordHi( 4 )];
|
||||
if ( (uiA96 & 0x7FFF8000) != 0x7FFF0000 ) return false;
|
||||
return
|
||||
((uiA96 & 0x00007FFF) != 0)
|
||||
|| ((aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )]
|
||||
| aWPtr[indexWord( 4, 0 )])
|
||||
!= 0);
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "primitives.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
bool f128M_isSignalingNaN( const float128_t *aPtr )
|
||||
{
|
||||
const uint32_t *aWPtr;
|
||||
uint32_t uiA96;
|
||||
|
||||
aWPtr = (const uint32_t *) aPtr;
|
||||
uiA96 = aWPtr[indexWordHi( 4 )];
|
||||
if ( (uiA96 & 0x7FFF8000) != 0x7FFF0000 ) return false;
|
||||
return
|
||||
((uiA96 & 0x00007FFF) != 0)
|
||||
|| ((aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )]
|
||||
| aWPtr[indexWord( 4, 0 )])
|
||||
!= 0);
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,57 +1,57 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include "platform.h"
|
||||
#include "softfloat_types.h"
|
||||
|
||||
#define softfloat_commonNaNToExtF80M softfloat_commonNaNToExtF80M
|
||||
#include "specialize.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
|
||||
| floating-point NaN, and stores this NaN at the location pointed to by
|
||||
| 'zSPtr'.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void
|
||||
softfloat_commonNaNToExtF80M(
|
||||
const struct commonNaN *aPtr, struct extFloat80M *zSPtr )
|
||||
{
|
||||
|
||||
zSPtr->signExp = defaultNaNExtF80UI64;
|
||||
zSPtr->signif = defaultNaNExtF80UI0;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include "platform.h"
|
||||
#include "softfloat_types.h"
|
||||
|
||||
#define softfloat_commonNaNToExtF80M softfloat_commonNaNToExtF80M
|
||||
#include "specialize.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
|
||||
| floating-point NaN, and stores this NaN at the location pointed to by
|
||||
| 'zSPtr'.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void
|
||||
softfloat_commonNaNToExtF80M(
|
||||
const struct commonNaN *aPtr, struct extFloat80M *zSPtr )
|
||||
{
|
||||
|
||||
zSPtr->signExp = defaultNaNExtF80UI64;
|
||||
zSPtr->signif = defaultNaNExtF80UI0;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,57 +1,57 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include "platform.h"
|
||||
#include "primitiveTypes.h"
|
||||
|
||||
#define softfloat_commonNaNToExtF80UI softfloat_commonNaNToExtF80UI
|
||||
#include "specialize.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
|
||||
| floating-point NaN, and returns the bit pattern of this value as an unsigned
|
||||
| integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr )
|
||||
{
|
||||
struct uint128 uiZ;
|
||||
|
||||
uiZ.v64 = defaultNaNExtF80UI64;
|
||||
uiZ.v0 = defaultNaNExtF80UI0;
|
||||
return uiZ;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include "platform.h"
|
||||
#include "primitiveTypes.h"
|
||||
|
||||
#define softfloat_commonNaNToExtF80UI softfloat_commonNaNToExtF80UI
|
||||
#include "specialize.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
|
||||
| floating-point NaN, and returns the bit pattern of this value as an unsigned
|
||||
| integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr )
|
||||
{
|
||||
struct uint128 uiZ;
|
||||
|
||||
uiZ.v64 = defaultNaNExtF80UI64;
|
||||
uiZ.v0 = defaultNaNExtF80UI0;
|
||||
return uiZ;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,60 +1,60 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "primitiveTypes.h"
|
||||
|
||||
#define softfloat_commonNaNToF128M softfloat_commonNaNToF128M
|
||||
#include "specialize.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
|
||||
| NaN, and stores this NaN at the location pointed to by 'zWPtr'. Argument
|
||||
| 'zWPtr' points to an array of four 32-bit elements that concatenate in the
|
||||
| platform's normal endian order to form a 128-bit floating-point value.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void
|
||||
softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr )
|
||||
{
|
||||
|
||||
zWPtr[indexWord( 4, 3 )] = defaultNaNF128UI96;
|
||||
zWPtr[indexWord( 4, 2 )] = defaultNaNF128UI64;
|
||||
zWPtr[indexWord( 4, 1 )] = defaultNaNF128UI32;
|
||||
zWPtr[indexWord( 4, 0 )] = defaultNaNF128UI0;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "primitiveTypes.h"
|
||||
|
||||
#define softfloat_commonNaNToF128M softfloat_commonNaNToF128M
|
||||
#include "specialize.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
|
||||
| NaN, and stores this NaN at the location pointed to by 'zWPtr'. Argument
|
||||
| 'zWPtr' points to an array of four 32-bit elements that concatenate in the
|
||||
| platform's normal endian order to form a 128-bit floating-point value.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void
|
||||
softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr )
|
||||
{
|
||||
|
||||
zWPtr[indexWord( 4, 3 )] = defaultNaNF128UI96;
|
||||
zWPtr[indexWord( 4, 2 )] = defaultNaNF128UI64;
|
||||
zWPtr[indexWord( 4, 1 )] = defaultNaNF128UI32;
|
||||
zWPtr[indexWord( 4, 0 )] = defaultNaNF128UI0;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,56 +1,56 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include "platform.h"
|
||||
#include "primitiveTypes.h"
|
||||
|
||||
#define softfloat_commonNaNToF128UI softfloat_commonNaNToF128UI
|
||||
#include "specialize.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN *aPtr )
|
||||
{
|
||||
struct uint128 uiZ;
|
||||
|
||||
uiZ.v64 = defaultNaNF128UI64;
|
||||
uiZ.v0 = defaultNaNF128UI0;
|
||||
return uiZ;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include "platform.h"
|
||||
#include "primitiveTypes.h"
|
||||
|
||||
#define softfloat_commonNaNToF128UI softfloat_commonNaNToF128UI
|
||||
#include "specialize.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN *aPtr )
|
||||
{
|
||||
struct uint128 uiZ;
|
||||
|
||||
uiZ.v64 = defaultNaNF128UI64;
|
||||
uiZ.v0 = defaultNaNF128UI0;
|
||||
return uiZ;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,5 +1,5 @@
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| This file intentionally contains no code.
|
||||
*----------------------------------------------------------------------------*/
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| This file intentionally contains no code.
|
||||
*----------------------------------------------------------------------------*/
|
||||
|
||||
|
@ -1,5 +1,5 @@
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| This file intentionally contains no code.
|
||||
*----------------------------------------------------------------------------*/
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| This file intentionally contains no code.
|
||||
*----------------------------------------------------------------------------*/
|
||||
|
||||
|
@ -1,5 +1,5 @@
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| This file intentionally contains no code.
|
||||
*----------------------------------------------------------------------------*/
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| This file intentionally contains no code.
|
||||
*----------------------------------------------------------------------------*/
|
||||
|
||||
|
@ -1,5 +1,5 @@
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| This file intentionally contains no code.
|
||||
*----------------------------------------------------------------------------*/
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| This file intentionally contains no code.
|
||||
*----------------------------------------------------------------------------*/
|
||||
|
||||
|
@ -1,5 +1,5 @@
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| This file intentionally contains no code.
|
||||
*----------------------------------------------------------------------------*/
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| This file intentionally contains no code.
|
||||
*----------------------------------------------------------------------------*/
|
||||
|
||||
|
@ -1,5 +1,5 @@
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| This file intentionally contains no code.
|
||||
*----------------------------------------------------------------------------*/
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| This file intentionally contains no code.
|
||||
*----------------------------------------------------------------------------*/
|
||||
|
||||
|
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user