diff options
Diffstat (limited to 'src')
66 files changed, 5841 insertions, 49 deletions
diff --git a/src/Dolphin/dvd/dvd.c b/src/Dolphin/dvd/dvd.c index 176ee49..72f7ef5 100644 --- a/src/Dolphin/dvd/dvd.c +++ b/src/Dolphin/dvd/dvd.c @@ -77,6 +77,14 @@ static DVDOptionalCommandChecker checkOptionalCommand = defaultOptionalCommandCh extern void __DVDInterruptHandler(__OSInterrupt interrupt, OSContext* context); +void __DVDPrintFatalMessage() { + +} + +int DVDCompareDiskID(DVDDiskID *lol, DVDDiskID *lol2) { + return 0; +} + static void defaultOptionalCommandChecker(DVDCommandBlock* block, DVDLowCallback cb) {} void DVDInit() { diff --git a/src/Dolphin/vi/vi.c b/src/Dolphin/vi/vi.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/src/Dolphin/vi/vi.c diff --git a/src/MSL_C.PPCEABI.bare.H/CPlusLibPPC.cpp b/src/MSL_C.PPCEABI.bare.H/CPlusLibPPC.cpp new file mode 100644 index 0000000..4a0b5b9 --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/CPlusLibPPC.cpp @@ -0,0 +1,25 @@ +#include "MWCPlusLib.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void* __copy(char* to, char* from, size_t size) { + char* p; + + if (to && size) { + p = to; + do { + *p = *from; + ++p; + ++from; + --size; + } while (size > 0); + } + + return to; +} + +#ifdef __cplusplus +} +#endif diff --git a/src/MSL_C.PPCEABI.bare.H/FILE_POS.c b/src/MSL_C.PPCEABI.bare.H/FILE_POS.c new file mode 100644 index 0000000..6413447 --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/FILE_POS.c @@ -0,0 +1,102 @@ +#include <ansi_files.h> +#include <errno.h> + +inline fpos_t _ftell(FILE* file) { + int charsInUndoBuffer = 0; + fpos_t position; + + unsigned char tmp_kind = file->mode.file_kind; + if (!(tmp_kind == __disk_file || tmp_kind == __console_file) || file->state.error) { + errno = EFPOS; + return (-1L); + } + + if (file->state.io_state == __neutral) + return (file->position); + + position = file->buffer_pos + (file->buffer_ptr - file->buffer); + + if (file->state.io_state >= __rereading) { + charsInUndoBuffer = file->state.io_state - __rereading + 1; + position -= charsInUndoBuffer; + } + + return (position); +} + +long ftell(FILE* file) { + long retval; + + retval = (long)_ftell(file); + + return retval; +} + +int _fseek(FILE* file, fpos_t offset, int mode) { + fpos_t position; + __pos_proc pos_proc; + + unsigned char tmp_kind = file->mode.file_kind; + if (!(tmp_kind == __disk_file) || file->state.error) { + errno = EFPOS; + return (-1); + } + + if (file->state.io_state == __writing) { + if (__flush_buffer(file, NULL) != __no_io_error) { + set_error(file); + errno = EFPOS; + return (-1); + } + } + + if (mode == SEEK_CUR) { + + mode = SEEK_SET; + + if ((position = _ftell(file)) < 0) + position = 0; + + offset += position; + } + + if ((mode != SEEK_END) && (file->mode.io_mode != __read_write) && + ((file->state.io_state == __reading) || (file->state.io_state == __rereading))) { + if ((offset >= file->position) || offset < file->buffer_pos) { + file->state.io_state = __neutral; + } else { + file->buffer_ptr = file->buffer + (offset - file->buffer_pos); + file->buffer_len = file->position - offset; + file->state.io_state = __reading; + } + } else { + file->state.io_state = __neutral; + } + + if (file->state.io_state == __neutral) { + if ((pos_proc = file->position_proc) != 0 && + (*pos_proc)(file->handle, &offset, mode, file->idle_proc)) { + set_error(file); + errno = EFPOS; + return (-1); + } + + file->state.eof = 0; + file->position = offset; + file->buffer_len = 0; + } + + return 0; +} + +int fseek(FILE * file, long offset, int mode) +{ + fpos_t real_offset = (fpos_t)offset; + int retval; + + + retval = _fseek(file, real_offset, mode); + + + return(retval); +} diff --git a/src/MSL_C.PPCEABI.bare.H/MWCPlusLib.h b/src/MSL_C.PPCEABI.bare.H/MWCPlusLib.h new file mode 100644 index 0000000..f268016 --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/MWCPlusLib.h @@ -0,0 +1,15 @@ +#ifndef _MWCPLUSLIB +#define _MWCPLUSLIB + +#include <types.h> + +#ifdef __cplusplus +extern "C" { +#endif +void* __copy(char* to, char* from, size_t size); + +#ifdef __cplusplus +} +#endif + +#endif // _MWCPLUSLIB diff --git a/src/MSL_C.PPCEABI.bare.H/abort_exit.c b/src/MSL_C.PPCEABI.bare.H/abort_exit.c new file mode 100644 index 0000000..b0ebade --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/abort_exit.c @@ -0,0 +1,38 @@ +#include <stdlib.h> + +void __destroy_global_chain(void); +void _ExitProcess(void); + +extern void (*_dtors[])(void); + +static void (*__console_exit)(void); +void (*__stdio_exit)(void); +static int __atexit_curr_func; +int __aborting; + +static void (*__atexit_funcs[64])(void); + +void exit(int status) { + int i; + void (**dtor)(void); + + if (!__aborting) { + __destroy_global_chain(); + dtor = _dtors; + while (*dtor != NULL) { + (*dtor)(); + dtor++; + } + if (__stdio_exit != NULL) { + __stdio_exit(); + __stdio_exit = NULL; + } + } + while (__atexit_curr_func > 0) + __atexit_funcs[--__atexit_curr_func](); + if (__console_exit != NULL) { + __console_exit(); + __console_exit = NULL; + } + _ExitProcess(); +} diff --git a/src/MSL_C.PPCEABI.bare.H/alloc.c b/src/MSL_C.PPCEABI.bare.H/alloc.c new file mode 100644 index 0000000..e72740c --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/alloc.c @@ -0,0 +1,7 @@ +void free(void *ptr) { + +} + +void *malloc(int size) { + +} diff --git a/src/MSL_C.PPCEABI.bare.H/ansi_files.c b/src/MSL_C.PPCEABI.bare.H/ansi_files.c new file mode 100644 index 0000000..14cd868 --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/ansi_files.c @@ -0,0 +1,119 @@ +#include "ansi_files.h" + +static unsigned char stdin_buff[0x100]; +static unsigned char stdout_buff[0x100]; +static unsigned char stderr_buff[0x100]; + +extern int fclose(FILE*); +extern int __read_console(__file_handle file, unsigned char* buff, size_t* count, + __idle_proc idle_proc); +extern int __write_console(__file_handle file, unsigned char* buff, size_t* count, + __idle_proc idle_proc); +extern int __close_console(__file_handle file); + +FILE __files[4] = { + {0, + {0, 1, 1, 2, 0}, + {0, 0, 0, 0}, + 0, + 0, + 0, + {0, 0}, + {0, 0}, + 0, + stdin_buff, + sizeof(stdin_buff), + stdin_buff, + 0, + 0, + 0, + 0, + NULL, + &__read_console, + &__write_console, + &__close_console, + 0, + &__files[1]}, + {1, + {0, 2, 1, 2, 0}, + {0, 0, 0, 0}, + 0, + 0, + 0, + {0, 0}, + {0, 0}, + 0, + stdout_buff, + sizeof(stdout_buff), + stdout_buff, + 0, + 0, + 0, + 0, + NULL, + &__read_console, + &__write_console, + &__close_console, + 0, + &__files[2]}, + {2, + {0, 2, 0, 2, 0}, + {0, 0, 0, 0}, + 0, + 0, + 0, + {0, 0}, + {0, 0}, + 0, + stderr_buff, + sizeof(stderr_buff), + stderr_buff, + 0, + 0, + 0, + 0, + NULL, + &__read_console, + &__write_console, + &__close_console, + 0, + &__files[3]}, +}; + +void __close_all() { + FILE* p = &__files[0]; + FILE* plast; + + // __begin_critical_region(2); + + while (p != NULL) { + if (p->mode.file_kind != __closed_file) { + fclose(p); + } + + plast = p; + p = p->next_file_struct; + if (plast->is_dynamically_allocated) + free(plast); + else { + plast->mode.file_kind = __unavailable_file; + if ((p != NULL) && p->is_dynamically_allocated) + plast->next_file_struct = NULL; + } + } + + // __end_critical_region(2); +} + +int __flush_all() { + int retval = 0; + FILE* __stream; + __stream = &__files[0]; + while (__stream) { + if ((__stream->mode.file_kind) && (fflush(__stream))) { + retval = -1; + } + __stream = __stream->next_file_struct; + }; + return retval; +} diff --git a/src/MSL_C.PPCEABI.bare.H/arith.c b/src/MSL_C.PPCEABI.bare.H/arith.c new file mode 100644 index 0000000..a21df7e --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/arith.c @@ -0,0 +1,15 @@ +#include <stdlib.h> + +int abs(int n) { + if (n < 0) + return (-n); + else + return (n); +} + +long labs(long n) { + if (n < 0) + return (-n); + else + return (n); +} diff --git a/src/MSL_C.PPCEABI.bare.H/buffer_io.c b/src/MSL_C.PPCEABI.bare.H/buffer_io.c new file mode 100644 index 0000000..e760ba8 --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/buffer_io.c @@ -0,0 +1,43 @@ +#include "buffer_io.h" + +void __convert_from_newlines(unsigned char* buf, size_t* n) { +} + +void __convert_to_newlines(unsigned char* buf, size_t* n) { +} + +void __prep_buffer(FILE* file) { + file->buffer_ptr = file->buffer; + file->buffer_len = file->buffer_size; + file->buffer_len -= file->position & file->buffer_alignment; + file->buffer_pos = file->position; +} + +int __flush_buffer(FILE* file, size_t* bytes_flushed) { + size_t buffer_len; + int ioresult; + + buffer_len = file->buffer_ptr - file->buffer; + + if (buffer_len) { + file->buffer_len = buffer_len; + + if (!file->mode.binary_io) + __convert_from_newlines(file->buffer, (size_t*)&file->buffer_len); + + ioresult = (*file->write_proc)(file->handle, file->buffer, (size_t*)&file->buffer_len, + file->idle_proc); + + if (bytes_flushed) + *bytes_flushed = file->buffer_len; + + if (ioresult) + return (ioresult); + + file->position += file->buffer_len; + } + + __prep_buffer(file); + + return 0; +} diff --git a/src/MSL_C.PPCEABI.bare.H/ctype.c b/src/MSL_C.PPCEABI.bare.H/ctype.c new file mode 100644 index 0000000..29581eb --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/ctype.c @@ -0,0 +1,69 @@ +#define _CTYPE_INLINE __declspec(weak) +#include <ctype.h> +#include <stdio.h> + +#define ctrl __control_char +#define motn __motion_char +#define spac __space_char +#define punc __punctuation +#define digi __digit +#define hexd __hex_digit +#define lowc __lower_case +#define uppc __upper_case +#define dhex (hexd | digi) +#define uhex (hexd | uppc) +#define lhex (hexd | lowc) + +unsigned char __ctype_map[256] = { + // clang-format off + ctrl, ctrl, ctrl, ctrl, ctrl, ctrl, ctrl, ctrl, ctrl, motn, motn, motn, motn, motn, ctrl, ctrl, + ctrl, ctrl, ctrl, ctrl, ctrl, ctrl, ctrl, ctrl, ctrl, ctrl, ctrl, ctrl, ctrl, ctrl, ctrl, ctrl, + spac, punc, punc, punc, punc, punc, punc, punc, punc, punc, punc, punc, punc, punc, punc, punc, + dhex, dhex, dhex, dhex, dhex, dhex, dhex, dhex, dhex, dhex, punc, punc, punc, punc, punc, punc, + punc, uhex, uhex, uhex, uhex, uhex, uhex, uppc, uppc, uppc, uppc, uppc, uppc, uppc, uppc, uppc, + uppc, uppc, uppc, uppc, uppc, uppc, uppc, uppc, uppc, uppc, uppc, punc, punc, punc, punc, punc, + punc, lhex, lhex, lhex, lhex, lhex, lhex, lowc, lowc, lowc, lowc, lowc, lowc, lowc, lowc, lowc, + lowc, lowc, lowc, lowc, lowc, lowc, lowc, lowc, lowc, lowc, lowc, punc, punc, punc, punc, ctrl, + // clang-format on +}; + +unsigned char __lower_map[256] = { + // clang-format off + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, + ' ', '!', '"', '#', '$', '%', '&', '\'', '(', ')', '*', '+', ',', '-', '.', '/', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';', '<', '=', '>', '?', + '@', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', + 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '[', '\\', ']', '^', '_', + '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', + 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '{', '|', '}', '~', 0x7F, + 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, + 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, + 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, + 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, + 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, + 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, + 0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF, + 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF, + // clang-format on +}; + +unsigned char __upper_map[256] = { + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, + ' ', '!', '"', '#', '$', '%', '&', '\'', '(', ')', '*', '+', ',', '-', '.', '/', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';', '<', '=', '>', '?', + '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', + 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '[', '\\', ']', '^', '_', + '`', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', + 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '{', '|', '}', '~', 0x7F, + 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, + 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, + 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, + 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, + 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, + 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, + 0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF, + 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF, + // clang-format on +}; diff --git a/src/MSL_C.PPCEABI.bare.H/direct_io.c b/src/MSL_C.PPCEABI.bare.H/direct_io.c new file mode 100644 index 0000000..a98d19c --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/direct_io.c @@ -0,0 +1,114 @@ +#include <ansi_files.h> +#include <stdio.h> + +size_t fwrite(const void* ptr, size_t memb_size, size_t num_memb, FILE* file) { + size_t retval; + retval = __fwrite(ptr, memb_size, num_memb, file); + return (retval); +} + +size_t __fwrite(const void* ptr, size_t memb_size, size_t num_memb, FILE* file) { + unsigned char* write_ptr; + size_t num_bytes, bytes_to_go, bytes_written; + int ioresult, always_buffer; + +#ifndef __NO_WIDE_CHAR + if (fwide(file, 0) == 0) + fwide(file, -1); +#endif + + bytes_to_go = memb_size * num_memb; + + if (!bytes_to_go || file->state.error || file->mode.file_kind == __closed_file) + return 0; + + if (file->mode.file_kind == __console_file) + __stdio_atexit(); + + always_buffer = + !file->mode.binary_io || file->mode.buffer_mode == _IOFBF || file->mode.buffer_mode == _IOLBF; + + if (file->state.io_state == __neutral) { + if (file->mode.io_mode & __write) { + if (file->mode.io_mode & __append) { + if (fseek(file, 0, SEEK_END)) + return 0; + } + file->state.io_state = __writing; + + __prep_buffer(file); + } + } + + if (file->state.io_state != __writing) { + set_error(file); + return 0; + } + + write_ptr = (unsigned char*)ptr; + bytes_written = 0; + + if (bytes_to_go && (file->buffer_ptr != file->buffer || always_buffer)) { + file->buffer_len = file->buffer_size - (file->buffer_ptr - file->buffer); + + do { + unsigned char* newline = NULL; + + num_bytes = file->buffer_len; + + if (num_bytes > bytes_to_go) + num_bytes = bytes_to_go; + if (file->mode.buffer_mode == _IOLBF && num_bytes) + if ((newline = (unsigned char*)__memrchr(write_ptr, '\n', num_bytes)) != NULL) + num_bytes = newline + 1 - write_ptr; + + if (num_bytes) { + memcpy(file->buffer_ptr, write_ptr, num_bytes); + + write_ptr += num_bytes; + bytes_written += num_bytes; + bytes_to_go -= num_bytes; + + file->buffer_ptr += num_bytes; + file->buffer_len -= num_bytes; + } + if (!file->buffer_len || newline != NULL || + (file->mode.buffer_mode == _IONBF)) + { + ioresult = __flush_buffer(file, NULL); + + if (ioresult) { + set_error(file); + bytes_to_go = 0; + break; + } + } + } while (bytes_to_go && always_buffer); + } + + if (bytes_to_go && !always_buffer) { + unsigned char* save_buffer = file->buffer; + size_t save_size = file->buffer_size; + + file->buffer = write_ptr; + file->buffer_size = bytes_to_go; + file->buffer_ptr = write_ptr + bytes_to_go; + + if (__flush_buffer(file, &num_bytes) != __no_io_error) + set_error(file); + + bytes_written += num_bytes; + + file->buffer = save_buffer; + file->buffer_size = save_size; + + __prep_buffer(file); + + file->buffer_len = 0; + } + + if (file->mode.buffer_mode != _IOFBF) + file->buffer_len = 0; + + return ((bytes_written + memb_size - 1) / memb_size); +} diff --git a/src/MSL_C.PPCEABI.bare.H/e_acos.c b/src/MSL_C.PPCEABI.bare.H/e_acos.c new file mode 100644 index 0000000..e464e99 --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/e_acos.c @@ -0,0 +1,107 @@ +/* @(#)e_acos.c 1.2 95/01/04 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* __ieee754_acos(x) + * Method : + * acos(x) = pi/2 - asin(x) + * acos(-x) = pi/2 + asin(x) + * For |x|<=0.5 + * acos(x) = pi/2 - (x + x*x^2*R(x^2)) (see asin.c) + * For x>0.5 + * acos(x) = pi/2 - (pi/2 - 2asin(sqrt((1-x)/2))) + * = 2asin(sqrt((1-x)/2)) + * = 2s + 2s*z*R(z) ...z=(1-x)/2, s=sqrt(z) + * = 2f + (2c + 2s*z*R(z)) + * where f=hi part of s, and c = (z-f*f)/(s+f) is the correction term + * for f so that f+c ~ sqrt(z). + * For x<-0.5 + * acos(x) = pi - 2asin(sqrt((1-|x|)/2)) + * = pi - 0.5*(s+s*z*R(z)), where z=(1-|x|)/2,s=sqrt(z) + * + * Special cases: + * if x is NaN, return x itself; + * if |x|>1, return NaN with invalid signal. + * + * Function needed: sqrt + */ + +#include "fdlibm.h" + +#ifdef __STDC__ +static const double +#else +static double +#endif + one = 1.00000000000000000000e+00, /* 0x3FF00000, 0x00000000 */ + pi = 3.14159265358979311600e+00, /* 0x400921FB, 0x54442D18 */ + pio2_hi = 1.57079632679489655800e+00, /* 0x3FF921FB, 0x54442D18 */ + pio2_lo = 6.12323399573676603587e-17, /* 0x3C91A626, 0x33145C07 */ + pS0 = 1.66666666666666657415e-01, /* 0x3FC55555, 0x55555555 */ + pS1 = -3.25565818622400915405e-01, /* 0xBFD4D612, 0x03EB6F7D */ + pS2 = 2.01212532134862925881e-01, /* 0x3FC9C155, 0x0E884455 */ + pS3 = -4.00555345006794114027e-02, /* 0xBFA48228, 0xB5688F3B */ + pS4 = 7.91534994289814532176e-04, /* 0x3F49EFE0, 0x7501B288 */ + pS5 = 3.47933107596021167570e-05, /* 0x3F023DE1, 0x0DFDF709 */ + qS1 = -2.40339491173441421878e+00, /* 0xC0033A27, 0x1C8A2D4B */ + qS2 = 2.02094576023350569471e+00, /* 0x40002AE5, 0x9C598AC8 */ + qS3 = -6.88283971605453293030e-01, /* 0xBFE6066C, 0x1B8D0159 */ + qS4 = 7.70381505559019352791e-02; /* 0x3FB3B8C5, 0xB12E9282 */ + +#ifdef __STDC__ +double __ieee754_acos(double x) +#else +double __ieee754_acos(x) +double x; +#endif +{ + double z, p, q, r, w, s, c, df; + _INT32 hx, ix; + hx = __HI(x); + ix = hx & 0x7fffffff; + if (ix >= 0x3ff00000) { /* |x| >= 1 */ + if (((ix - 0x3ff00000) | __LO(x)) == 0) { /* |x|==1 */ + if (hx > 0) + return 0.0; /* acos(1) = 0 */ + else + return pi + 2.0 * pio2_lo; /* acos(-1)= pi */ + } + return NAN; /* acos(|x|>1) is NaN */ + } + if (ix < 0x3fe00000) { /* |x| < 0.5 */ + if (ix <= 0x3c600000) + return pio2_hi + pio2_lo; /*if|x|<2**-57*/ + z = x * x; + p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5))))); + q = one + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4))); + r = p / q; + return pio2_hi - (x - (pio2_lo - x * r)); + } else if (hx < 0) { /* x < -0.5 */ + z = (one + x) * 0.5; + p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5))))); + q = one + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4))); + s = sqrt(z); + r = p / q; + w = r * s - pio2_lo; + return pi - 2.0 * (s + w); + } else { /* x > 0.5 */ + z = (one - x) * 0.5; + s = sqrt(z); + df = s; + __LO(df) = 0; + c = (z - df * df) / (s + df); + p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5))))); + q = one + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4))); + r = p / q; + w = r * s + c; + return 2.0 * (df + w); + } +} diff --git a/src/MSL_C.PPCEABI.bare.H/e_asin.c b/src/MSL_C.PPCEABI.bare.H/e_asin.c new file mode 100644 index 0000000..b8ad60b --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/e_asin.c @@ -0,0 +1,115 @@ +/* @(#)e_asin.c 1.2 95/01/04 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* __ieee754_asin(x) + * Method : + * Since asin(x) = x + x^3/6 + x^5*3/40 + x^7*15/336 + ... + * we approximate asin(x) on [0,0.5] by + * asin(x) = x + x*x^2*R(x^2) + * where + * R(x^2) is a rational approximation of (asin(x)-x)/x^3 + * and its remez error is bounded by + * |(asin(x)-x)/x^3 - R(x^2)| < 2^(-58.75) + * + * For x in [0.5,1] + * asin(x) = pi/2-2*asin(sqrt((1-x)/2)) + * Let y = (1-x), z = y/2, s := sqrt(z), and pio2_hi+pio2_lo=pi/2; + * then for x>0.98 + * asin(x) = pi/2 - 2*(s+s*z*R(z)) + * = pio2_hi - (2*(s+s*z*R(z)) - pio2_lo) + * For x<=0.98, let pio4_hi = pio2_hi/2, then + * f = hi part of s; + * c = sqrt(z) - f = (z-f*f)/(s+f) ...f+c=sqrt(z) + * and + * asin(x) = pi/2 - 2*(s+s*z*R(z)) + * = pio4_hi+(pio4-2s)-(2s*z*R(z)-pio2_lo) + * = pio4_hi+(pio4-2f)-(2s*z*R(z)-(pio2_lo+2c)) + * + * Special cases: + * if x is NaN, return x itself; + * if |x|>1, return NaN with invalid signal. + * + */ + +#include <fdlibm.h> + +#ifdef __STDC__ +static const double +#else +static double +#endif + one = 1.00000000000000000000e+00, /* 0x3FF00000, 0x00000000 */ + big = 1.000e+300, pio2_hi = 1.57079632679489655800e+00, /* 0x3FF921FB, 0x54442D18 */ + pio2_lo = 6.12323399573676603587e-17, /* 0x3C91A626, 0x33145C07 */ + pio4_hi = 7.85398163397448278999e-01, /* 0x3FE921FB, 0x54442D18 */ + /* coefficient for R(x^2) */ + pS0 = 1.66666666666666657415e-01, /* 0x3FC55555, 0x55555555 */ + pS1 = -3.25565818622400915405e-01, /* 0xBFD4D612, 0x03EB6F7D */ + pS2 = 2.01212532134862925881e-01, /* 0x3FC9C155, 0x0E884455 */ + pS3 = -4.00555345006794114027e-02, /* 0xBFA48228, 0xB5688F3B */ + pS4 = 7.91534994289814532176e-04, /* 0x3F49EFE0, 0x7501B288 */ + pS5 = 3.47933107596021167570e-05, /* 0x3F023DE1, 0x0DFDF709 */ + qS1 = -2.40339491173441421878e+00, /* 0xC0033A27, 0x1C8A2D4B */ + qS2 = 2.02094576023350569471e+00, /* 0x40002AE5, 0x9C598AC8 */ + qS3 = -6.88283971605453293030e-01, /* 0xBFE6066C, 0x1B8D0159 */ + qS4 = 7.70381505559019352791e-02; /* 0x3FB3B8C5, 0xB12E9282 */ + +#ifdef __STDC__ +double __ieee754_asin(double x) +#else +double __ieee754_asin(x) +double x; +#endif +{ + double t, w, p, q, c, r, s; + _INT32 hx, ix; + hx = __HI(x); + ix = hx & 0x7fffffff; + if (ix >= 0x3ff00000) { /* |x|>= 1 */ + if (((ix - 0x3ff00000) | __LO(x)) == 0) + /* asin(1)=+-pi/2 with inexact */ + return x * pio2_hi + x * pio2_lo; + return NAN; /* asin(|x|>1) is NaN */ + } else if (ix < 0x3fe00000) { /* |x|<0.5 */ + if (ix < 0x3e400000) { /* if |x| < 2**-27 */ + if (big + x > one) + return x; /* return x with inexact if x!=0*/ + } else + t = x * x; + p = t * (pS0 + t * (pS1 + t * (pS2 + t * (pS3 + t * (pS4 + t * pS5))))); + q = one + t * (qS1 + t * (qS2 + t * (qS3 + t * qS4))); + w = p / q; + return x + x * w; + } + /* 1> |x|>= 0.5 */ + w = one - fabs(x); + t = w * 0.5; + p = t * (pS0 + t * (pS1 + t * (pS2 + t * (pS3 + t * (pS4 + t * pS5))))); + q = one + t * (qS1 + t * (qS2 + t * (qS3 + t * qS4))); + s = sqrt(t); + if (ix >= 0x3FEF3333) { /* if |x| > 0.975 */ + w = p / q; + t = pio2_hi - (2.0 * (s + s * w) - pio2_lo); + } else { + w = s; + __LO(w) = 0; + c = (t - w * w) / (s + w); + r = p / q; + p = 2.0 * s * r - (pio2_lo - 2.0 * c); + q = pio4_hi - 2.0 * w; + t = pio4_hi - (p - q); + } + if (hx > 0) + return t; + else + return -t; +} diff --git a/src/MSL_C.PPCEABI.bare.H/e_atan2.c b/src/MSL_C.PPCEABI.bare.H/e_atan2.c new file mode 100644 index 0000000..2902bd8 --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/e_atan2.c @@ -0,0 +1,143 @@ +/* @(#)e_atan2.c 1.2 95/01/04 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + * + */ + +/* __ieee754_atan2(y,x) + * Method : + * 1. Reduce y to positive by atan2(y,x)=-atan2(-y,x). + * 2. Reduce x to positive by (if x and y are unexceptional): + * ARG (x+iy) = arctan(y/x) ... if x > 0, + * ARG (x+iy) = pi - arctan[y/(-x)] ... if x < 0, + * + * Special cases: + * + * ATAN2((anything), NaN ) is NaN; + * ATAN2(NAN , (anything) ) is NaN; + * ATAN2(+-0, +(anything but NaN)) is +-0 ; + * ATAN2(+-0, -(anything but NaN)) is +-pi ; + * ATAN2(+-(anything but 0 and NaN), 0) is +-pi/2; + * ATAN2(+-(anything but INF and NaN), +INF) is +-0 ; + * ATAN2(+-(anything but INF and NaN), -INF) is +-pi; + * ATAN2(+-INF,+INF ) is +-pi/4 ; + * ATAN2(+-INF,-INF ) is +-3pi/4; + * ATAN2(+-INF, (anything but,0,NaN, and INF)) is +-pi/2; + * + * Constants: + * The hexadecimal values are the intended ones for the following + * constants. The decimal values may be used, provided that the + * compiler will convert from decimal to binary accurately enough + * to produce the hexadecimal values shown. + */ + +#include "fdlibm.h" + +#ifdef __STDC__ +static const double +#else +static double +#endif + tiny = 1.0e-300, + zero = 0.0, pi_o_4 = 7.8539816339744827900E-01, /* 0x3FE921FB, 0x54442D18 */ + pi_o_2 = 1.5707963267948965580E+00, /* 0x3FF921FB, 0x54442D18 */ + pi = 3.1415926535897931160E+00, /* 0x400921FB, 0x54442D18 */ + pi_lo = 1.2246467991473531772E-16; /* 0x3CA1A626, 0x33145C07 */ + +#ifdef __STDC__ +double __ieee754_atan2(double y, double x) +#else +double __ieee754_atan2(y, x) +double y, x; +#endif +{ + double z; + _INT32 k, m, hx, hy, ix, iy; + _UINT32 lx, ly; + + hx = __HI(x); + ix = hx & 0x7fffffff; + lx = __LO(x); + hy = __HI(y); + iy = hy & 0x7fffffff; + ly = __LO(y); + if (((ix | ((lx | -lx) >> 31)) > 0x7ff00000) || + ((iy | ((ly | -ly) >> 31)) > 0x7ff00000)) /* x or y is NaN */ + return x + y; + if ((hx - 0x3ff00000 | lx) == 0) + return atan(y); /* x=1.0 */ + m = ((hy >> 31) & 1) | ((hx >> 30) & 2); /* 2*sign(x)+sign(y) */ + + /* when y = 0 */ + if ((iy | ly) == 0) { + switch (m) { + case 0: + case 1: + return y; /* atan(+-0,+anything)=+-0 */ + case 2: + return pi + tiny; /* atan(+0,-anything) = pi */ + case 3: + return -pi - tiny; /* atan(-0,-anything) =-pi */ + } + } + /* when x = 0 */ + if ((ix | lx) == 0) + return (hy < 0) ? -pi_o_2 - tiny : pi_o_2 + tiny; + + /* when x is INF */ + if (ix == 0x7ff00000) { + if (iy == 0x7ff00000) { + switch (m) { + case 0: + return pi_o_4 + tiny; /* atan(+INF,+INF) */ + case 1: + return -pi_o_4 - tiny; /* atan(-INF,+INF) */ + case 2: + return 3.0 * pi_o_4 + tiny; /*atan(+INF,-INF)*/ + case 3: + return -3.0 * pi_o_4 - tiny; /*atan(-INF,-INF)*/ + } + } else { + switch (m) { + case 0: + return zero; /* atan(+...,+INF) */ + case 1: + return -zero; /* atan(-...,+INF) */ + case 2: + return pi + tiny; /* atan(+...,-INF) */ + case 3: + return -pi - tiny; /* atan(-...,-INF) */ + } + } + } + /* when y is INF */ + if (iy == 0x7ff00000) + return (hy < 0) ? -pi_o_2 - tiny : pi_o_2 + tiny; + + /* compute y/x */ + k = (iy - ix) >> 20; + if (k > 60) + z = pi_o_2 + 0.5 * pi_lo; /* |y/x| > 2**60 */ + else if (hx < 0 && k < -60) + z = 0.0; /* |y|/x < -2**60 */ + else + z = atan(fabs(y / x)); /* safe to do y/x */ + switch (m) { + case 0: + return z; /* atan(+,+) */ + case 1: + __HI(z) ^= 0x80000000; + return z; /* atan(-,+) */ + case 2: + return pi - (z - pi_lo); /* atan(+,-) */ + default: /* case 3 */ + return (z - pi_lo) - pi; /* atan(-,-) */ + } +} diff --git a/src/MSL_C.PPCEABI.bare.H/e_exp.c b/src/MSL_C.PPCEABI.bare.H/e_exp.c new file mode 100644 index 0000000..9a52d13 --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/e_exp.c @@ -0,0 +1,162 @@ +/* @(#)e_exp.c 1.6 04/04/22 */ +/* + * ==================================================== + * Copyright (C) 2004 by Sun Microsystems, Inc. All rights reserved. + * + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ +/* __ieee754_exp(x) + * Returns the exponential of x. + * + * Method + * 1. Argument reduction: + * Reduce x to an r so that |r| <= 0.5*ln2 ~ 0.34658. + * Given x, find r and integer k such that + * + * x = k*ln2 + r, |r| <= 0.5*ln2. + * + * Here r will be represented as r = hi-lo for better + * accuracy. + * + * 2. Approximation of ieee_exp(r) by a special rational function on + * the interval [0,0.34658]: + * Write + * R(r**2) = r*(ieee_exp(r)+1)/(ieee_exp(r)-1) = 2 + r*r/6 - r**4/360 + ... + * We use a special Remes algorithm on [0,0.34658] to generate + * a polynomial of degree 5 to approximate R. The maximum error + * of this polynomial approximation is bounded by 2**-59. In + * other words, + * R(z) ~ 2.0 + P1*z + P2*z**2 + P3*z**3 + P4*z**4 + P5*z**5 + * (where z=r*r, and the values of P1 to P5 are listed below) + * and + * | 5 | -59 + * | 2.0+P1*z+...+P5*z - R(z) | <= 2 + * | | + * The computation of ieee_exp(r) thus becomes + * 2*r + * exp(r) = 1 + ------- + * R - r + * r*R1(r) + * = 1 + r + ----------- (for better accuracy) + * 2 - R1(r) + * where + * 2 4 10 + * R1(r) = r - (P1*r + P2*r + ... + P5*r ). + * + * 3. Scale back to obtain ieee_exp(x): + * From step 1, we have + * ieee_exp(x) = 2^k * ieee_exp(r) + * + * Special cases: + * exp(INF) is INF, ieee_exp(NaN) is NaN; + * exp(-INF) is 0, and + * for finite argument, only ieee_exp(0)=1 is exact. + * + * Accuracy: + * according to an error analysis, the error is always less than + * 1 ulp (unit in the last place). + * + * Misc. info. + * For IEEE double + * if x > 7.09782712893383973096e+02 then ieee_exp(x) overflow + * if x < -7.45133219101941108420e+02 then ieee_exp(x) underflow + * + * Constants: + * The hexadecimal values are the intended ones for the following + * constants. The decimal values may be used, provided that the + * compiler will convert from decimal to binary accurately enough + * to produce the hexadecimal values shown. + */ +#include "fdlibm.h" +#ifdef __STDC__ +static const double +#else +static double +#endif + one = 1.0, + halF[2] = + { + 0.5, + -0.5, +}, + huge = 1.0e+300, twom1000 = 9.33263618503218878990e-302, /* 2**-1000=0x01700000,0*/ + o_threshold = 7.09782712893383973096e+02, /* 0x40862E42, 0xFEFA39EF */ + u_threshold = -7.45133219101941108420e+02, /* 0xc0874910, 0xD52D3051 */ + ln2HI[2] = + { + 6.93147180369123816490e-01, /* 0x3fe62e42, 0xfee00000 */ + -6.93147180369123816490e-01, +}, /* 0xbfe62e42, 0xfee00000 */ + ln2LO[2] = + { + 1.90821492927058770002e-10, /* 0x3dea39ef, 0x35793c76 */ + -1.90821492927058770002e-10, +}, /* 0xbdea39ef, 0x35793c76 */ + invln2 = 1.44269504088896338700e+00, /* 0x3ff71547, 0x652b82fe */ + P1 = 1.66666666666666019037e-01, /* 0x3FC55555, 0x5555553E */ + P2 = -2.77777777770155933842e-03, /* 0xBF66C16C, 0x16BEBD93 */ + P3 = 6.61375632143793436117e-05, /* 0x3F11566A, 0xAF25DE2C */ + P4 = -1.65339022054652515390e-06, /* 0xBEBBBD41, 0xC5D26BF1 */ + P5 = 4.13813679705723846039e-08; /* 0x3E663769, 0x72BEA4D0 */ +#ifdef __STDC__ +double __ieee754_exp(double x) /* default IEEE double exp */ +#else +double __ieee754_exp(x) /* default IEEE double exp */ +double x; +#endif +{ + double y, hi, lo, c, t; + int k, xsb; + unsigned hx; + hx = __HI(x); /* high word of x */ + xsb = (hx >> 31) & 1; /* sign bit of x */ + hx &= 0x7fffffff; /* high word of |x| */ + /* filter out non-finite argument */ + if (hx >= 0x40862E42) { /* if |x|>=709.78... */ + if (hx >= 0x7ff00000) { + if (((hx & 0xfffff) | __LO(x)) != 0) + return x + x; /* NaN */ + else + return (xsb == 0) ? x : 0.0; /* ieee_exp(+-inf)={inf,0} */ + } + if (x > o_threshold) + return huge * huge; /* overflow */ + if (x < u_threshold) + return twom1000 * twom1000; /* underflow */ + } + /* argument reduction */ + if (hx > 0x3fd62e42) { /* if |x| > 0.5 ln2 */ + if (hx < 0x3FF0A2B2) { /* and |x| < 1.5 ln2 */ + hi = x - ln2HI[xsb]; + lo = ln2LO[xsb]; + k = 1 - xsb - xsb; + } else { + k = (int)(invln2 * x + halF[xsb]); + t = k; + hi = x - t * ln2HI[0]; /* t*ln2HI is exact here */ + lo = t * ln2LO[0]; + } + x = hi - lo; + } else if (hx < 0x3e300000) { /* when |x|<2**-28 */ + if (huge + x > one) + return one + x; /* trigger inexact */ + } else + k = 0; + /* x is now in primary range */ + t = x * x; + c = x - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5)))); + if (k == 0) + return one - ((x * c) / (c - 2.0) - x); + else + y = one - ((lo - (x * c) / (2.0 - c)) - hi); + if (k >= -1021) { + __HI(y) += (k << 20); /* add k to y's exponent */ + return y; + } else { + __HI(y) += ((k + 1000) << 20); /* add k to y's exponent */ + return y * twom1000; + } +} diff --git a/src/MSL_C.PPCEABI.bare.H/e_fmod.c b/src/MSL_C.PPCEABI.bare.H/e_fmod.c new file mode 100644 index 0000000..b0f2524 --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/e_fmod.c @@ -0,0 +1,167 @@ +/* @(#)e_fmod.c 1.2 95/01/04 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* + * __ieee754_fmod(x,y) + * Return x mod y in exact arithmetic + * Method: shift and subtract + */ + +#include "fdlibm.h" + +#ifdef __STDC__ +static const double one = 1.0, Zero[] = { + 0.0, + -0.0, +}; +#else +static double one = 1.0, Zero[] = { + 0.0, + -0.0, +}; +#endif + +#ifdef __STDC__ +double __ieee754_fmod(double x, double y) +#else +double __ieee754_fmod(x, y) +double x, y; +#endif +{ + _INT32 n, hx, hy, hz, ix, iy, sx, i; + _UINT32 lx, ly, lz; + + hx = __HI(x); /* high word of x */ + lx = __LO(x); /* low word of x */ + hy = __HI(y); /* high word of y */ + ly = __LO(y); /* low word of y */ + sx = hx & 0x80000000; /* sign of x */ + hx ^= sx; /* |x| */ + hy &= 0x7fffffff; /* |y| */ + + /* purge off exception values */ + if ((hy | ly) == 0 || (hx >= 0x7ff00000) || /* y=0,or x not finite */ + ((hy | ((ly | -ly) >> 31)) > 0x7ff00000)) /* or y is NaN */ + return (x * y) / (x * y); + if (hx <= hy) { + if ((hx < hy) || (lx < ly)) + return x; /* |x|<|y| return x */ + if (lx == ly) + return Zero[(_UINT32)sx >> 31]; /* |x|=|y| return x*0*/ + } + + /* determine ix = ilogb(x) */ + if (hx < 0x00100000) { /* subnormal x */ + if (hx == 0) { + for (ix = -1043, i = lx; i > 0; i <<= 1) + ix -= 1; + } else { + for (ix = -1022, i = (hx << 11); i > 0; i <<= 1) + ix -= 1; + } + } else + ix = (hx >> 20) - 1023; + + /* determine iy = ilogb(y) */ + if (hy < 0x00100000) { /* subnormal y */ + if (hy == 0) { + for (iy = -1043, i = ly; i > 0; i <<= 1) + iy -= 1; + } else { + for (iy = -1022, i = (hy << 11); i > 0; i <<= 1) + iy -= 1; + } + } else + iy = (hy >> 20) - 1023; + + /* set up {hx,lx}, {hy,ly} and align y to x */ + if (ix >= -1022) + hx = 0x00100000 | (0x000fffff & hx); + else { /* subnormal x, shift x to normal */ + n = -1022 - ix; + if (n <= 31) { + hx = (hx << n) | (lx >> (32 - n)); + lx <<= n; + } else { + hx = lx << (n - 32); + lx = 0; + } + } + if (iy >= -1022) + hy = 0x00100000 | (0x000fffff & hy); + else { /* subnormal y, shift y to normal */ + n = -1022 - iy; + if (n <= 31) { + hy = (hy << n) | (ly >> (32 - n)); + ly <<= n; + } else { + hy = ly << (n - 32); + ly = 0; + } + } + + /* fix point fmod */ + n = ix - iy; + while (n--) { + hz = hx - hy; + lz = lx - ly; + if (lx < ly) + hz -= 1; + if (hz < 0) { + hx = hx + hx + (lx >> 31); + lx = lx + lx; + } else { + if ((hz | lz) == 0) /* return sign(x)*0 */ + return Zero[(_UINT32)sx >> 31]; + hx = hz + hz + (lz >> 31); + lx = lz + lz; + } + } + hz = hx - hy; + lz = lx - ly; + if (lx < ly) + hz -= 1; + if (hz >= 0) { + hx = hz; + lx = lz; + } + + /* convert back to floating value and restore the sign */ + if ((hx | lx) == 0) /* return sign(x)*0 */ + return Zero[(_UINT32)sx >> 31]; + while (hx < 0x00100000) { /* normalize x */ + hx = hx + hx + (lx >> 31); + lx = lx + lx; + iy -= 1; + } + if (iy >= -1022) { /* normalize output */ + hx = ((hx - 0x00100000) | ((iy + 1023) << 20)); + __HI(x) = hx | sx; + __LO(x) = lx; + } else { /* subnormal output */ + n = -1022 - iy; + if (n <= 20) { + lx = (lx >> n) | ((_UINT32)hx << (32 - n)); + hx >>= n; + } else if (n <= 31) { + lx = (hx << (32 - n)) | (lx >> n); + hx = sx; + } else { + lx = hx >> (n - 32); + hx = sx; + } + __HI(x) = hx | sx; + __LO(x) = lx; + x *= one; /* create necessary signal */ + } + return x; /* exact output */ +} diff --git a/src/MSL_C.PPCEABI.bare.H/e_log.c b/src/MSL_C.PPCEABI.bare.H/e_log.c new file mode 100644 index 0000000..abeb901 --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/e_log.c @@ -0,0 +1,158 @@ +/* @(#)e_log.c 1.2 95/01/04 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* __ieee754_log(x) + * Return the logrithm of x + * + * Method : + * 1. Argument Reduction: find k and f such that + * x = 2^k * (1+f), + * where sqrt(2)/2 < 1+f < sqrt(2) . + * + * 2. Approximation of log(1+f). + * Let s = f/(2+f) ; based on log(1+f) = log(1+s) - log(1-s) + * = 2s + 2/3 s**3 + 2/5 s**5 + ....., + * = 2s + s*R + * We use a special Reme algorithm on [0,0.1716] to generate + * a polynomial of degree 14 to approximate R The maximum error + * of this polynomial approximation is bounded by 2**-58.45. In + * other words, + * 2 4 6 8 10 12 14 + * R(z) ~ Lg1*s +Lg2*s +Lg3*s +Lg4*s +Lg5*s +Lg6*s +Lg7*s + * (the values of Lg1 to Lg7 are listed in the program) + * and + * | 2 14 | -58.45 + * | Lg1*s +...+Lg7*s - R(z) | <= 2 + * | | + * Note that 2s = f - s*f = f - hfsq + s*hfsq, where hfsq = f*f/2. + * In order to guarantee error in log below 1ulp, we compute log + * by + * log(1+f) = f - s*(f - R) (if f is not too large) + * log(1+f) = f - (hfsq - s*(hfsq+R)). (better accuracy) + * + * 3. Finally, log(x) = k*ln2 + log(1+f). + * = k*ln2_hi+(f-(hfsq-(s*(hfsq+R)+k*ln2_lo))) + * Here ln2 is split into two floating point number: + * ln2_hi + ln2_lo, + * where n*ln2_hi is always exact for |n| < 2000. + * + * Special cases: + * log(x) is NaN with signal if x < 0 (including -INF) ; + * log(+INF) is +INF; log(0) is -INF with signal; + * log(NaN) is that NaN with no signal. + * + * Accuracy: + * according to an error analysis, the error is always less than + * 1 ulp (unit in the last place). + * + * Constants: + * The hexadecimal values are the intended ones for the following + * constants. The decimal values may be used, provided that the + * compiler will convert from decimal to binary accurately enough + * to produce the hexadecimal values shown. + */ + +#include "fdlibm.h" + +#ifdef __STDC__ +static const double +#else +static double +#endif + ln2_hi = 6.93147180369123816490e-01, /* 3fe62e42 fee00000 */ + ln2_lo = 1.90821492927058770002e-10, /* 3dea39ef 35793c76 */ + two54 = 1.80143985094819840000e+16, /* 43500000 00000000 */ + Lg1 = 6.666666666666735130e-01, /* 3FE55555 55555593 */ + Lg2 = 3.999999999940941908e-01, /* 3FD99999 9997FA04 */ + Lg3 = 2.857142874366239149e-01, /* 3FD24924 94229359 */ + Lg4 = 2.222219843214978396e-01, /* 3FCC71C5 1D8E78AF */ + Lg5 = 1.818357216161805012e-01, /* 3FC74664 96CB03DE */ + Lg6 = 1.531383769920937332e-01, /* 3FC39A09 D078C69F */ + Lg7 = 1.479819860511658591e-01; /* 3FC2F112 DF3E5244 */ + +static double zero = 0.0; + +#ifdef __STDC__ +double __ieee754_log(double x) +#else +double __ieee754_log(x) +double x; +#endif +{ + double hfsq, f, s, z, R, w, t1, t2, dk; + _INT32 k, hx, i, j; + _UINT32 lx; + + hx = __HI(x); /* high word of x */ + lx = __LO(x); /* low word of x */ + + k = 0; + if (hx < 0x00100000) { /* x < 2**-1022 */ + if (((hx & 0x7fffffff) | lx) == 0) + return -two54 / zero; /* log(+-0)=-inf */ + if (hx < 0) { +#ifdef __STDC__ + errno = EDOM; +#endif + return (x - x) / zero; /* log(-#) = NaN */ + } + k -= 54; + x *= two54; /* subnormal number, scale up x */ + hx = __HI(x); /* high word of x */ + } + if (hx >= 0x7ff00000) + return x + x; + k += (hx >> 20) - 1023; + hx &= 0x000fffff; + i = (hx + 0x95f64) & 0x100000; + __HI(x) = hx | (i ^ 0x3ff00000); /* normalize x or x/2 */ + k += (i >> 20); + f = x - 1.0; + if ((0x000fffff & (2 + hx)) < 3) { /* |f| < 2**-20 */ + if (f == zero) + if (k == 0) + return zero; + else { + dk = (double)k; + return dk * ln2_hi + dk * ln2_lo; + } + R = f * f * (0.5 - 0.33333333333333333 * f); + if (k == 0) + return f - R; + else { + dk = (double)k; + return dk * ln2_hi - ((R - dk * ln2_lo) - f); + } + } + s = f / (2.0 + f); + dk = (double)k; + z = s * s; + i = hx - 0x6147a; + w = z * z; + j = 0x6b851 - hx; + t1 = w * (Lg2 + w * (Lg4 + w * Lg6)); + t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7))); + i |= j; + R = t2 + t1; + if (i > 0) { + hfsq = 0.5 * f * f; + if (k == 0) + return f - (hfsq - s * (hfsq + R)); + else + return dk * ln2_hi - ((hfsq - (s * (hfsq + R) + dk * ln2_lo)) - f); + } else { + if (k == 0) + return f - s * (f - R); + else + return dk * ln2_hi - ((s * (f - R) - dk * ln2_lo) - f); + } +} diff --git a/src/MSL_C.PPCEABI.bare.H/e_pow.c b/src/MSL_C.PPCEABI.bare.H/e_pow.c new file mode 100644 index 0000000..335679d --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/e_pow.c @@ -0,0 +1,353 @@ +/* @(#)e_pow.c 1.2 95/01/04 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* __ieee754_pow(x,y) return x**y + * + * n + * Method: Let x = 2 * (1+f) + * 1. Compute and return log2(x) in two pieces: + * log2(x) = w1 + w2, + * where w1 has 53-24 = 29 bit trailing zeros. + * 2. Perform y*log2(x) = n+y' by simulating muti-precision + * arithmetic, where |y'|<=0.5. + * 3. Return x**y = 2**n*exp(y'*log2) + * + * Special cases: + * 1. (anything) ** 0 is 1 + * 2. (anything) ** 1 is itself + * 3. (anything) ** NAN is NAN + * 4. NAN ** (anything except 0) is NAN + * 5. +-(|x| > 1) ** +INF is +INF + * 6. +-(|x| > 1) ** -INF is +0 + * 7. +-(|x| < 1) ** +INF is +0 + * 8. +-(|x| < 1) ** -INF is +INF + * 9. +-1 ** +-INF is NAN + * 10. +0 ** (+anything except 0, NAN) is +0 + * 11. -0 ** (+anything except 0, NAN, odd integer) is +0 + * 12. +0 ** (-anything except 0, NAN) is +INF + * 13. -0 ** (-anything except 0, NAN, odd integer) is +INF + * 14. -0 ** (odd integer) = -( +0 ** (odd integer) ) + * 15. +INF ** (+anything except 0,NAN) is +INF + * 16. +INF ** (-anything except 0,NAN) is +0 + * 17. -INF ** (anything) = -0 ** (-anything) + * 18. (-anything) ** (integer) is (-1)**(integer)*(+anything**integer) + * 19. (-anything except 0 and inf) ** (non-integer) is NAN + * + * Accuracy: + * pow(x,y) returns x**y nearly rounded. In particular + * pow(integer,integer) + * always returns the correct integer provided it is + * representable. + * + * Constants : + * The hexadecimal values are the intended ones for the following + * constants. The decimal values may be used, provided that the + * compiler will convert from decimal to binary accurately enough + * to produce the hexadecimal values shown. + */ + +#include "fdlibm.h" +#ifdef __STDC__ +static const double +#else +static double +#endif + bp[] = + { + 1.0, + 1.5, +}, + dp_h[] = + { + 0.0, + 5.84962487220764160156e-01, +}, /* 0x3FE2B803, 0x40000000 */ + dp_l[] = + { + 0.0, + 1.35003920212974897128e-08, +}, /* 0x3E4CFDEB, 0x43CFD006 */ + zero = 0.0, one = 1.0, two = 2.0, two53 = 9007199254740992.0, /* 0x43400000, 0x00000000 */ + big = 1.0e300, tiny = 1.0e-300, + /* poly coefs for (3/2)*(log(x)-2s-2/3*s**3 */ + L1 = 5.99999999999994648725e-01, /* 0x3FE33333, 0x33333303 */ + L2 = 4.28571428578550184252e-01, /* 0x3FDB6DB6, 0xDB6FABFF */ + L3 = 3.33333329818377432918e-01, /* 0x3FD55555, 0x518F264D */ + L4 = 2.72728123808534006489e-01, /* 0x3FD17460, 0xA91D4101 */ + L5 = 2.30660745775561754067e-01, /* 0x3FCD864A, 0x93C9DB65 */ + L6 = 2.06975017800338417784e-01, /* 0x3FCA7E28, 0x4A454EEF */ + P1 = 1.66666666666666019037e-01, /* 0x3FC55555, 0x5555553E */ + P2 = -2.77777777770155933842e-03, /* 0xBF66C16C, 0x16BEBD93 */ + P3 = 6.61375632143793436117e-05, /* 0x3F11566A, 0xAF25DE2C */ + P4 = -1.65339022054652515390e-06, /* 0xBEBBBD41, 0xC5D26BF1 */ + P5 = 4.13813679705723846039e-08, /* 0x3E663769, 0x72BEA4D0 */ + lg2 = 6.93147180559945286227e-01, /* 0x3FE62E42, 0xFEFA39EF */ + lg2_h = 6.93147182464599609375e-01, /* 0x3FE62E43, 0x00000000 */ + lg2_l = -1.90465429995776804525e-09, /* 0xBE205C61, 0x0CA86C39 */ + ovt = 8.0085662595372944372e-0017, /* -(1024-log2(ovfl+.5ulp)) */ + cp = 9.61796693925975554329e-01, /* 0x3FEEC709, 0xDC3A03FD =2/(3ln2) */ + cp_h = 9.61796700954437255859e-01, /* 0x3FEEC709, 0xE0000000 =(float)cp */ + cp_l = -7.02846165095275826516e-09, /* 0xBE3E2FE0, 0x145B01F5 =tail of cp_h*/ + ivln2 = 1.44269504088896338700e+00, /* 0x3FF71547, 0x652B82FE =1/ln2 */ + ivln2_h = 1.44269502162933349609e+00, /* 0x3FF71547, 0x60000000 =24b 1/ln2*/ + ivln2_l = 1.92596299112661746887e-08; /* 0x3E54AE0B, 0xF85DDF44 =1/ln2 tail*/ + +#ifdef __STDC__ +double __ieee754_pow(double x, double y) +#else +double __ieee754_pow(x, y) +double x, y; +#endif +{ + double z, ax, z_h, z_l, p_h, p_l; + double y1, t1, t2, r, s, t, u, v, w; + _INT32 i, j, k, yisint, n; + _INT32 hx, hy, ix, iy; + _UINT32 lx, ly; + + hx = __HI(x); + lx = __LO(x); + hy = __HI(y); + ly = __LO(y); + ix = hx & 0x7fffffff; + iy = hy & 0x7fffffff; + + /* y==zero: x**0 = 1 */ + if ((iy | ly) == 0) + return one; + + /* +-NaN return x+y */ + if (ix > 0x7ff00000 || ((ix == 0x7ff00000) && (lx != 0)) || iy > 0x7ff00000 || + ((iy == 0x7ff00000) && (ly != 0))) { + return x + y; +#ifdef __STDC__ + errno = EDOM; /* mf-- added to conform to old ANSI standard */ +#endif + } + + /* determine if y is an odd int when x < 0 + * yisint = 0 ... y is not an integer + * yisint = 1 ... y is an odd int + * yisint = 2 ... y is an even int + */ + yisint = 0; + if (hx < 0) { + if (iy >= 0x43400000) + yisint = 2; /* even integer y */ + else if (iy >= 0x3ff00000) { + k = (iy >> 20) - 0x3ff; /* exponent */ + if (k > 20) { + j = ly >> (52 - k); + if ((j << (52 - k)) == ly) + yisint = 2 - (j & 1); + } else if (ly == 0) { + j = iy >> (20 - k); + if ((j << (20 - k)) == iy) + yisint = 2 - (j & 1); + } + } + } + + /* special value of y */ + if (ly == 0) { + if (iy == 0x7ff00000) { + + /* y is +-inf */ + if (((ix - 0x3ff00000) | lx) == 0) + return y - y; /* inf**+-1 is NaN */ + else if (ix >= 0x3ff00000) /* (|x|>1)**+-inf = inf,0 */ + return (hy >= 0) ? y : zero; + else /* (|x|<1)**-,+inf = inf,0 */ + return (hy < 0) ? -y : zero; + } + if (iy == 0x3ff00000) { + /* y is +-1 */ + if (hy < 0) + return one / x; + else + return x; + } + if (hy == 0x40000000) + return x * x; /* y is 2 */ + if (hy == 0x3fe00000) { /* y is 0.5 */ + if (hx >= 0) /* x >= +0 */ + return sqrt(x); + } + } + + ax = fabs(x); + /* special value of x */ + if (lx == 0) { + if (ix == 0x7ff00000 || ix == 0 || ix == 0x3ff00000) { + z = ax; /*x is +-0,+-inf,+-1*/ + if (hy < 0) + z = one / z; /* z = (1/|x|) */ + if (hx < 0) { + if (((ix - 0x3ff00000) | yisint) == 0) { + z = (z - z) / (z - z); /* (-1)**non-int is NaN */ + } else if (yisint == 1) + z = -z; /* (x<0)**odd = -(|x|**odd) */ + } + return z; + } + } + + /* (x<0)**(non-int) is NaN */ + if ((((hx >> 31) + 1) | yisint) == 0) { +#ifdef __STDC__ + errno = EDOM; /* mf-- added to conform to old ANSI standard */ +#endif + return NAN; + } + + /* |y| is big */ + if (iy > 0x41e00000) { /* if |y| > 2**31 */ + if (iy > 0x43f00000) { /* if |y| > 2**64, must o/uflow */ + if (ix <= 0x3fefffff) + return (hy < 0) ? big * big : tiny * tiny; + if (ix >= 0x3ff00000) + return (hy > 0) ? big * big : tiny * tiny; + } + /* over/underflow if x is not close to one */ + if (ix < 0x3fefffff) + return (hy < 0) ? big * big : tiny * tiny; + if (ix > 0x3ff00000) + return (hy > 0) ? big * big : tiny * tiny; + /* now |1-x| is tiny <= 2**-20, suffice to compute + log(x) by x-x^2/2+x^3/3-x^4/4 */ + t = x - 1; /* t has 20 trailing zeros */ + w = (t * t) * (0.5 - t * (0.3333333333333333333333 - t * 0.25)); + u = ivln2_h * t; /* ivln2_h has 21 sig. bits */ + v = t * ivln2_l - w * ivln2; + t1 = u + v; + __LO(t1) = 0; + t2 = v - (t1 - u); + } else { + double s2, s_h, s_l, t_h, t_l; + n = 0; + /* take care subnormal number */ + if (ix < 0x00100000) { + ax *= two53; + n -= 53; + ix = __HI(ax); + } + n += ((ix) >> 20) - 0x3ff; + j = ix & 0x000fffff; + /* determine interval */ + ix = j | 0x3ff00000; /* normalize ix */ + if (j <= 0x3988E) + k = 0; /* |x|<sqrt(3/2) */ + else if (j < 0xBB67A) + k = 1; /* |x|<sqrt(3) */ + else { + k = 0; + n += 1; + ix -= 0x00100000; + } + __HI(ax) = ix; + + /* compute s = s_h+s_l = (x-1)/(x+1) or (x-1.5)/(x+1.5) */ + u = ax - bp[k]; /* bp[0]=1.0, bp[1]=1.5 */ + v = one / (ax + bp[k]); + s = u * v; + s_h = s; + __LO(s_h) = 0; + /* t_h=ax+bp[k] High */ + t_h = zero; + __HI(t_h) = ((ix >> 1) | 0x20000000) + 0x00080000 + (k << 18); + t_l = ax - (t_h - bp[k]); + s_l = v * ((u - s_h * t_h) - s_h * t_l); + /* compute log(ax) */ + s2 = s * s; + r = s2 * s2 * (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6))))); + r += s_l * (s_h + s); + s2 = s_h * s_h; + t_h = 3.0 + s2 + r; + __LO(t_h) = 0; + t_l = r - ((t_h - 3.0) - s2); + /* u+v = s*(1+...) */ + u = s_h * t_h; + v = s_l * t_h + t_l * s; + /* 2/(3log2)*(s+...) */ + p_h = u + v; + __LO(p_h) = 0; + p_l = v - (p_h - u); + z_h = cp_h * p_h; /* cp_h+cp_l = 2/(3*log2) */ + z_l = cp_l * p_h + p_l * cp + dp_l[k]; + /* log2(ax) = (s+..)*2/(3*log2) = n + dp_h + z_h + z_l */ + t = (double)n; + t1 = (((z_h + z_l) + dp_h[k]) + t); + __LO(t1) = 0; + t2 = z_l - (((t1 - t) - dp_h[k]) - z_h); + } + + s = one; /* s (sign of result -ve**odd) = -1 else = 1 */ + if ((((hx >> 31) + 1) | (yisint - 1)) == 0) + s = -one; /* (-ve)**(odd int) */ + + /* split up y into y1+y2 and compute (y1+y2)*(t1+t2) */ + y1 = y; + __LO(y1) = 0; + p_l = (y - y1) * t1 + y * t2; + p_h = y1 * t1; + z = p_l + p_h; + j = __HI(z); + i = __LO(z); + if (j >= 0x40900000) { /* z >= 1024 */ + if (((j - 0x40900000) | i) != 0) /* if z > 1024 */ + return s * big * big; /* overflow */ + else { + if (p_l + ovt > z - p_h) + return s * big * big; /* overflow */ + } + } else if ((j & 0x7fffffff) >= 0x4090cc00) { /* z <= -1075 */ + if (((j - 0xc090cc00) | i) != 0) /* z < -1075 */ + return s * tiny * tiny; /* underflow */ + else { + if (p_l <= z - p_h) + return s * tiny * tiny; /* underflow */ + } + } + /* + * compute 2**(p_h+p_l) + */ + i = j & 0x7fffffff; + k = (i >> 20) - 0x3ff; + n = 0; + if (i > 0x3fe00000) { /* if |z| > 0.5, set n = [z+0.5] */ + n = j + (0x00100000 >> (k + 1)); + k = ((n & 0x7fffffff) >> 20) - 0x3ff; /* new k for n */ + t = zero; + __HI(t) = (n & ~(0x000fffff >> k)); + n = ((n & 0x000fffff) | 0x00100000) >> (20 - k); + if (j < 0) + n = -n; + p_h -= t; + } + t = p_l + p_h; + __LO(t) = 0; + u = t * lg2_h; + v = (p_l - (t - p_h)) * lg2 + t * lg2_l; + z = u + v; + w = v - (z - u); + t = z * z; + t1 = z - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5)))); + r = (z * t1) / (t1 - two) - (w + z * w); + z = one - (r - z); + j = __HI(z); + j += (n << 20); + if ((j >> 20) <= 0) + z = scalbn(z, n); /* subnormal output */ + else + __HI(z) += (n << 20); + return s * z; +} diff --git a/src/MSL_C.PPCEABI.bare.H/e_rem_pio2.c b/src/MSL_C.PPCEABI.bare.H/e_rem_pio2.c new file mode 100644 index 0000000..6bdf342 --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/e_rem_pio2.c @@ -0,0 +1,184 @@ +/* @(#)e_rem_pio2.c 1.3 95/01/04 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + * + */ + +/* __ieee754_rem_pio2(x,y) + * + * return the remainder of x rem pi/2 in y[0]+y[1] + * use __kernel_rem_pio2() + */ + +#include "fdlibm.h" + +/* + * Table of constants for 2/pi, 396 Hex digits (476 decimal) of 2/pi + */ + +#ifdef __STDC__ +static const _INT32 two_over_pi[] = { +#else +static _INT32 two_over_pi[] = { +#endif + 0xA2F983, 0x6E4E44, 0x1529FC, 0x2757D1, 0xF534DD, 0xC0DB62, 0x95993C, 0x439041, 0xFE5163, + 0xABDEBB, 0xC561B7, 0x246E3A, 0x424DD2, 0xE00649, 0x2EEA09, 0xD1921C, 0xFE1DEB, 0x1CB129, + 0xA73EE8, 0x8235F5, 0x2EBB44, 0x84E99C, 0x7026B4, 0x5F7E41, 0x3991D6, 0x398353, 0x39F49C, + 0x845F8B, 0xBDF928, 0x3B1FF8, 0x97FFDE, 0x05980F, 0xEF2F11, 0x8B5A0A, 0x6D1F6D, 0x367ECF, + 0x27CB09, 0xB74F46, 0x3F669E, 0x5FEA2D, 0x7527BA, 0xC7EBE5, 0xF17B3D, 0x0739F7, 0x8A5292, + 0xEA6BFB, 0x5FB11F, 0x8D5D08, 0x560330, 0x46FC7B, 0x6BABF0, 0xCFBC20, 0x9AF436, 0x1DA9E3, + 0x91615E, 0xE61B08, 0x659985, 0x5F14A0, 0x68408D, 0xFFD880, 0x4D7327, 0x310606, 0x1556CA, + 0x73A8C9, 0x60E27B, 0xC08C6B, +}; + +#ifdef __STDC__ +static const _INT32 npio2_hw[] = { +#else +static _INT32 npio2_hw[] = { +#endif + 0x3FF921FB, 0x400921FB, 0x4012D97C, 0x401921FB, 0x401F6A7A, 0x4022D97C, 0x4025FDBB, 0x402921FB, + 0x402C463A, 0x402F6A7A, 0x4031475C, 0x4032D97C, 0x40346B9C, 0x4035FDBB, 0x40378FDB, 0x403921FB, + 0x403AB41B, 0x403C463A, 0x403DD85A, 0x403F6A7A, 0x40407E4C, 0x4041475C, 0x4042106C, 0x4042D97C, + 0x4043A28C, 0x40446B9C, 0x404534AC, 0x4045FDBB, 0x4046C6CB, 0x40478FDB, 0x404858EB, 0x404921FB, +}; + +/* + * invpio2: 53 bits of 2/pi + * pio2_1: first 33 bit of pi/2 + * pio2_1t: pi/2 - pio2_1 + * pio2_2: second 33 bit of pi/2 + * pio2_2t: pi/2 - (pio2_1+pio2_2) + * pio2_3: third 33 bit of pi/2 + * pio2_3t: pi/2 - (pio2_1+pio2_2+pio2_3) + */ + +#ifdef __STDC__ +static const double +#else +static double +#endif + zero = 0.00000000000000000000e+00, /* 0x00000000, 0x00000000 */ + half = 5.00000000000000000000e-01, /* 0x3FE00000, 0x00000000 */ + two24 = 1.67772160000000000000e+07, /* 0x41700000, 0x00000000 */ + invpio2 = 6.36619772367581382433e-01, /* 0x3FE45F30, 0x6DC9C883 */ + pio2_1 = 1.57079632673412561417e+00, /* 0x3FF921FB, 0x54400000 */ + pio2_1t = 6.07710050650619224932e-11, /* 0x3DD0B461, 0x1A626331 */ + pio2_2 = 6.07710050630396597660e-11, /* 0x3DD0B461, 0x1A600000 */ + pio2_2t = 2.02226624879595063154e-21, /* 0x3BA3198A, 0x2E037073 */ + pio2_3 = 2.02226624871116645580e-21, /* 0x3BA3198A, 0x2E000000 */ + pio2_3t = 8.47842766036889956997e-32; /* 0x397B839A, 0x252049C1 */ + +#ifdef __STDC__ +_INT32 __ieee754_rem_pio2(double x, double* y) +#else +_INT32 __ieee754_rem_pio2(x, y) +double x, y[]; +#endif +{ + double z, w, t, r, fn; + double tx[3]; + _INT32 e0, i, j, nx, n, ix, hx; + + hx = __HI(x); /* high word of x */ + ix = hx & 0x7fffffff; + if (ix <= 0x3fe921fb) /* |x| ~<= pi/4 , no need for reduction */ + { + y[0] = x; + y[1] = 0; + return 0; + } + if (ix < 0x4002d97c) { /* |x| < 3pi/4, special case with n=+-1 */ + if (hx > 0) { + z = x - pio2_1; + if (ix != 0x3ff921fb) { /* 33+53 bit pi is good enough */ + y[0] = z - pio2_1t; + y[1] = (z - y[0]) - pio2_1t; + } else { /* near pi/2, use 33+33+53 bit pi */ + z -= pio2_2; + y[0] = z - pio2_2t; + y[1] = (z - y[0]) - pio2_2t; + } + return 1; + } else { /* negative x */ + z = x + pio2_1; + if (ix != 0x3ff921fb) { /* 33+53 bit pi is good enough */ + y[0] = z + pio2_1t; + y[1] = (z - y[0]) + pio2_1t; + } else { /* near pi/2, use 33+33+53 bit pi */ + z += pio2_2; + y[0] = z + pio2_2t; + y[1] = (z - y[0]) + pio2_2t; + } + return -1; + } + } + if (ix <= 0x413921fb) { /* |x| ~<= 2^19*(pi/2), medium size */ + t = fabs(x); + n = (_INT32)(t * invpio2 + half); + fn = (double)n; + r = t - fn * pio2_1; + w = fn * pio2_1t; /* 1st round good to 85 bit */ + if (n < 32 && ix != npio2_hw[n - 1]) { + y[0] = r - w; /* quick check no cancellation */ + } else { + j = ix >> 20; + y[0] = r - w; + i = j - (((__HI(y[0])) >> 20) & 0x7ff); + if (i > 16) { /* 2nd iteration needed, good to 118 */ + t = r; + w = fn * pio2_2; + r = t - w; + w = fn * pio2_2t - ((t - r) - w); + y[0] = r - w; + i = j - (((__HI(y[0])) >> 20) & 0x7ff); + if (i > 49) { /* 3rd iteration need, 151 bits acc */ + t = r; /* will cover all possible cases */ + w = fn * pio2_3; + r = t - w; + w = fn * pio2_3t - ((t - r) - w); + y[0] = r - w; + } + } + } + y[1] = (r - y[0]) - w; + if (hx < 0) { + y[0] = -y[0]; + y[1] = -y[1]; + return -n; + } else + return n; + } + /* + * all other (large) arguments + */ + if (ix >= 0x7ff00000) { /* x is inf or NaN */ + y[0] = y[1] = x - x; + return 0; + } + /* set z = scalbn(|x|,ilogb(x)-23) */ + __LO(z) = __LO(x); + e0 = (ix >> 20) - 1046; /* e0 = ilogb(z)-23; */ + __HI(z) = ix - (e0 << 20); + for (i = 0; i < 2; i++) { + tx[i] = (double)((_INT32)(z)); + z = (z - tx[i]) * two24; + } + tx[2] = z; + nx = 3; + while (tx[nx - 1] == zero) + nx--; /* skip zero term */ + n = __kernel_rem_pio2(tx, y, e0, nx, 2, two_over_pi); + if (hx < 0) { + y[0] = -y[0]; + y[1] = -y[1]; + return -n; + } + return n; +} diff --git a/src/MSL_C.PPCEABI.bare.H/errno.c b/src/MSL_C.PPCEABI.bare.H/errno.c new file mode 100644 index 0000000..d013499 --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/errno.c @@ -0,0 +1,3 @@ +#include <errno.h> + +int errno; diff --git a/src/MSL_C.PPCEABI.bare.H/fdlibm.h b/src/MSL_C.PPCEABI.bare.H/fdlibm.h new file mode 100644 index 0000000..5040cae --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/fdlibm.h @@ -0,0 +1,149 @@ +/* @(#)fdlibm.h 1.2 95/01/04 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ +#ifdef __STDC__ +#include <errno.h> +#include <math.h> +#endif + +#define _IEEE_LIBM + +#if __option(little_endian) +#define __HIp(x) *(1 + (_INT32*)x) +#define __LOp(x) *(_INT32*)x +#else +#define __HIp(x) *(_INT32*)x +#define __LOp(x) *(1 + (_INT32*)x) +#endif + +#ifdef __STDC__ +#define __P(p) p +#else +#define __P(p) () +#endif + +/* + * ANSI/POSIX + */ + +extern int signgam; + +#define MAXFLOAT ((float)3.40282346638528860e+38) + +enum fdversion { fdlibm_ieee = -1, fdlibm_svid, fdlibm_xopen, fdlibm_posix }; + +#define _LIB_VERSION_TYPE enum fdversion +#define _LIB_VERSION _fdlib_version + +/* if global variable _LIB_VERSION is not desirable, one may + * change the following to be a constant by: + * #define _LIB_VERSION_TYPE const enum version + * In that case, after one initializes the value _LIB_VERSION (see + * s_lib_version.c) during compile time, it cannot be modified + * in the middle of a program + */ +extern _LIB_VERSION_TYPE _LIB_VERSION; + +#define _IEEE_ fdlibm_ieee +#define _SVID_ fdlibm_svid +#define _XOPEN_ fdlibm_xopen +#define _POSIX_ fdlibm_posix + +struct exception { + int type; + char* name; + double arg1; + double arg2; + double retval; +}; + +#define HUGE MAXFLOAT + +/* + * set X_TLOSS = pi*2**52, which is possibly defined in <values.h> + * (one may replace the following line by "#include <values.h>") + */ + +#define X_TLOSS 1.41484755040568800000e+16 + +#define DOMAIN 1 +#define SING 2 +#define OVERFLOW 3 +#define UNDERFLOW 4 +#define TLOSS 5 +#define PLOSS 6 + +/* + * ANSI/POSIX + */ + +extern int matherr __P((struct exception*)); + +/* + * IEEE Test Vector + */ +extern double significand __P((double)); + +/* + * Functions callable from C, intended to support IEEE arithmetic. + */ + +extern int ilogb __P((double)); + +/* + * BSD math library entry points + */ + +/* + * Reentrant version of gamma & lgamma; passes signgam back by reference + * as the second argument; user must allocate space for signgam. + */ +#ifdef _REENTRANT +extern double gamma_r __P((double, int*)); +extern double lgamma_r __P((double, int*)); +#endif /* _REENTRANT */ + +/* ieee style elementary functions */ +extern double __ieee754_sqrt __P((double)); +extern double __ieee754_acos __P((double)); +extern double __ieee754_acosh __P((double)); +extern double __ieee754_log __P((double)); +extern double __ieee754_atanh __P((double)); +extern double __ieee754_asin __P((double)); +extern double __ieee754_atan2 __P((double, double)); +extern double __ieee754_exp __P((double)); +extern double __ieee754_cosh __P((double)); +extern double __ieee754_fmod __P((double, double)); +extern double __ieee754_pow __P((double, double)); +extern double __ieee754_lgamma_r __P((double, int*)); +extern double __ieee754_gamma_r __P((double, int*)); +extern double __ieee754_lgamma __P((double)); +extern double __ieee754_gamma __P((double)); +extern double __ieee754_log10 __P((double)); +extern double __ieee754_sinh __P((double)); +extern double __ieee754_hypot __P((double, double)); +extern double __ieee754_j0 __P((double)); +extern double __ieee754_j1 __P((double)); +extern double __ieee754_y0 __P((double)); +extern double __ieee754_y1 __P((double)); +extern double __ieee754_jn __P((int, double)); +extern double __ieee754_yn __P((int, double)); +extern double __ieee754_remainder __P((double, double)); +extern int __ieee754_rem_pio2 __P((double, double*)); + +extern double __ieee754_scalb __P((double, int)); + +/* fdlibm kernel function */ +extern double __kernel_standard __P((double, double, int)); +extern double __kernel_sin __P((double, double, int)); +extern double __kernel_cos __P((double, double)); +extern double __kernel_tan __P((double, double, int)); +extern int __kernel_rem_pio2 __P((double*, double*, int, int, int, const int*)); diff --git a/src/MSL_C.PPCEABI.bare.H/file_io.c b/src/MSL_C.PPCEABI.bare.H/file_io.c new file mode 100644 index 0000000..a05a7ab --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/file_io.c @@ -0,0 +1,70 @@ +#include "ansi_files.h" +#include "types.h" + +#pragma dont_inline on +int fclose(FILE* file) { + int flush_result, close_result; + + if (file == nullptr) + return (-1); + if (file->mode.file_kind == __closed_file) + return (0); + + flush_result = fflush(file); + + close_result = (*file->close_proc)(file->handle); + + file->mode.file_kind = __closed_file; + file->handle = NULL; + + if (file->state.free_buffer) + free(file->buffer); + return ((flush_result || close_result) ? -1 : 0); +} + +int fflush(FILE* file) { + int pos; + + if (file == nullptr) { + return __flush_all(); + } + + if (file->state.error != 0 || file->mode.file_kind == __closed_file) { + return -1; + } + + if (file->mode.io_mode == 1) { + return 0; + } + + if (file->state.io_state >= 3) { + file->state.io_state = 2; + } + + if (file->state.io_state == 2) { + file->buffer_len = 0; + } + + if (file->state.io_state != 1) { + file->state.io_state = 0; + return 0; + } + + if (file->mode.file_kind != __disk_file) { + pos = 0; + } else { + pos = ftell(file); + } + + if (__flush_buffer(file, 0) != 0) { + file->state.error = 1; + file->buffer_len = 0; + return -1; + } + + file->state.io_state = 0; + file->position = pos; + file->buffer_len = 0; + return 0; +} +#pragma dont_inline reset diff --git a/src/MSL_C.PPCEABI.bare.H/float.c b/src/MSL_C.PPCEABI.bare.H/float.c new file mode 100644 index 0000000..333680a --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/float.c @@ -0,0 +1,17 @@ + +#include "math.h" + +_INT32 __float_nan[] = {0x7FFFFFFF}; +_INT32 __float_huge[] = {0x7F800000}; +_INT32 __double_min[] = {0x00100000, 0}; +_INT32 __double_max[] = {0x7fefffff, 0xffffffff}; +_INT32 __double_epsilon[] = {0x3cb00000, 0}; +_INT32 __double_tiny[] = {0, 1}; +_INT32 __double_huge[] = {0x7FF00000, 0}; +_INT32 __double_nan[] = {0x7FFFFFFF, 0xFFFFFFFF}; +_INT32 __extended_min[] = {0x00100000, 0}; +_INT32 __extended_max[] = {0x7fefffff, 0xffffffff}; +_INT32 __extended_epsilon[] = {0x3cb00000, 0}; +_INT32 __extended_tiny[] = {0, 1}; +_INT32 __extended_huge[] = {0x7FF00000, 0}; +_INT32 __extended_nan[] = {0x7FFFFFFF, 0xFFFFFFFF}; diff --git a/src/MSL_C.PPCEABI.bare.H/hyperbolicsf.c b/src/MSL_C.PPCEABI.bare.H/hyperbolicsf.c new file mode 100644 index 0000000..404e9e9 --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/hyperbolicsf.c @@ -0,0 +1 @@ +double fabsf__Ff(float f1) { return __fabs(f1); } diff --git a/src/MSL_C.PPCEABI.bare.H/k_cos.c b/src/MSL_C.PPCEABI.bare.H/k_cos.c new file mode 100644 index 0000000..6780afe --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/k_cos.c @@ -0,0 +1,92 @@ +/* @(#)k_cos.c 1.2 95/01/04 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* + * __kernel_cos( x, y ) + * kernel cos function on [-pi/4, pi/4], pi/4 ~ 0.785398164 + * Input x is assumed to be bounded by ~pi/4 in magnitude. + * Input y is the tail of x. + * + * Algorithm + * 1. Since cos(-x) = cos(x), we need only to consider positive x. + * 2. if x < 2^-27 (hx<0x3e400000 0), return 1 with inexact if x!=0. + * 3. cos(x) is approximated by a polynomial of degree 14 on + * [0,pi/4] + * 4 14 + * cos(x) ~ 1 - x*x/2 + C1*x + ... + C6*x + * where the remez error is + * + * | 2 4 6 8 10 12 14 | -58 + * |cos(x)-(1-.5*x +C1*x +C2*x +C3*x +C4*x +C5*x +C6*x )| <= 2 + * | | + * + * 4 6 8 10 12 14 + * 4. let r = C1*x +C2*x +C3*x +C4*x +C5*x +C6*x , then + * cos(x) = 1 - x*x/2 + r + * since cos(x+y) ~ cos(x) - sin(x)*y + * ~ cos(x) - x*y, + * a correction term is necessary in cos(x) and hence + * cos(x+y) = 1 - (x*x/2 - (r - x*y)) + * For better accuracy when x > 0.3, let qx = |x|/4 with + * the last 32 bits mask off, and if x > 0.78125, let qx = 0.28125. + * Then + * cos(x+y) = (1-qx) - ((x*x/2-qx) - (r-x*y)). + * Note that 1-qx and (x*x/2-qx) is EXACT here, and the + * magnitude of the latter is at least a quarter of x*x/2, + * thus, reducing the rounding error in the subtraction. + */ + +#include "fdlibm.h" + +#ifdef __STDC__ +static const double +#else +static double +#endif + one = 1.00000000000000000000e+00, /* 0x3FF00000, 0x00000000 */ + C1 = 4.16666666666666019037e-02, /* 0x3FA55555, 0x5555554C */ + C2 = -1.38888888888741095749e-03, /* 0xBF56C16C, 0x16C15177 */ + C3 = 2.48015872894767294178e-05, /* 0x3EFA01A0, 0x19CB1590 */ + C4 = -2.75573143513906633035e-07, /* 0xBE927E4F, 0x809C52AD */ + C5 = 2.08757232129817482790e-09, /* 0x3E21EE9E, 0xBDB4B1C4 */ + C6 = -1.13596475577881948265e-11; /* 0xBDA8FAE9, 0xBE8838D4 */ + +#ifdef __STDC__ +double __kernel_cos(double x, double y) +#else +double __kernel_cos(x, y) +double x, y; +#endif +{ + double a, hz, z, r, qx; + int ix; + ix = __HI(x) & 0x7fffffff; /* ix = |x|'s high word*/ + if (ix < 0x3e400000) { /* if x < 2**27 */ + if (((int)x) == 0) + return one; /* generate inexact */ + } + z = x * x; + r = z * (C1 + z * (C2 + z * (C3 + z * (C4 + z * (C5 + z * C6))))); + if (ix < 0x3FD33333) /* if |x| < 0.3 */ + return one - (0.5 * z - (z * r - x * y)); + else { + if (ix > 0x3fe90000) { /* x > 0.78125 */ + qx = 0.28125; + } else { + __HI(qx) = ix - 0x00200000; /* x/4 */ + __LO(qx) = 0; + } + hz = 0.5 * z - qx; + a = one - qx; + return a - (hz - (z * r - x * y)); + } +} diff --git a/src/MSL_C.PPCEABI.bare.H/k_rem_pio2.c b/src/MSL_C.PPCEABI.bare.H/k_rem_pio2.c new file mode 100644 index 0000000..ffde5d7 --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/k_rem_pio2.c @@ -0,0 +1,349 @@ +/* @(#)k_rem_pio2.c 1.2 95/01/04 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* + * __kernel_rem_pio2(x,y,e0,nx,prec,ipio2) + * double x[],y[]; int e0,nx,prec; int ipio2[]; + * + * __kernel_rem_pio2 return the last three digits of N with + * y = x - N*pi/2 + * so that |y| < pi/2. + * + * The method is to compute the integer (mod 8) and fraction parts of + * (2/pi)*x without doing the full multiplication. In general we + * skip the part of the product that are known to be a huge integer ( + * more accurately, = 0 mod 8 ). Thus the number of operations are + * independent of the exponent of the input. + * + * (2/pi) is represented by an array of 24-bit integers in ipio2[]. + * + * Input parameters: + * x[] The input value (must be positive) is broken into nx + * pieces of 24-bit integers in double precision format. + * x[i] will be the i-th 24 bit of x. The scaled exponent + * of x[0] is given in input parameter e0 (i.e., x[0]*2^e0 + * match x's up to 24 bits. + * + * Example of breaking a double positive z into x[0]+x[1]+x[2]: + * e0 = ilogb(z)-23 + * z = scalbn(z,-e0) + * for i = 0,1,2 + * x[i] = floor(z) + * z = (z-x[i])*2**24 + * + * + * y[] ouput result in an array of double precision numbers. + * The dimension of y[] is: + * 24-bit precision 1 + * 53-bit precision 2 + * 64-bit precision 2 + * 113-bit precision 3 + * The actual value is the sum of them. Thus for 113-bit + * precison, one may have to do something like: + * + * long double t,w,r_head, r_tail; + * t = (long double)y[2] + (long double)y[1]; + * w = (long double)y[0]; + * r_head = t+w; + * r_tail = w - (r_head - t); + * + * e0 The exponent of x[0] + * + * nx dimension of x[] + * + * prec an integer indicating the precision: + * 0 24 bits (single) + * 1 53 bits (double) + * 2 64 bits (extended) + * 3 113 bits (quad) + * + * ipio2[] + * integer array, contains the (24*i)-th to (24*i+23)-th + * bit of 2/pi after binary point. The corresponding + * floating value is + * + * ipio2[i] * 2^(-24(i+1)). + * + * External function: + * double scalbn(), floor(); + * + * + * Here is the description of some local variables: + * + * jk jk+1 is the initial number of terms of ipio2[] needed + * in the computation. The recommended value is 2,3,4, + * 6 for single, double, extended,and quad. + * + * jz local integer variable indicating the number of + * terms of ipio2[] used. + * + * jx nx - 1 + * + * jv index for pointing to the suitable ipio2[] for the + * computation. In general, we want + * ( 2^e0*x[0] * ipio2[jv-1]*2^(-24jv) )/8 + * is an integer. Thus + * e0-3-24*jv >= 0 or (e0-3)/24 >= jv + * Hence jv = max(0,(e0-3)/24). + * + * jp jp+1 is the number of terms in PIo2[] needed, jp = jk. + * + * q[] double array with integral value, representing the + * 24-bits chunk of the product of x and 2/pi. + * + * q0 the corresponding exponent of q[0]. Note that the + * exponent for q[i] would be q0-24*i. + * + * PIo2[] double precision array, obtained by cutting pi/2 + * into 24 bits chunks. + * + * f[] ipio2[] in floating point + * + * iq[] integer array by breaking up q[] in 24-bits chunk. + * + * fq[] final product of x*(2/pi) in fq[0],..,fq[jk] + * + * ih integer. If >0 it indicates q[] is >= 0.5, hence + * it also indicates the *sign* of the result. + * + */ + +/* + * Constants: + * The hexadecimal values are the intended ones for the following + * constants. The decimal values may be used, provided that the + * compiler will convert from decimal to binary accurately enough + * to produce the hexadecimal values shown. + */ + +#include "fdlibm.h" + +#ifdef __STDC__ +static const _INT32 init_jk[] = {2, 3, 4, 6}; /* initial value for jk */ +#else +static _INT32 init_jk[] = {2, 3, 4, 6}; +#endif + +#ifdef __STDC__ +static const double PIo2[] = { +#else +static double PIo2[] = { +#endif + 1.57079625129699707031e+00, /* 0x3FF921FB, 0x40000000 */ + 7.54978941586159635335e-08, /* 0x3E74442D, 0x00000000 */ + 5.39030252995776476554e-15, /* 0x3CF84698, 0x80000000 */ + 3.28200341580791294123e-22, /* 0x3B78CC51, 0x60000000 */ + 1.27065575308067607349e-29, /* 0x39F01B83, 0x80000000 */ + 1.22933308981111328932e-36, /* 0x387A2520, 0x40000000 */ + 2.73370053816464559624e-44, /* 0x36E38222, 0x80000000 */ + 2.16741683877804819444e-51, /* 0x3569F31D, 0x00000000 */ +}; + +#ifdef __STDC__ +static const double +#else +static double +#endif + zero = 0.0, + one = 1.0, two24 = 1.67772160000000000000e+07, /* 0x41700000, 0x00000000 */ + twon24 = 5.96046447753906250000e-08; /* 0x3E700000, 0x00000000 */ + +#ifdef __STDC__ +_INT32 __kernel_rem_pio2(double* x, double* y, _INT32 e0, _INT32 nx, _INT32 prec, + const _INT32* ipio2) +#else +_INT32 __kernel_rem_pio2(x, y, e0, nx, prec, ipio2) +double x[], y[]; +_INT32 e0, nx, prec; +_INT32 ipio2[]; +#endif +{ + _INT32 jz, jx, jv, jp, jk, carry, n, iq[20], i, j, k, m, q0, ih; + double z, fw, f[20], fq[20], q[20]; + + /* initialize jk*/ + jk = init_jk[prec]; + jp = jk; + + /* determine jx,jv,q0, note that 3>q0 */ + jx = nx - 1; + jv = (e0 - 3) / 24; + if (jv < 0) + jv = 0; + q0 = e0 - 24 * (jv + 1); + + /* set up f[0] to f[jx+jk] where f[jx+jk] = ipio2[jv+jk] */ + j = jv - jx; + m = jx + jk; + for (i = 0; i <= m; i++, j++) + f[i] = (j < 0) ? zero : (double)ipio2[j]; + + /* compute q[0],q[1],...q[jk] */ + for (i = 0; i <= jk; i++) { + for (j = 0, fw = 0.0; j <= jx; j++) + fw += x[j] * f[jx + i - j]; + q[i] = fw; + } + + jz = jk; +recompute: + /* distill q[] into iq[] reversingly */ + for (i = 0, j = jz, z = q[jz]; j > 0; i++, j--) { + fw = (double)((_INT32)(twon24 * z)); + iq[i] = (_INT32)(z - two24 * fw); + z = q[j - 1] + fw; + } + + /* compute n */ + z = scalbn(z, q0); /* actual value of z */ + z -= 8.0 * floor(z * 0.125); /* trim off integer >= 8 */ + n = (_INT32)z; + z -= (double)n; + ih = 0; + if (q0 > 0) { /* need iq[jz-1] to determine n */ + i = (iq[jz - 1] >> (24 - q0)); + n += i; + iq[jz - 1] -= i << (24 - q0); + ih = iq[jz - 1] >> (23 - q0); + } else if (q0 == 0) + ih = iq[jz - 1] >> 23; + else if (z >= 0.5) + ih = 2; + + if (ih > 0) { /* q > 0.5 */ + n += 1; + carry = 0; + for (i = 0; i < jz; i++) { /* compute 1-q */ + j = iq[i]; + if (carry == 0) { + if (j != 0) { + carry = 1; + iq[i] = 0x1000000 - j; + } + } else + iq[i] = 0xffffff - j; + } + if (q0 > 0) { /* rare case: chance is 1 in 12 */ + switch (q0) { + case 1: + iq[jz - 1] &= 0x7fffff; + break; + case 2: + iq[jz - 1] &= 0x3fffff; + break; + } + } + if (ih == 2) { + z = one - z; + if (carry != 0) + z -= scalbn(one, q0); + } + } + + /* check if recomputation is needed */ + if (z == zero) { + j = 0; + for (i = jz - 1; i >= jk; i--) + j |= iq[i]; + if (j == 0) { /* need recomputation */ + for (k = 1; iq[jk - k] == 0; k++) + ; /* k = no. of terms needed */ + + for (i = jz + 1; i <= jz + k; i++) { /* add q[jz+1] to q[jz+k] */ + f[jx + i] = (double)ipio2[jv + i]; + for (j = 0, fw = 0.0; j <= jx; j++) + fw += x[j] * f[jx + i - j]; + q[i] = fw; + } + jz += k; + goto recompute; + } + } + + /* chop off zero terms */ + if (z == 0.0) { + jz -= 1; + q0 -= 24; + while (iq[jz] == 0) { + jz--; + q0 -= 24; + } + } else { /* break z into 24-bit if necessary */ + z = scalbn(z, -q0); + if (z >= two24) { + fw = (double)((_INT32)(twon24 * z)); + iq[jz] = (_INT32)(z - two24 * fw); + jz += 1; + q0 += 24; + iq[jz] = (_INT32)fw; + } else + iq[jz] = (_INT32)z; + } + + /* convert integer "bit" chunk to floating-point value */ + fw = scalbn(one, q0); + for (i = jz; i >= 0; i--) { + q[i] = fw * (double)iq[i]; + fw *= twon24; + } + + /* compute PIo2[0,...,jp]*q[jz,...,0] */ + for (i = jz; i >= 0; i--) { + for (fw = 0.0, k = 0; k <= jp && k <= jz - i; k++) + fw += PIo2[k] * q[i + k]; + fq[jz - i] = fw; + } + + /* compress fq[] into y[] */ + switch (prec) { + case 0: + fw = 0.0; + for (i = jz; i >= 0; i--) + fw += fq[i]; + y[0] = (ih == 0) ? fw : -fw; + break; + case 1: + case 2: + fw = 0.0; + for (i = jz; i >= 0; i--) + fw += fq[i]; + y[0] = (ih == 0) ? fw : -fw; + fw = fq[0] - fw; + for (i = 1; i <= jz; i++) + fw += fq[i]; + y[1] = (ih == 0) ? fw : -fw; + break; + case 3: /* painful */ + for (i = jz; i > 0; i--) { + fw = fq[i - 1] + fq[i]; + fq[i] += fq[i - 1] - fw; + fq[i - 1] = fw; + } + for (i = jz; i > 1; i--) { + fw = fq[i - 1] + fq[i]; + fq[i] += fq[i - 1] - fw; + fq[i - 1] = fw; + } + for (fw = 0.0, i = jz; i >= 2; i--) + fw += fq[i]; + if (ih == 0) { + y[0] = fq[0]; + y[1] = fq[1]; + y[2] = fw; + } else { + y[0] = -fq[0]; + y[1] = -fq[1]; + y[2] = -fw; + } + } + return n & 7; +} diff --git a/src/MSL_C.PPCEABI.bare.H/k_sin.c b/src/MSL_C.PPCEABI.bare.H/k_sin.c new file mode 100644 index 0000000..6c4ded3 --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/k_sin.c @@ -0,0 +1,79 @@ +/* @(#)k_sin.c 1.2 95/01/04 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* __kernel_sin( x, y, iy) + * kernel sin function on [-pi/4, pi/4], pi/4 ~ 0.7854 + * Input x is assumed to be bounded by ~pi/4 in magnitude. + * Input y is the tail of x. + * Input iy indicates whether y is 0. (if iy=0, y assume to be 0). + * + * Algorithm + * 1. Since sin(-x) = -sin(x), we need only to consider positive x. + * 2. if x < 2^-27 (hx<0x3e400000 0), return x with inexact if x!=0. + * 3. sin(x) is approximated by a polynomial of degree 13 on + * [0,pi/4] + * 3 13 + * sin(x) ~ x + S1*x + ... + S6*x + * where + * + * |sin(x) 2 4 6 8 10 12 | -58 + * |----- - (1+S1*x +S2*x +S3*x +S4*x +S5*x +S6*x )| <= 2 + * | x | + * + * 4. sin(x+y) = sin(x) + sin'(x')*y + * ~ sin(x) + (1-x*x/2)*y + * For better accuracy, let + * 3 2 2 2 2 + * r = x *(S2+x *(S3+x *(S4+x *(S5+x *S6)))) + * then 3 2 + * sin(x) = x + (S1*x + (x *(r-y/2)+y)) + */ + +#include "fdlibm.h" + +#ifdef __STDC__ +static const double +#else +static double +#endif + half = 5.00000000000000000000e-01, /* 0x3FE00000, 0x00000000 */ + S1 = -1.66666666666666324348e-01, /* 0xBFC55555, 0x55555549 */ + S2 = 8.33333333332248946124e-03, /* 0x3F811111, 0x1110F8A6 */ + S3 = -1.98412698298579493134e-04, /* 0xBF2A01A0, 0x19C161D5 */ + S4 = 2.75573137070700676789e-06, /* 0x3EC71DE3, 0x57B1FE7D */ + S5 = -2.50507602534068634195e-08, /* 0xBE5AE5E6, 0x8A2B9CEB */ + S6 = 1.58969099521155010221e-10; /* 0x3DE5D93A, 0x5ACFD57C */ + +#ifdef __STDC__ +double __kernel_sin(double x, double y, int iy) +#else +double __kernel_sin(x, y, iy) +double x, y; +int iy; /* iy=0 if y is zero */ +#endif +{ + double z, r, v; + int ix; + ix = __HI(x) & 0x7fffffff; /* high word of x */ + if (ix < 0x3e400000) /* |x| < 2**-27 */ + { + if ((int)x == 0) + return x; + } /* generate inexact */ + z = x * x; + v = z * x; + r = S2 + z * (S3 + z * (S4 + z * (S5 + z * S6))); + if (iy == 0) + return x + v * (S1 + z * r); + else + return x - ((z * (half * y - v * r) - y) - v * S1); +} diff --git a/src/MSL_C.PPCEABI.bare.H/k_tan.c b/src/MSL_C.PPCEABI.bare.H/k_tan.c new file mode 100644 index 0000000..0c50c8e --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/k_tan.c @@ -0,0 +1,134 @@ +/* @(#)k_tan.c 1.2 95/01/04 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* __kernel_tan( x, y, k ) + * kernel tan function on [-pi/4, pi/4], pi/4 ~ 0.7854 + * Input x is assumed to be bounded by ~pi/4 in magnitude. + * Input y is the tail of x. + * Input k indicates whether tan (if k=1) or + * -1/tan (if k= -1) is returned. + * + * Algorithm + * 1. Since tan(-x) = -tan(x), we need only to consider positive x. + * 2. if x < 2^-28 (hx<0x3e300000 0), return x with inexact if x!=0. + * 3. tan(x) is approximated by a odd polynomial of degree 27 on + * [0,0.67434] + * 3 27 + * tan(x) ~ x + T1*x + ... + T13*x + * where + * + * |tan(x) 2 4 26 | -59.2 + * |----- - (1+T1*x +T2*x +.... +T13*x )| <= 2 + * | x | + * + * Note: tan(x+y) = tan(x) + tan'(x)*y + * ~ tan(x) + (1+x*x)*y + * Therefore, for better accuracy in computing tan(x+y), let + * 3 2 2 2 2 + * r = x *(T2+x *(T3+x *(...+x *(T12+x *T13)))) + * then + * 3 2 + * tan(x+y) = x + (T1*x + (x *(r+y)+y)) + * + * 4. For x in [0.67434,pi/4], let y = pi/4 - x, then + * tan(x) = tan(pi/4-y) = (1-tan(y))/(1+tan(y)) + * = 1 - 2*(tan(y) - (tan(y)^2)/(1+tan(y))) + */ + +#include "fdlibm.h" + +#ifdef __STDC__ +static const double +#else +static double +#endif + one = 1.00000000000000000000e+00, /* 0x3FF00000, 0x00000000 */ + pio4 = 7.85398163397448278999e-01, /* 0x3FE921FB, 0x54442D18 */ + pio4lo = 3.06161699786838301793e-17, /* 0x3C81A626, 0x33145C07 */ + T[] = { + 3.33333333333334091986e-01, /* 0x3FD55555, 0x55555563 */ + 1.33333333333201242699e-01, /* 0x3FC11111, 0x1110FE7A */ + 5.39682539762260521377e-02, /* 0x3FABA1BA, 0x1BB341FE */ + 2.18694882948595424599e-02, /* 0x3F9664F4, 0x8406D637 */ + 8.86323982359930005737e-03, /* 0x3F8226E3, 0xE96E8493 */ + 3.59207910759131235356e-03, /* 0x3F6D6D22, 0xC9560328 */ + 1.45620945432529025516e-03, /* 0x3F57DBC8, 0xFEE08315 */ + 5.88041240820264096874e-04, /* 0x3F4344D8, 0xF2F26501 */ + 2.46463134818469906812e-04, /* 0x3F3026F7, 0x1A8D1068 */ + 7.81794442939557092300e-05, /* 0x3F147E88, 0xA03792A6 */ + 7.14072491382608190305e-05, /* 0x3F12B80F, 0x32F0A7E9 */ + -1.85586374855275456654e-05, /* 0xBEF375CB, 0xDB605373 */ + 2.59073051863633712884e-05, /* 0x3EFB2A70, 0x74BF7AD4 */ +}; + +#ifdef __STDC__ +double __kernel_tan(double x, double y, _INT32 iy) +#else +double __kernel_tan(x, y, iy) +double x, y; +_INT32 iy; +#endif +{ + double z, r, v, w, s; + _INT32 ix, hx; + hx = __HI(x); /* high word of x */ + ix = hx & 0x7fffffff; /* high word of |x| */ + if (ix < 0x3e300000) /* x < 2**-28 */ + { + if ((_INT32)x == 0) { /* generate inexact */ + if (((ix | __LO(x)) | (iy + 1)) == 0) + return one / fabs(x); + else + return (iy == 1) ? x : -one / x; + } + } + if (ix >= 0x3FE59428) { /* |x|>=0.6744 */ + if (hx < 0) { + x = -x; + y = -y; + } + z = pio4 - x; + w = pio4lo - y; + x = z + w; + y = 0.0; + } + z = x * x; + w = z * z; + /* Break x^5*(T[1]+x^2*T[2]+...) into + * x^5(T[1]+x^4*T[3]+...+x^20*T[11]) + + * x^5(x^2*(T[2]+x^4*T[4]+...+x^22*[T12])) + */ + r = T[1] + w * (T[3] + w * (T[5] + w * (T[7] + w * (T[9] + w * T[11])))); + v = z * (T[2] + w * (T[4] + w * (T[6] + w * (T[8] + w * (T[10] + w * T[12]))))); + s = z * x; + r = y + z * (s * (r + v) + y); + r += T[0] * s; + w = x + r; + if (ix >= 0x3FE59428) { + v = (double)iy; + return (double)(1 - ((hx >> 30) & 2)) * (v - 2.0 * (x - (w * w / (w + v) - r))); + } + if (iy == 1) + return w; + else { /* if allow error up to 2 ulp, + simply return -1.0/(x+r) here */ + /* compute -1.0/(x+r) accurately */ + double a, t; + z = w; + __LO(z) = 0; + v = r - (z - x); /* z+v = r+x */ + t = a = -1.0 / w; /* a = -1.0/w */ + __LO(t) = 0; + s = 1.0 + t * z; + return t + a * (s + t * v); + } +} diff --git a/src/MSL_C.PPCEABI.bare.H/locale.c b/src/MSL_C.PPCEABI.bare.H/locale.c new file mode 100644 index 0000000..e265db0 --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/locale.c @@ -0,0 +1,33 @@ +#include <limits.h> +#include <locale.h> + +struct lconv __lconv = { + ".", // decimal_point + "", // thousands_sep + "", // grouping + "", // mon_decimal_point + "", // mon_thousands_sep + "", // mon_grouping + "", // positive_sign + "", // negative_sign + "", // currency_symbol + CHAR_MAX, // frac_digits + CHAR_MAX, // p_cs_precedes + CHAR_MAX, // n_cs_precedes + CHAR_MAX, // p_sep_by_space + CHAR_MAX, // n_sep_by_space + CHAR_MAX, // p_sign_posn + CHAR_MAX, // n_sign_posn + "", // int_curr_symbol + CHAR_MAX, // int_frac_digits + CHAR_MAX, // int_p_cs_precedes + CHAR_MAX, // int_n_cs_precedes + CHAR_MAX, // int_p_sep_by_space + CHAR_MAX, // int_n_sep_by_space + CHAR_MAX, // int_p_sign_posn + CHAR_MAX, // int_n_sign_posn +}; + +// Just here to generate the extra string, +// the real usage is inside setlocale, which is stripped +static char* locale_name = "C"; diff --git a/src/MSL_C.PPCEABI.bare.H/math_ppc.c b/src/MSL_C.PPCEABI.bare.H/math_ppc.c new file mode 100644 index 0000000..5304c61 --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/math_ppc.c @@ -0,0 +1,2 @@ +#define _MATH_INLINE +#include <math.h> diff --git a/src/MSL_C.PPCEABI.bare.H/mbstring.c b/src/MSL_C.PPCEABI.bare.H/mbstring.c new file mode 100644 index 0000000..9e95ff1 --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/mbstring.c @@ -0,0 +1,115 @@ +#include "errno.h" +#include "stdio.h" +#include "string.h" + +#pragma ANSI_strict off + +#ifndef __WINT_TYPE__ +#define __WINT_TYPE__ unsigned int +#endif + +typedef struct { + int __count; + union { + __WINT_TYPE__ __wch; + char __wchb[4]; + } __value; /* Value so far. */ +} mbstate_t; + +static int is_utf8_complete(const char* s, size_t n); +static int is_utf8_complete(const char* s, size_t n) { + if (n <= 0) /* 0 or fewer characters do not form a valid multibyte character */ + return (-1); + + if (*s == 0x00) + return (0); + + if ((*s & 0x80) == 0x00) + return (1); + else if ((*s & 0xe0) == 0xc0) /* need 2 bytes */ + if (n >= 2) + if (((*(s + 1) & 0x80) == 0x80)) + return (2); + else + return (-1); + else + return (-2); + + else if ((*s & 0xf0) == 0xe0) + if (n >= 3) + if (((*(s + 1) & 0x80) == 0x80) && ((*(s + 2) & 0x80) == 0x80)) + return (3); + else + return (-1); + else if (((n == 2) && ((*(s + 1) & 0x80) == 0x80)) || (n == 1)) + return (-2); + else + return (-1); + else + return (-1); +} + +#pragma dont_inline on +static int unicode_to_UTF8(char* s, wchar_t wchar) { + int number_of_bytes; + wchar_t wide_char; + char* target_ptr; + char first_byte_mark[4] = {0x00, 0x00, 0xc0, 0xe0}; + + if (!s) { + return 0; + } + + wide_char = wchar; + if (wide_char < 0x0080) + number_of_bytes = 1; + else if (wide_char < 0x0800) + number_of_bytes = 2; + else + number_of_bytes = 3; + + target_ptr = s + number_of_bytes; + + switch (number_of_bytes) { + case 3: + *--target_ptr = (wide_char & 0x003f) | 0x80; + wide_char >>= 6; + case 2: + *--target_ptr = (wide_char & 0x003f) | 0x80; + wide_char >>= 6; + case 1: + *--target_ptr = wide_char | first_byte_mark[number_of_bytes]; + } + + return (number_of_bytes); +} +#pragma dont_inline reset + +int wctomb(char* s, wchar_t wchar) { return (unicode_to_UTF8(s, wchar)); } + +size_t wcstombs(char* s, const wchar_t* pwcs, size_t n) { + int chars_written = 0; + int result; + char temp[3]; + wchar_t* source; + + if (!s || !pwcs) + return (0); + + source = (wchar_t*)pwcs; + while (chars_written <= n) { + if (!*source) { + *(s + chars_written) = '\0'; + break; + } else { + result = wctomb(temp, *source++); + if ((chars_written + result) <= n) { + strncpy(s + chars_written, temp, result); + chars_written += result; + } else + break; + } + } + + return (chars_written); +} diff --git a/src/MSL_C.PPCEABI.bare.H/mem.c b/src/MSL_C.PPCEABI.bare.H/mem.c new file mode 100644 index 0000000..f2ed7b7 --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/mem.c @@ -0,0 +1,70 @@ +#include <string.h> + +#include "mem_funcs.h" + +void* memmove(void* dst, const void* src, size_t n) { + const char* p; + char* q; + int rev = ((unsigned long)src < (unsigned long)dst); + + if (n >= __min_bytes_for_long_copy) { + if ((((int)dst ^ (int)src)) & 3) + if (!rev) + __copy_longs_unaligned(dst, src, n); + else + __copy_longs_rev_unaligned(dst, src, n); + else if (!rev) + __copy_longs_aligned(dst, src, n); + else + __copy_longs_rev_aligned(dst, src, n); + + return dst; + } + + if (!rev) { + + for (p = (const char*)src - 1, q = (char*)dst - 1, n++; --n;) + *++q = *++p; + + } else { + for (p = (const char*)src + n, q = (char*)dst + n, n++; --n;) + *--q = *--p; + } + + return dst; +} + +void* memchr(const void* src, int val, size_t n) { + const unsigned char* p; + + unsigned long v = (val & 0xff); + + for (p = (unsigned char*)src - 1, n++; --n;) + if ((*++p & 0xff) == v) + return (void*)p; + + return NULL; +} + +void* __memrchr(const void* src, int val, size_t n) { + const unsigned char* p; + + unsigned long v = (val & 0xff); + + for (p = (unsigned char*)src + n, n++; --n;) + if (*--p == v) + return (void*)p; + + return NULL; +} + +int memcmp(const void* src1, const void* src2, size_t n) { + const unsigned char* p1; + const unsigned char* p2; + + for (p1 = (const unsigned char*)src1 - 1, p2 = (const unsigned char*)src2 - 1, n++; --n;) + if (*++p1 != *++p2) + return ((*p1 < *p2) ? -1 : +1); + + return 0; +} diff --git a/src/MSL_C.PPCEABI.bare.H/mem_funcs.c b/src/MSL_C.PPCEABI.bare.H/mem_funcs.c new file mode 100644 index 0000000..c1ce8ea --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/mem_funcs.c @@ -0,0 +1,235 @@ +#include "mem_funcs.h" + +#pragma ANSI_strict off + +#define cps ((unsigned char*)src) +#define cpd ((unsigned char*)dst) +#define lps ((unsigned long*)src) +#define lpd ((unsigned long*)dst) +#define deref_auto_inc(p) *++(p) + +void __copy_longs_aligned(void* dst, const void* src, unsigned long n) { + unsigned long i; + + i = (-(unsigned long)dst) & 3; + + cps = ((unsigned char*)src) - 1; + cpd = ((unsigned char*)dst) - 1; + + if (i) { + n -= i; + + do + deref_auto_inc(cpd) = deref_auto_inc(cps); + while (--i); + } + + lps = ((unsigned long*)(cps + 1)) - 1; + lpd = ((unsigned long*)(cpd + 1)) - 1; + + i = n >> 5; + + if (i) + do { + deref_auto_inc(lpd) = deref_auto_inc(lps); + deref_auto_inc(lpd) = deref_auto_inc(lps); + deref_auto_inc(lpd) = deref_auto_inc(lps); + deref_auto_inc(lpd) = deref_auto_inc(lps); + deref_auto_inc(lpd) = deref_auto_inc(lps); + deref_auto_inc(lpd) = deref_auto_inc(lps); + deref_auto_inc(lpd) = deref_auto_inc(lps); + deref_auto_inc(lpd) = deref_auto_inc(lps); + } while (--i); + + i = (n & 31) >> 2; + + if (i) + do + deref_auto_inc(lpd) = deref_auto_inc(lps); + while (--i); + + cps = ((unsigned char*)(lps + 1)) - 1; + cpd = ((unsigned char*)(lpd + 1)) - 1; + +#ifdef PRIME1 + n &= 3ULL; +#else + n &= 3; +#endif + + if (n) + do + deref_auto_inc(cpd) = deref_auto_inc(cps); + while (--n); + + return; +} + +void __copy_longs_rev_aligned(void* dst, const void* src, unsigned long n) { + unsigned long i; + + cps = ((unsigned char*)src) + n; + cpd = ((unsigned char*)dst) + n; + + i = ((unsigned long)cpd) & 3; + + if (i) { + n -= i; + + do + *--cpd = *--cps; + while (--i); + } + + i = n >> 5; + + if (i) + do { + *--lpd = *--lps; + *--lpd = *--lps; + *--lpd = *--lps; + *--lpd = *--lps; + *--lpd = *--lps; + *--lpd = *--lps; + *--lpd = *--lps; + *--lpd = *--lps; + } while (--i); + + i = (n & 31) >> 2; + + if (i) + do + *--lpd = *--lps; + while (--i); + +#ifdef PRIME1 + n &= 3ULL; +#else + n &= 3; +#endif + + if (n) + do + *--cpd = *--cps; + while (--n); + + return; +} + +void __copy_longs_unaligned(void* dst, const void* src, unsigned long n) { + unsigned long i, v1, v2; + unsigned int src_offset, left_shift, right_shift; + + i = (-(unsigned long)dst) & 3; + + cps = ((unsigned char*)src) - 1; + cpd = ((unsigned char*)dst) - 1; + + if (i) { + n -= i; + + do + deref_auto_inc(cpd) = deref_auto_inc(cps); + while (--i); + } + + src_offset = ((unsigned int)(cps + 1)) & 3; + + left_shift = src_offset << 3; + right_shift = 32 - left_shift; + + cps -= src_offset; + + lps = ((unsigned long*)(cps + 1)) - 1; + lpd = ((unsigned long*)(cpd + 1)) - 1; + + i = n >> 3; + + v1 = deref_auto_inc(lps); + + do { + v2 = deref_auto_inc(lps); + deref_auto_inc(lpd) = (v1 << left_shift) | (v2 >> right_shift); + v1 = deref_auto_inc(lps); + deref_auto_inc(lpd) = (v2 << left_shift) | (v1 >> right_shift); + } while (--i); + + if (n & 4) { + v2 = deref_auto_inc(lps); + deref_auto_inc(lpd) = (v1 << left_shift) | (v2 >> right_shift); + } + + cps = ((unsigned char*)(lps + 1)) - 1; + cpd = ((unsigned char*)(lpd + 1)) - 1; + +#ifdef PRIME1 + n &= 3ULL; +#else + n &= 3; +#endif + + if (n) { + cps -= 4 - src_offset; + do + deref_auto_inc(cpd) = deref_auto_inc(cps); + while (--n); + } + + return; +} + +void __copy_longs_rev_unaligned(void* dst, const void* src, unsigned long n) { + unsigned long i, v1, v2; + unsigned int src_offset, left_shift, right_shift; + + cps = ((unsigned char*)src) + n; + cpd = ((unsigned char*)dst) + n; + + i = ((unsigned long)cpd) & 3; + + if (i) { + n -= i; + + do + *--cpd = *--cps; + while (--i); + } + + src_offset = ((unsigned int)cps) & 3; + + left_shift = src_offset << 3; + right_shift = 32 - left_shift; + + cps += 4 - src_offset; + + i = n >> 3; + + v1 = *--lps; + + do { + v2 = *--lps; + *--lpd = (v2 << left_shift) | (v1 >> right_shift); + v1 = *--lps; + *--lpd = (v1 << left_shift) | (v2 >> right_shift); + } while (--i); + + if (n & 4) { + v2 = *--lps; + *--lpd = (v2 << left_shift) | (v1 >> right_shift); + } + +#ifdef PRIME1 + n &= 3ULL; +#else + n &= 3; +#endif + + if (n) { + cps += src_offset; + do + *--cpd = *--cps; + while (--n); + } + + return; +} diff --git a/src/MSL_C.PPCEABI.bare.H/misc_io.c b/src/MSL_C.PPCEABI.bare.H/misc_io.c new file mode 100644 index 0000000..6b4060a --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/misc_io.c @@ -0,0 +1,4 @@ +extern void (*__stdio_exit)(void); +void __close_all(void); + +void __stdio_atexit(void) { __stdio_exit = __close_all; } diff --git a/src/MSL_C.PPCEABI.bare.H/qsort.c b/src/MSL_C.PPCEABI.bare.H/qsort.c new file mode 100644 index 0000000..98e8624 --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/qsort.c @@ -0,0 +1,76 @@ +#include <stdlib.h> + +#define table_ptr(i) (((char*)table_base) + (member_size * ((i)-1))) + +#define swap(dst, src, cnt) \ + do { \ + char* p; \ + char* q; \ + size_t n = cnt; \ + \ + unsigned long tmp; \ + \ + for (p = (char*)src - 1, q = (char*)dst - 1, n++; --n;) { \ + tmp = *++q; \ + *q = *++p; \ + *p = tmp; \ + } \ + } while (0) + +void qsort(void* table_base, size_t num_members, size_t member_size, + _compare_function compare_members) { + size_t l, r, j; + char* lp; + char* rp; + char* ip; + char* jp; + char* kp; + + if (num_members < 2) + return; + + r = num_members; + l = (r / 2) + 1; + + lp = table_ptr(l); + rp = table_ptr(r); + + for (;;) { + if (l > 1) { + l--; + lp -= member_size; + } else { + swap(lp, rp, member_size); + + if (--r == 1) + return; + + rp -= member_size; + } + + j = l; + + jp = table_ptr(j); + + while (j * 2 <= r) { + j *= 2; + + ip = jp; + jp = table_ptr(j); + + if (j < r) { + kp = jp + member_size; + + if (compare_members(jp, kp) < 0) { + j++; + jp = kp; + } + } + + if (compare_members(ip, jp) < 0) + swap(ip, jp, member_size); + else + break; + } + } +} diff --git a/src/MSL_C.PPCEABI.bare.H/rand.c b/src/MSL_C.PPCEABI.bare.H/rand.c new file mode 100644 index 0000000..9d02257 --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/rand.c @@ -0,0 +1,10 @@ +#include <stdlib.h> + +static unsigned long int next = 1; + +int rand(void) { + next = next * 1103515245 + 12345; + return (next >> 16) & 0x7FFF; +} + +void srand(unsigned int seed) { next = seed; } diff --git a/src/MSL_C.PPCEABI.bare.H/s_atan.c b/src/MSL_C.PPCEABI.bare.H/s_atan.c new file mode 100644 index 0000000..31976b8 --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/s_atan.c @@ -0,0 +1,142 @@ +/* @(#)s_atan.c 1.2 95/01/04 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + * + */ + +/* atan(x) + * Method + * 1. Reduce x to positive by atan(x) = -atan(-x). + * 2. According to the integer k=4t+0.25 chopped, t=x, the argument + * is further reduced to one of the following intervals and the + * arctangent of t is evaluated by the corresponding formula: + * + * [0,7/16] atan(x) = t-t^3*(a1+t^2*(a2+...(a10+t^2*a11)...) + * [7/16,11/16] atan(x) = atan(1/2) + atan( (t-0.5)/(1+t/2) ) + * [11/16.19/16] atan(x) = atan( 1 ) + atan( (t-1)/(1+t) ) + * [19/16,39/16] atan(x) = atan(3/2) + atan( (t-1.5)/(1+1.5t) ) + * [39/16,INF] atan(x) = atan(INF) + atan( -1/t ) + * + * Constants: + * The hexadecimal values are the intended ones for the following + * constants. The decimal values may be used, provided that the + * compiler will convert from decimal to binary accurately enough + * to produce the hexadecimal values shown. + */ + +#include "fdlibm.h" + +#ifdef __STDC__ +static const double atanhi[] = { +#else +static double atanhi[] = { +#endif + 4.63647609000806093515e-01, /* atan(0.5)hi 0x3FDDAC67, 0x0561BB4F */ + 7.85398163397448278999e-01, /* atan(1.0)hi 0x3FE921FB, 0x54442D18 */ + 9.82793723247329054082e-01, /* atan(1.5)hi 0x3FEF730B, 0xD281F69B */ + 1.57079632679489655800e+00, /* atan(inf)hi 0x3FF921FB, 0x54442D18 */ +}; + +#ifdef __STDC__ +static const double atanlo[] = { +#else +static double atanlo[] = { +#endif + 2.26987774529616870924e-17, /* atan(0.5)lo 0x3C7A2B7F, 0x222F65E2 */ + 3.06161699786838301793e-17, /* atan(1.0)lo 0x3C81A626, 0x33145C07 */ + 1.39033110312309984516e-17, /* atan(1.5)lo 0x3C700788, 0x7AF0CBBD */ + 6.12323399573676603587e-17, /* atan(inf)lo 0x3C91A626, 0x33145C07 */ +}; + +#ifdef __STDC__ +static const double aT[] = { +#else +static double aT[] = { +#endif + 3.33333333333329318027e-01, /* 0x3FD55555, 0x5555550D */ + -1.99999999998764832476e-01, /* 0xBFC99999, 0x9998EBC4 */ + 1.42857142725034663711e-01, /* 0x3FC24924, 0x920083FF */ + -1.11111104054623557880e-01, /* 0xBFBC71C6, 0xFE231671 */ + 9.09088713343650656196e-02, /* 0x3FB745CD, 0xC54C206E */ + -7.69187620504482999495e-02, /* 0xBFB3B0F2, 0xAF749A6D */ + 6.66107313738753120669e-02, /* 0x3FB10D66, 0xA0D03D51 */ + -5.83357013379057348645e-02, /* 0xBFADDE2D, 0x52DEFD9A */ + 4.97687799461593236017e-02, /* 0x3FA97B4B, 0x24760DEB */ + -3.65315727442169155270e-02, /* 0xBFA2B444, 0x2C6A6C2F */ + 1.62858201153657823623e-02, /* 0x3F90AD3A, 0xE322DA11 */ +}; + +#ifdef __STDC__ +static const double +#else +static double +#endif + one = 1.0, + big = 1.0e300; + +#ifdef __STDC__ +double atan(double x) +#else +double atan(x) +double x; +#endif +{ + double w, s1, s2, z; + _INT32 ix, hx, id; + + hx = __HI(x); + ix = hx & 0x7fffffff; + if (ix >= 0x44100000) { /* if |x| >= 2^66 */ + if (ix > 0x7ff00000 || (ix == 0x7ff00000 && (__LO(x) != 0))) + return x + x; /* NaN */ + if (hx > 0) + return atanhi[3] + atanlo[3]; + else + return -atanhi[3] - atanlo[3]; + } + if (ix < 0x3fdc0000) { /* |x| < 0.4375 */ + if (ix < 0x3e200000) { /* |x| < 2^-29 */ + if (big + x > one) + return x; /* raise inexact */ + } + id = -1; + } else { + x = fabs(x); + if (ix < 0x3ff30000) { /* |x| < 1.1875 */ + if (ix < 0x3fe60000) { /* 7/16 <=|x|<11/16 */ + id = 0; + x = (2.0 * x - one) / (2.0 + x); + } else { /* 11/16<=|x|< 19/16 */ + id = 1; + x = (x - one) / (x + one); + } + } else { + if (ix < 0x40038000) { /* |x| < 2.4375 */ + id = 2; + x = (x - 1.5) / (one + 1.5 * x); + } else { /* 2.4375 <= |x| < 2^66 */ + id = 3; + x = -1.0 / x; + } + } + } + /* end of argument reduction */ + z = x * x; + w = z * z; + /* break sum from i=0 to 10 aT[i]z**(i+1) into odd and even poly */ + s1 = z * (aT[0] + w * (aT[2] + w * (aT[4] + w * (aT[6] + w * (aT[8] + w * aT[10]))))); + s2 = w * (aT[1] + w * (aT[3] + w * (aT[5] + w * (aT[7] + w * aT[9])))); + if (id < 0) + return x - x * (s1 + s2); + else { + z = atanhi[id] - ((x * (s1 + s2) - atanlo[id]) - x); + return (hx < 0) ? -z : z; + } +} diff --git a/src/MSL_C.PPCEABI.bare.H/s_copysign.c b/src/MSL_C.PPCEABI.bare.H/s_copysign.c new file mode 100644 index 0000000..38b88a3 --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/s_copysign.c @@ -0,0 +1,30 @@ +/* @(#)s_copysign.c 1.2 95/01/04 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* + * copysign(double x, double y) + * copysign(x,y) returns a value with the magnitude of x and + * with the sign bit of y. + */ + +#include "fdlibm.h" + +#ifdef __STDC__ +double copysign(double x, double y) +#else +double __copysign(x, y) +double x, y; +#endif +{ + __HI(x) = (__HI(x) & 0x7fffffff) | (__HI(y) & 0x80000000); + return x; +} diff --git a/src/MSL_C.PPCEABI.bare.H/s_cos.c b/src/MSL_C.PPCEABI.bare.H/s_cos.c new file mode 100644 index 0000000..833d871 --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/s_cos.c @@ -0,0 +1,75 @@ +/* @(#)s_cos.c 1.3 95/01/18 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunSoft, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ +/* cos(x) + * Return cosine function of x. + * + * kernel function: + * __kernel_sin ... sine function on [-pi/4,pi/4] + * __kernel_cos ... cosine function on [-pi/4,pi/4] + * __ieee754_rem_pio2 ... argument reduction routine + * + * Method. + * Let S,C and T denote the sin, cos and tan respectively on + * [-PI/4, +PI/4]. Reduce the argument x to y1+y2 = x-k*pi/2 + * in [-pi/4 , +pi/4], and let n = k mod 4. + * We have + * + * n sin(x) cos(x) tan(x) + * ---------------------------------------------------------- + * 0 S C T + * 1 C -S -1/T + * 2 -S -C T + * 3 -C S -1/T + * ---------------------------------------------------------- + * + * Special cases: + * Let trig be any of sin, cos, or tan. + * trig(+-INF) is NaN, with signals; + * trig(NaN) is that NaN; + * + * Accuracy: + * TRIG(x) returns trig(x) nearly rounded + */ +#include "fdlibm.h" +#ifdef __STDC__ +double cos(double x) +#else +double cos(x) +double x; +#endif +{ + double y[2], z = 0.0; + int n, ix; + /* High word of x. */ + ix = __HI(x); + /* |x| ~< pi/4 */ + ix &= 0x7fffffff; + if (ix <= 0x3fe921fb) + return __kernel_cos(x, z); + /* cos(Inf or NaN) is NaN */ + else if (ix >= 0x7ff00000) + return x - x; + /* argument reduction needed */ + else { + n = __ieee754_rem_pio2(x, y); + switch (n & 3) { + case 0: + return __kernel_cos(y[0], y[1]); + case 1: + return -__kernel_sin(y[0], y[1], 1); + case 2: + return -__kernel_cos(y[0], y[1]); + default: + return __kernel_sin(y[0], y[1], 1); + } + } +} diff --git a/src/MSL_C.PPCEABI.bare.H/s_floor.c b/src/MSL_C.PPCEABI.bare.H/s_floor.c new file mode 100644 index 0000000..bac24bc --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/s_floor.c @@ -0,0 +1,87 @@ +/* @(#)s_floor.c 1.3 95/01/18 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunSoft, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ +/* + * floor(x) + * Return x rounded toward -inf to integral value + * Method: + * Bit twiddling. + * Exception: + * Inexact flag raised if x not equal to floor(x). + */ +#include "fdlibm.h" + +#ifdef __STDC__ +static const double huge = 1.0e300; +#else +static double huge = 1.0e300; +#endif + +#ifdef __STDC__ +double floor(double x) +#else +double floor(x) +double x; +#endif +{ + int i0, i1, j0; + unsigned i, j; + i0 = __HI(x); + i1 = __LO(x); + j0 = ((i0 >> 20) & 0x7ff) - 0x3ff; + if (j0 < 20) { + if (j0 < 0) { /* raise inexact if x != 0 */ + if (huge + x > 0.0) { /* return 0*sign(x) if |x|<1 */ + if (i0 >= 0) { + i0 = i1 = 0; + } else if (((i0 & 0x7fffffff) | i1) != 0) { + i0 = 0xbff00000; + i1 = 0; + } + } + } else { + i = (0x000fffff) >> j0; + if (((i0 & i) | i1) == 0) + return x; /* x is integral */ + if (huge + x > 0.0) { /* raise inexact flag */ + if (i0 < 0) + i0 += (0x00100000) >> j0; + i0 &= (~i); + i1 = 0; + } + } + } else if (j0 > 51) { + if (j0 == 0x400) + return x + x; /* inf or NaN */ + else + return x; /* x is integral */ + } else { + i = ((unsigned)(0xffffffff)) >> (j0 - 20); + if ((i1 & i) == 0) + return x; /* x is integral */ + if (huge + x > 0.0) { /* raise inexact flag */ + if (i0 < 0) { + if (j0 == 20) + i0 += 1; + else { + j = i1 + (1 << (52 - j0)); + if (j < i1) + i0 += 1; /* got a carry */ + i1 = j; + } + } + i1 &= (~i); + } + } + __HI(x) = i0; + __LO(x) = i1; + return x; +} diff --git a/src/MSL_C.PPCEABI.bare.H/s_frexp.c b/src/MSL_C.PPCEABI.bare.H/s_frexp.c new file mode 100644 index 0000000..dcc1a26 --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/s_frexp.c @@ -0,0 +1,57 @@ +/* @(#)s_frexp.c 1.3 95/01/04 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* + * for non-zero x + * x = frexp(arg,&exp); + * return a double fp quantity x such that 0.5 <= |x| <1.0 + * and the corresponding binary exponent "exp". That is + * arg = x*2^exp. + * If arg is inf, 0.0, or NaN, then frexp(arg,&exp) returns arg + * with *exp=0. + */ + +#include "fdlibm.h" + +#ifdef __STDC__ +static const double +#else +static double +#endif + two54 = 1.80143985094819840000e+16; /* 0x43500000, 0x00000000 */ + +#ifdef __STDC__ +double frexp(double x, int* eptr) +#else +double frexp(x, eptr) +double x; +int* eptr; +#endif +{ + int hx, ix, lx; + hx = __HI(x); + ix = 0x7fffffff & hx; + lx = __LO(x); + *eptr = 0; + if (ix >= 0x7ff00000 || ((ix | lx) == 0)) + return x; /* 0,inf,nan */ + if (ix < 0x00100000) { /* subnormal */ + x *= two54; + hx = __HI(x); + ix = hx & 0x7fffffff; + *eptr = -54; + } + *eptr += (ix >> 20) - 1022; + hx = (hx & 0x800fffff) | 0x3fe00000; + __HI(x) = hx; + return x; +} diff --git a/src/MSL_C.PPCEABI.bare.H/s_ldexp.c b/src/MSL_C.PPCEABI.bare.H/s_ldexp.c new file mode 100644 index 0000000..aeeda31 --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/s_ldexp.c @@ -0,0 +1,54 @@ +/* @(#)s_ldexp.c 1.2 95/01/04 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +#include "fdlibm.h" + +static const double two54 = 1.80143985094819840000e+16, /* 0x43500000, 0x00000000 */ + twom54 = 5.55111512312578270212e-17, /* 0x3C900000, 0x00000000 */ + big = 1.0e+300, tiny = 1.0e-300; + +double ldexp(double x, int n) { + _INT32 k, hx, lx; + if (!isfinite(x) || x == 0.0) + return x; + + hx = __HI(x); + lx = __LO(x); + k = (hx & 0x7ff00000) >> 20; /* extract exponent */ + if (k == 0) { /* 0 or subnormal x */ + if ((lx | (hx & 0x7fffffff)) == 0) + return x; /* +-0 */ + x *= two54; + hx = __HI(x); + k = ((hx & 0x7ff00000) >> 20) - 54; + if (n < -50000) + return tiny * x; /*underflow*/ + } + if (k == 0x7ff) + return x + x; /* NaN or Inf */ + k = k + n; + if (k > 0x7fe) + return big * copysign(big, x); /* overflow */ + if (k > 0) /* normal result */ + { + __HI(x) = (hx & 0x800fffff) | (k << 20); + return x; + } + if (k <= -54) + if (n > 50000) /* in case integer overflow in n+k */ + return big * copysign(big, x); /*overflow*/ + else + return tiny * copysign(tiny, x); /*underflow*/ + k += 54; /* subnormal result */ + __HI(x) = (hx & 0x800fffff) | (k << 20); + return x * twom54; +} diff --git a/src/MSL_C.PPCEABI.bare.H/s_modf.c b/src/MSL_C.PPCEABI.bare.H/s_modf.c new file mode 100644 index 0000000..9352e72 --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/s_modf.c @@ -0,0 +1,79 @@ +/* @(#)s_modf.c 1.2 95/01/04 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* + * modf(double x, double *iptr) + * return fraction part of x, and return x's integral part in *iptr. + * Method: + * Bit twiddling. + * + * Exception: + * No exception. + */ + +#include "fdlibm.h" + +#ifdef __STDC__ +static const double one = 1.0; +#else +static double one = 1.0; +#endif + +#ifdef __STDC__ +double modf(double x, double* iptr) +#else +double modf(x, iptr) +double x, *iptr; +#endif +{ + _INT32 i0, i1, j0; + _UINT32 i; + i0 = __HI(x); /* high x */ + i1 = __LO(x); /* low x */ + j0 = ((i0 >> 20) & 0x7ff) - 0x3ff; /* exponent of x */ + if (j0 < 20) { /* integer part in high x */ + if (j0 < 0) { /* |x|<1 */ + __HIp(iptr) = i0 & 0x80000000; + __LOp(iptr) = 0; /* *iptr = +-0 */ + return x; + } else { + i = (0x000fffff) >> j0; + if (((i0 & i) | i1) == 0) { /* x is integral */ + *iptr = x; + __HI(x) &= 0x80000000; + __LO(x) = 0; /* return +-0 */ + return x; + } else { + __HIp(iptr) = i0 & (~i); + __LOp(iptr) = 0; + return x - *iptr; + } + } + } else if (j0 > 51) { /* no fraction part */ + *iptr = x * one; + __HI(x) &= 0x80000000; + __LO(x) = 0; /* return +-0 */ + return x; + } else { /* fraction part in low x */ + i = ((_UINT32)(0xffffffff)) >> (j0 - 20); + if ((i1 & i) == 0) { /* x is integral */ + *iptr = x; + __HI(x) &= 0x80000000; + __LO(x) = 0; /* return +-0 */ + return x; + } else { + __HIp(iptr) = i0; + __LOp(iptr) = i1 & (~i); + return x - *iptr; + } + } +} diff --git a/src/MSL_C.PPCEABI.bare.H/s_nextafter.c b/src/MSL_C.PPCEABI.bare.H/s_nextafter.c new file mode 100644 index 0000000..44ce353 --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/s_nextafter.c @@ -0,0 +1,88 @@ +/* @(#)s_nextafter.c 1.2 95/01/04 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* IEEE functions + * nextafter(x,y) + * return the next machine floating-point number of x in the + * direction toward y. + * Special cases: + */ + +#include "fdlibm.h" + +#ifdef __STDC__ +double nextafter(double x, double y) +#else +double nextafter(x, y) +double x, y; +#endif +{ + _INT32 hx, hy, ix, iy; + _UINT32 lx, ly; + + hx = __HI(x); /* high word of x */ + lx = __LO(x); /* low word of x */ + hy = __HI(y); /* high word of y */ + ly = __LO(y); /* low word of y */ + ix = hx & 0x7fffffff; /* |x| */ + iy = hy & 0x7fffffff; /* |y| */ + + if (((ix >= 0x7ff00000) && ((ix - 0x7ff00000) | lx) != 0) || /* x is nan */ + ((iy >= 0x7ff00000) && ((iy - 0x7ff00000) | ly) != 0)) /* y is nan */ + return x + y; + if (x == y) + return x; /* x=y, return x */ + if ((ix | lx) == 0) { /* x == 0 */ + __HI(x) = hy & 0x80000000; /* return +-minsubnormal */ + __LO(x) = 1; + y = x * x; + if (y == x) + return y; + else + return x; /* raise underflow flag */ + } + if (hx >= 0) { /* x > 0 */ + if (hx > hy || ((hx == hy) && (lx > ly))) { /* x > y, x -= ulp */ + if (lx == 0) + hx -= 1; + lx -= 1; + } else { /* x < y, x += ulp */ + lx += 1; + if (lx == 0) + hx += 1; + } + } else { /* x < 0 */ + if (hy >= 0 || hx > hy || ((hx == hy) && (lx > ly))) { /* x < y, x -= ulp */ + if (lx == 0) + hx -= 1; + lx -= 1; + } else { /* x > y, x += ulp */ + lx += 1; + if (lx == 0) + hx += 1; + } + } + hy = hx & 0x7ff00000; + if (hy >= 0x7ff00000) + return x + x; /* overflow */ + if (hy < 0x00100000) { /* underflow */ + y = x * x; + if (y != x) { /* raise underflow flag */ + __HI(y) = hx; + __LO(y) = lx; + return y; + } + } + __HI(x) = hx; + __LO(x) = lx; + return x; +} diff --git a/src/MSL_C.PPCEABI.bare.H/s_sin.c b/src/MSL_C.PPCEABI.bare.H/s_sin.c new file mode 100644 index 0000000..ebb4dee --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/s_sin.c @@ -0,0 +1,84 @@ +/* @(#)s_sin.c 1.2 95/01/04 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* sin(x) + * Return sine function of x. + * + * kernel function: + * __kernel_sin ... sine function on [-pi/4,pi/4] + * __kernel_cos ... cose function on [-pi/4,pi/4] + * __ieee754_rem_pio2 ... argument reduction routine + * + * Method. + * Let S,C and T denote the sin, cos and tan respectively on + * [-PI/4, +PI/4]. Reduce the argument x to y1+y2 = x-k*pi/2 + * in [-pi/4 , +pi/4], and let n = k mod 4. + * We have + * + * n sin(x) cos(x) tan(x) + * ---------------------------------------------------------- + * 0 S C T + * 1 C -S -1/T + * 2 -S -C T + * 3 -C S -1/T + * ---------------------------------------------------------- + * + * Special cases: + * Let trig be any of sin, cos, or tan. + * trig(+-INF) is NaN, with signals; + * trig(NaN) is that NaN; + * + * Accuracy: + * TRIG(x) returns trig(x) nearly rounded + */ + +#include "fdlibm.h" + +#ifdef __STDC__ +double sin(double x) +#else +double sin(x) +double x; +#endif +{ + double y[2], z = 0.0; + int n, ix; + + /* High word of x. */ + ix = __HI(x); + + /* |x| ~< pi/4 */ + ix &= 0x7fffffff; + if (ix <= 0x3fe921fb) + return __kernel_sin(x, z, 0); + + /* sin(Inf or NaN) is NaN */ + else if (ix >= 0x7ff00000) + return x - x; + + /* argument reduction needed */ + else { + + n = __ieee754_rem_pio2(x, y); + + switch (n & 3) { + case 0: + return __kernel_sin(y[0], y[1], 1); + case 1: + return __kernel_cos(y[0], y[1]); + case 2: + return -__kernel_sin(y[0], y[1], 1); + default: + return -__kernel_cos(y[0], y[1]); + } + } +} diff --git a/src/MSL_C.PPCEABI.bare.H/s_tan.c b/src/MSL_C.PPCEABI.bare.H/s_tan.c new file mode 100644 index 0000000..6edb666 --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/s_tan.c @@ -0,0 +1,73 @@ +/* @(#)s_tan.c 1.2 95/01/04 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* tan(x) + * Return tangent function of x. + * + * kernel function: + * __kernel_tan ... tangent function on [-pi/4,pi/4] + * __ieee754_rem_pio2 ... argument reduction routine + * + * Method. + * Let S,C and T denote the sin, cos and tan respectively on + * [-PI/4, +PI/4]. Reduce the argument x to y1+y2 = x-k*pi/2 + * in [-pi/4 , +pi/4], and let n = k mod 4. + * We have + * + * n sin(x) cos(x) tan(x) + * ---------------------------------------------------------- + * 0 S C T + * 1 C -S -1/T + * 2 -S -C T + * 3 -C S -1/T + * ---------------------------------------------------------- + * + * Special cases: + * Let trig be any of sin, cos, or tan. + * trig(+-INF) is NaN, with signals; + * trig(NaN) is that NaN; + * + * Accuracy: + * TRIG(x) returns trig(x) nearly rounded + */ + +#include "fdlibm.h" + +#ifdef __STDC__ +double tan(double x) +#else +double tan(x) +double x; +#endif +{ + double y[2], z = 0.0; + _INT32 n, ix; + + /* High word of x. */ + ix = __HI(x); + + /* |x| ~< pi/4 */ + ix &= 0x7fffffff; + if (ix <= 0x3fe921fb) + return __kernel_tan(x, z, 1); + + /* tan(Inf or NaN) is NaN */ + else if (ix >= 0x7ff00000) + return x - x; /* NaN */ + + /* argument reduction needed */ + else { + n = __ieee754_rem_pio2(x, y); + return __kernel_tan(y[0], y[1], 1 - ((n & 1) << 1)); /* 1 -- n even + -1 -- n odd */ + } +} diff --git a/src/MSL_C.PPCEABI.bare.H/sscanf.c b/src/MSL_C.PPCEABI.bare.H/sscanf.c new file mode 100644 index 0000000..171ee58 --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/sscanf.c @@ -0,0 +1,26 @@ +#include "stdio.h" + +int __StringRead(void* isc, int ch, int Action) { + char ret; + __InStrCtrl* iscp = (__InStrCtrl*)isc; + switch (Action) { + case __GetChar: + ret = *(iscp->NextChar); + if (ret == '\0') { + iscp->NullCharDetected = 1; + return (EOF); + } else { + iscp->NextChar++; + return ((unsigned char)ret); + } + case __UngetChar: + if (!iscp->NullCharDetected) + iscp->NextChar--; + else + iscp->NullCharDetected = 0; + return (ch); + case __CheckForError: + return (iscp->NullCharDetected); + } + return 0; +} diff --git a/src/MSL_C.PPCEABI.bare.H/string.c b/src/MSL_C.PPCEABI.bare.H/string.c new file mode 100644 index 0000000..82ca568 --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/string.c @@ -0,0 +1,201 @@ +#include "string.h" + +size_t strlen(const char* str) { + size_t len = -1; + unsigned char* p = (unsigned char*)str - 1; + do { + len++; + } while (*++p); + return len; +} + +char*(strcpy)(char* dst, const char* src) { + unsigned char *destb, *fromb; + unsigned int w, t, align; + unsigned int k1; + unsigned int k2; + + fromb = (unsigned char*)src; + destb = (unsigned char*)dst; + + if ((align = ((int)fromb & 3)) != ((int)destb & 3)) { + goto bytecopy; + } + + if (align) { + if ((*destb = *fromb) == 0) { + return dst; + } + + for (align = 3 - align; align; align--) { + if ((*(++destb) = *(++fromb)) == 0) { + return dst; + } + } + ++destb; + ++fromb; + } + + k1 = 0x80808080; + k2 = 0xfefefeff; + + w = *((int*)(fromb)); + t = w + k2; + t &= k1; + if (t) { + goto bytecopy; + } + + --((int*)(destb)); + + do { + *(++((int*)(destb))) = w; + w = *(++((int*)(fromb))); + + t = w + k2; + t &= k1; + if (t) + goto adjust; + } while (1); + +adjust: + ++((int*)(destb)); + +bytecopy: + if ((*destb = *fromb) == 0) + return (dst); + do { + if ((*(++destb) = *(++fromb)) == 0) + return dst; + } while (1); + + return dst; +} + +char* strncpy(char* dst, const char* src, size_t n) { + const unsigned char* p = (const unsigned char*)src - 1; + unsigned char* q = (unsigned char*)dst - 1; + unsigned char zero = 0; + + n++; + + while (--n) + if (!(*++q = *++p)) { + while (--n) + *++q = 0; + break; + } + + return dst; +} + +int strcmp(const char* str1, const char* str2) { + unsigned char* left = (unsigned char*)str1; + unsigned char* right = (unsigned char*)str2; + unsigned int k1, k2, align, l1, r1, x; + + l1 = *left; + r1 = *right; + if (l1 - r1) { + return l1 - r1; + } + + if ((align = ((int)left & 3)) != ((int)right & 3)) { + goto bytecopy; + } + if (align) { + if (l1 == 0) { + return 0; + } + for (align = 3 - align; align; align--) { + l1 = *(++left); + r1 = *(++right); + if (l1 - r1) { + return l1 - r1; + } + if (l1 == 0) { + return 0; + } + } + left++; + right++; + } + + k1 = 0x80808080; + k2 = 0xfefefeff; + + l1 = *(int*)left; + r1 = *(int*)right; + x = l1 + k2; + if (x & k1) { + goto adjust; + } + while (l1 == r1) { + l1 = *(++((int*)(left))); + r1 = *(++((int*)(right))); + x = l1 + k2; + if (x & k1) { + goto adjust; + } + } + + if (l1 > r1) { + return 1; + } + + return -1; + +adjust: + l1 = *left; + r1 = *right; + if (l1 - r1) { + return l1 - r1; + } + +bytecopy: + if (l1 == 0) { + return 0; + } + + do { + l1 = *(++left); + r1 = *(++right); + if (l1 - r1) { + return l1 - r1; + } + if (l1 == 0) { + return 0; + } + } while (1); +} + +int strncmp(const char* str1, const char* str2, size_t n) { + const unsigned char* p1 = (unsigned char*)str1 - 1; + const unsigned char* p2 = (unsigned char*)str2 - 1; + unsigned long c1, c2; + + n++; + + while (--n) { + if ((c1 = *++p1) != (c2 = *++p2)) { + return (c1 - c2); + } else if (!c1) { + break; + } + } + + return 0; +} + +char* strchr(const char* str, int chr) { + const unsigned char* p = (unsigned char*)str - 1; + unsigned long c = (chr & 0xff); + unsigned long ch; + + while (ch = *++p) { + if (ch == c) + return ((char*)p); + } + + return (c ? 0 : (char*)p); +} diff --git a/src/MSL_C.PPCEABI.bare.H/uart_console_io.c b/src/MSL_C.PPCEABI.bare.H/uart_console_io.c new file mode 100644 index 0000000..1aff7dc --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/uart_console_io.c @@ -0,0 +1,34 @@ +#include "console_io.h" + +int __TRK_write_console(__file_handle handle, unsigned char* buffer, size_t* count, + __idle_proc idle_proc); + +static inline int __init_uart_console(void) { + int err = 0; + static int initialized = 0; + + if (initialized == 0) { + err = InitializeUART(57600); + + if (err == 0) + initialized = 1; + } + + return (err); +} +int __write_console(__file_handle handle, unsigned char* buffer, size_t* count, + __idle_proc idle_proc) { + if (__init_uart_console() != 0) { + return 1; + } + + if (WriteUARTN(buffer, *count) != 0) { + *count = 0; + return 1; + } + + __TRK_write_console(handle, buffer, count, idle_proc); + return 0; +} + +int __close_console() { return 0; } diff --git a/src/MSL_C.PPCEABI.bare.H/w_acos.c b/src/MSL_C.PPCEABI.bare.H/w_acos.c new file mode 100644 index 0000000..1d9a9ce --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/w_acos.c @@ -0,0 +1,39 @@ + +/* @(#)w_acos.c 1.2 95/01/04 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* + * wrap_acos(x) + */ + +#include "fdlibm.h" + +#ifdef __STDC__ +double acos(double x) /* wrapper acos */ +#else +double acos(x) /* wrapper acos */ +double x; +#endif +{ +#ifdef _IEEE_LIBM + return __ieee754_acos(x); +#else + double z; + z = __ieee754_acos(x); + if (_LIB_VERSION == _IEEE_ || isnan(x)) + return z; + if (fabs(x) > 1.0) { + return __kernel_standard(x, x, 1); /* acos(|x|>1) */ + } else + return z; +#endif +} diff --git a/src/MSL_C.PPCEABI.bare.H/w_asin.c b/src/MSL_C.PPCEABI.bare.H/w_asin.c new file mode 100644 index 0000000..5519bc7 --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/w_asin.c @@ -0,0 +1,40 @@ + +/* @(#)w_asin.c 1.2 95/01/04 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + * + */ + +/* + * wrapper asin(x) + */ + +#include "fdlibm.h" + +#ifdef __STDC__ +double asin(double x) /* wrapper asin */ +#else +double asin(x) /* wrapper asin */ +double x; +#endif +{ +#ifdef _IEEE_LIBM + return __ieee754_asin(x); +#else + double z; + z = __ieee754_asin(x); + if (_LIB_VERSION == _IEEE_ || isnan(x)) + return z; + if (fabs(x) > 1.0) { + return __kernel_standard(x, x, 2); /* asin(|x|>1) */ + } else + return z; +#endif +} diff --git a/src/MSL_C.PPCEABI.bare.H/w_atan2.c b/src/MSL_C.PPCEABI.bare.H/w_atan2.c new file mode 100644 index 0000000..890f130 --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/w_atan2.c @@ -0,0 +1,40 @@ + +/* @(#)w_atan2.c 1.2 95/01/04 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + * + */ + +/* + * wrapper atan2(y,x) + */ + +#include "fdlibm.h" + +#ifdef __STDC__ +double atan2(double y, double x) /* wrapper atan2 */ +#else +double atan2(y, x) /* wrapper atan2 */ +double y, x; +#endif +{ +#ifdef _IEEE_LIBM + return __ieee754_atan2(y, x); +#else + double z; + z = __ieee754_atan2(y, x); + if (_LIB_VERSION == _IEEE_ || isnan(x) || isnan(y)) + return z; + if (x == 0.0 && y == 0.0) { + return __kernel_standard(y, x, 3); /* atan2(+-0,+-0) */ + } else + return z; +#endif +} diff --git a/src/MSL_C.PPCEABI.bare.H/w_exp.c b/src/MSL_C.PPCEABI.bare.H/w_exp.c new file mode 100644 index 0000000..c8ed38b --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/w_exp.c @@ -0,0 +1,49 @@ +/* @(#)w_exp.c 1.2 95/01/04 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* + * wrapper exp(x) + */ + +#include "fdlibm.h" + +#ifdef __STDC__ +static const double +#else +static double +#endif + o_threshold = 7.09782712893383973096e+02, /* 0x40862E42, 0xFEFA39EF */ + u_threshold = -7.45133219101941108420e+02; /* 0xc0874910, 0xD52D3051 */ + +#ifdef __STDC__ +double exp(double x) /* wrapper pow */ +#else +double exp(x) /* wrapper exp */ +double x; +#endif +{ +#ifdef _IEEE_LIBM + return __ieee754_exp(x); +#else + double z; + z = __ieee754_exp(x); + if (_LIB_VERSION == _IEEE_) + return z; + if (isfinite(x)) { + if (x > o_threshold) + return __kernel_standard(x, x, 6); /* exp overflow */ + else if (x < u_threshold) + return __kernel_standard(x, x, 7); /* exp underflow */ + } + return z; +#endif +} diff --git a/src/MSL_C.PPCEABI.bare.H/w_fmod.c b/src/MSL_C.PPCEABI.bare.H/w_fmod.c new file mode 100644 index 0000000..6a0f07a --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/w_fmod.c @@ -0,0 +1,38 @@ +/* @(#)w_fmod.c 1.2 95/01/04 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* + * wrapper fmod(x,y) + */ + +#include "fdlibm.h" + +#ifdef __STDC__ +double fmod(double x, double y) /* wrapper fmod */ +#else +double fmod(x, y) /* wrapper fmod */ +double x, y; +#endif +{ +#ifdef _IEEE_LIBM + return __ieee754_fmod(x, y); +#else + double z; + z = __ieee754_fmod(x, y); + if (_LIB_VERSION == _IEEE_ || isnan(y) || isnan(x)) + return z; + if (y == 0.0) { + return __kernel_standard(x, y, 27); /* fmod(x,0) */ + } else + return z; +#endif +} diff --git a/src/MSL_C.PPCEABI.bare.H/w_log.c b/src/MSL_C.PPCEABI.bare.H/w_log.c new file mode 100644 index 0000000..f4baac3 --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/w_log.c @@ -0,0 +1,38 @@ +/* @(#)w_log.c 1.2 95/01/04 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* + * wrapper log(x) + */ + +#include "fdlibm.h" + +#ifdef __STDC__ +double log(double x) /* wrapper pow */ +#else +double log(x) /* wrapper log */ +double x; +#endif +{ +#ifdef _IEEE_LIBM + return __ieee754_log(x); +#else + double z; + z = __ieee754_log(x); + if (_LIB_VERSION == _IEEE_ || isnan(x) || x > 0.0) + return z; + if (x == 0.0) + return __kernel_standard(x, x, 16); /* log(0) */ + else + return __kernel_standard(x, x, 17); /* log(x<0) */ +#endif +} diff --git a/src/MSL_C.PPCEABI.bare.H/w_pow.c b/src/MSL_C.PPCEABI.bare.H/w_pow.c new file mode 100644 index 0000000..0c05ac8 --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/w_pow.c @@ -0,0 +1,58 @@ +/* @(#)w_pow.c 1.2 95/01/04 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* + * wrapper pow(x,y) return x**y + */ + +#include "fdlibm.h" + +#ifdef __STDC__ +double pow(double x, double y) /* wrapper pow */ +#else +double pow(x, y) /* wrapper pow */ +double x, y; +#endif +{ +#ifdef _IEEE_LIBM + return __ieee754_pow(x, y); +#else + double z; + z = __ieee754_pow(x, y); + if (_LIB_VERSION == _IEEE_ || isnan(y)) + return z; + if (isnan(x)) { + if (y == 0.0) + return __kernel_standard(x, y, 42); /* pow(NaN,0.0) */ + else + return z; + } + if (x == 0.0) { + if (y == 0.0) + return __kernel_standard(x, y, 20); /* pow(0.0,0.0) */ + if (isfinite(y) && y < 0.0) + return __kernel_standard(x, y, 23); /* pow(0.0,negative) */ + return z; + } + if (!isfinite(z)) { + if (isfinite(x) && isfinite(y)) { + if (isnan(z)) + return __kernel_standard(x, y, 24); /* pow neg**non-int */ + else + return __kernel_standard(x, y, 21); /* pow overflow */ + } + } + if (z == 0.0 && isfinite(x) && isfinite(y)) + return __kernel_standard(x, y, 22); /* pow underflow */ + return z; +#endif +} diff --git a/src/MSL_C.PPCEABI.bare.H/wchar_io.c b/src/MSL_C.PPCEABI.bare.H/wchar_io.c new file mode 100644 index 0000000..87da4af --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/wchar_io.c @@ -0,0 +1,28 @@ +#include <stdio.h> + +int fwide(FILE* stream, int mode) { + int orientation; + int result; + + if ((stream == NULL) || (stream->mode.file_kind == __closed_file)) + return 0; + orientation = stream->mode.file_orientation; + switch (orientation) { + case __unoriented: + if (mode > 0) + stream->mode.file_orientation = __wide_oriented; + else if (mode < 0) + stream->mode.file_orientation = __char_oriented; + result = mode; + break; + + case __wide_oriented: + result = 1; + break; + + case __char_oriented: + result = -1; + break; + } + return result; +} diff --git a/src/Runtime/NMWException.cpp b/src/Runtime/NMWException.cpp new file mode 100644 index 0000000..1ccbad1 --- /dev/null +++ b/src/Runtime/NMWException.cpp @@ -0,0 +1,49 @@ +#include <NMWException.h> +#pragma exceptions on + +class __partial_array_destructor { +private: + void* p; + size_t size; + size_t n; + void* dtor; + +public: + size_t i; + + __partial_array_destructor(void* array, size_t elementsize, size_t nelements, void* destructor) { + p = array; + size = elementsize; + n = nelements; + dtor = destructor; + i = n; + } + + ~__partial_array_destructor() { + char* ptr; + + if (i < n && dtor) { + for (ptr = (char*)p + size * i; i > 0; i--) { + ptr -= size; + DTORCALL_COMPLETE(dtor, ptr); + } + } + } +}; + +extern "C" void __construct_array(void* ptr, void* ctor, void* dtor, size_t size, size_t n) { + __partial_array_destructor pad(ptr, size, n, dtor); + char* p; + + for (pad.i = 0, p = (char*)ptr; pad.i < n; pad.i++, p += size) + CTORCALL_COMPLETE(ctor, p); +} + +extern "C" void __destroy_arr(void* block, void* dtor, size_t size, size_t n) { + char* p; + + for (p = (char*)block + size * n; n > 0; n--) { + p -= size; + DTORCALL_COMPLETE(dtor, p); + } +} diff --git a/src/Runtime/NMWException.h b/src/Runtime/NMWException.h deleted file mode 100644 index 49b623e..0000000 --- a/src/Runtime/NMWException.h +++ /dev/null @@ -1,16 +0,0 @@ -#ifndef NMWEXCEPTION_H -#define NMWEXCEPTION_H - -typedef void (dtor_func)(void *object, int free_object); -typedef struct destructor_chain dtor_chain; - -struct destructor_chain { - dtor_chain *next; - dtor_func *destructor; - void *object; -}; - -void *__register_global_object(void *object, dtor_func *destructor, dtor_chain *regmem); -void __destroy_global_chain(); - -#endif diff --git a/src/Runtime/__mem.c b/src/Runtime/__mem.c new file mode 100644 index 0000000..a5ef6c1 --- /dev/null +++ b/src/Runtime/__mem.c @@ -0,0 +1,85 @@ +#include "string.h" + +void* memcpy(void* dst, const void* src, size_t n) { + const char* p; + char* q; + int rev = ((unsigned long)src < (unsigned long)dst); + + if (!rev) { + + for (p = (const char*)src - 1, q = (char*)dst - 1, n++; --n;) + *++q = *++p; + + } else { + for (p = (const char*)src + n, q = (char*)dst + n, n++; --n;) + *--q = *--p; + } + return (dst); +} + +#define cps ((unsigned char*)src) +#define cpd ((unsigned char*)dst) +#define lps ((unsigned long*)src) +#define lpd ((unsigned long*)dst) +#define deref_auto_inc(p) *++(p) + +void __fill_mem(void* dst, int val, size_t n) { + unsigned long v = (unsigned char)val; + unsigned long i; + + cpd = ((unsigned char*)dst) - 1; + + if (n >= 32) { + i = (~(unsigned long)dst) & 3; + + if (i) { + n -= i; + + do + deref_auto_inc(cpd) = v; + while (--i); + } + + if (v) + v |= v << 24 | v << 16 | v << 8; + + lpd = ((unsigned long*)(cpd + 1)) - 1; + + i = n >> 5; + + if (i) + do { + deref_auto_inc(lpd) = v; + deref_auto_inc(lpd) = v; + deref_auto_inc(lpd) = v; + deref_auto_inc(lpd) = v; + deref_auto_inc(lpd) = v; + deref_auto_inc(lpd) = v; + deref_auto_inc(lpd) = v; + deref_auto_inc(lpd) = v; + } while (--i); + + i = (n & 31) >> 2; + + if (i) + do + deref_auto_inc(lpd) = v; + while (--i); + + cpd = ((unsigned char*)(lpd + 1)) - 1; + + n &= 3; + } + + if (n) + do + deref_auto_inc(cpd) = v; + while (--n); + + return; +} + +void* memset(void* str, int c, size_t n) { + __fill_mem(str, c, n); + return str; +} diff --git a/src/Runtime/__va_arg.c b/src/Runtime/__va_arg.c new file mode 100644 index 0000000..fd0e182 --- /dev/null +++ b/src/Runtime/__va_arg.c @@ -0,0 +1,57 @@ +typedef struct { + char gpr; + char fpr; + char reserved[2]; + char* input_arg_area; + char* reg_save_area; +} va_list[1]; + +typedef enum { + ARGPOINTER, + WORD, + DOUBLEWORD, + REAL, +} _va_arg_type; + +#define ALIGN(addr, amount) (((unsigned int)(addr) + ((amount)-1)) & ~((amount)-1)) + +void* __va_arg(va_list ap, _va_arg_type type) { + char* addr; + char* curGprPtr = &(ap->gpr); + int curGpr = ap->gpr; + int max = 8; + int size = 4; + int inc = 1; + int even = 0; + int fprOffset = 0; + int regSize = 4; + + if (type == 3) { + curGprPtr = &(ap->fpr); + curGpr = ap->fpr; + size = 8; + fprOffset = 8 * 4; + regSize = 8; + } + if (type == 2) { + size = 8; + max = max - 1; + if (curGpr & 1) + even = 1; + inc = 2; + } + if (curGpr < max) { + curGpr += even; + addr = ap->reg_save_area + fprOffset + (curGpr * regSize); + *curGprPtr = curGpr + inc; + } else { + *curGprPtr = 8; + addr = ap->input_arg_area; + addr = (char*)ALIGN(addr, size); + ap->input_arg_area = addr + size; + } + if (type == ARGPOINTER) + addr = *((char**)addr); + + return addr; +} diff --git a/src/Runtime/abort_exit.c b/src/Runtime/abort_exit.c deleted file mode 100644 index 43b1a0c..0000000 --- a/src/Runtime/abort_exit.c +++ /dev/null @@ -1,17 +0,0 @@ -void __destroy_global_chain(); - -extern void (*_dtors[])(void); - -int __aborting; - - -void exit(int state) { - void (**dtor)(void); - if (!__aborting) { - dtor = _dtors; - while (*dtor != 0) { - (*dtor)(); - dtor++; - } - } -} diff --git a/src/Runtime/global_destructor_chain.c b/src/Runtime/global_destructor_chain.c index 1f3790d..7c24b76 100644 --- a/src/Runtime/global_destructor_chain.c +++ b/src/Runtime/global_destructor_chain.c @@ -1,22 +1,26 @@ #include "NMWException.h" -dtor_chain *__global_destructor_chain; - -extern void *__register_global_object(void *object, dtor_func *destructor, dtor_chain *regmem) { - regmem->next = __global_destructor_chain; - regmem->destructor = destructor; - regmem->object = object; - __global_destructor_chain = regmem; - return object; + + +DestructorChain* __global_destructor_chain; + +extern void* __register_global_object(void* object, void* destructor, void* regmem) { + ((DestructorChain*)regmem)->next = __global_destructor_chain; + ((DestructorChain*)regmem)->destructor = destructor; + ((DestructorChain*)regmem)->object = object; + __global_destructor_chain = (DestructorChain*)regmem; + + return object; } -void __destroy_global_chain() { - dtor_chain *iter = __global_destructor_chain; - while (__global_destructor_chain != 0) { - iter = __global_destructor_chain; - __global_destructor_chain = __global_destructor_chain->next; - iter->destructor(iter->object, -1); - } +void __destroy_global_chain(void) { + DestructorChain* iter; + + while ((iter=__global_destructor_chain) != 0) { + __global_destructor_chain = iter->next; + DTORCALL_COMPLETE(iter->destructor, iter->object); + } } -__declspec(section ".dtors") static void* const __destroy_global_chain_reference = __destroy_global_chain; +__declspec(section + ".dtors") static void* const __destroy_global_chain_reference = __destroy_global_chain; diff --git a/src/Runtime/ptmf.c b/src/Runtime/ptmf.c new file mode 100644 index 0000000..b9e8a90 --- /dev/null +++ b/src/Runtime/ptmf.c @@ -0,0 +1,45 @@ + +typedef struct PTMF { + long this_delta; // delta to this pointer + long vtbl_offset; // offset in vtable (-1: not a virtual function) + union { + void* func_addr; //nonvirtual function address + long ventry_offset; // of virtual function entry in vtable + } func_data; +} PTMF; + +const PTMF __ptmf_null = {0, 0, 0}; + +/* clang-format off */ +asm void __ptmf_test(register PTMF* ptmf) { + nofralloc + + lwz r5, PTMF.this_delta(ptmf) + lwz r6, PTMF.vtbl_offset(ptmf) + lwz r7, PTMF.func_data(ptmf) + li r3, 1 + cmpwi cr0, r5, 0 + cmpwi cr6, r6, 0 + cmpwi cr7, r7, 0 + bnelr cr0 + bnelr cr6 + bnelr cr7 + li r3, 0 + blr +} + +asm void __ptmf_scall(...) { + nofralloc + lwz r0, PTMF.this_delta(r12) + lwz r11, PTMF.vtbl_offset(r12) + lwz r12, PTMF.func_data(r12) + add r3, r3, r0 + cmpwi r11, 0 + blt @1 + lwzx r12, r3, r12 + lwzx r12, r12, r11 +@1 + mtctr r12 + bctr +} +/* clang-format - on*/ diff --git a/src/Runtime/runtime.c b/src/Runtime/runtime.c new file mode 100644 index 0000000..16fd6ed --- /dev/null +++ b/src/Runtime/runtime.c @@ -0,0 +1,842 @@ +/* clang-format off */ +#define SAVE_FPR(reg) _savefpr_ ## reg +#define RESTORE_FPR(reg) _restfpr_ ## reg +#define SAVE_GPR(reg) _savegpr_ ## reg +#define RESTORE_GPR(reg) _restgpr_ ## reg + +#define ENTRY_SAVE_FPR(reg) entry SAVE_FPR(reg) +#define ENTRY_RESTORE_FPR(reg) entry RESTORE_FPR(reg) +#define ENTRY_SAVE_GPR(reg) entry SAVE_GPR(reg) +#define ENTRY_RESTORE_GPR(reg) entry RESTORE_GPR(reg) + +#define SAVE_FPR2(reg) _savef ## reg +#define RESTORE_FPR2(reg) _restf ## reg +#define ENTRY_SAVE_FPR2(reg) +#define ENTRY_RESTORE_FPR2(reg) + + +#ifdef __cplusplus +extern "C" { +#endif + +void SAVE_FPR(14)(void); +void SAVE_FPR(15)(void); +void SAVE_FPR(16)(void); +void SAVE_FPR(17)(void); +void SAVE_FPR(18)(void); +void SAVE_FPR(19)(void); +void SAVE_FPR(20)(void); +void SAVE_FPR(21)(void); +void SAVE_FPR(22)(void); +void SAVE_FPR(23)(void); +void SAVE_FPR(24)(void); +void SAVE_FPR(25)(void); +void SAVE_FPR(26)(void); +void SAVE_FPR(27)(void); +void SAVE_FPR(28)(void); +void SAVE_FPR(29)(void); +void SAVE_FPR(30)(void); +void SAVE_FPR(31)(void); +void SAVE_FPR2(14)(void); +void SAVE_FPR2(15)(void); +void SAVE_FPR2(16)(void); +void SAVE_FPR2(17)(void); +void SAVE_FPR2(18)(void); +void SAVE_FPR2(19)(void); +void SAVE_FPR2(20)(void); +void SAVE_FPR2(21)(void); +void SAVE_FPR2(22)(void); +void SAVE_FPR2(23)(void); +void SAVE_FPR2(24)(void); +void SAVE_FPR2(25)(void); +void SAVE_FPR2(26)(void); +void SAVE_FPR2(27)(void); +void SAVE_FPR2(28)(void); +void SAVE_FPR2(29)(void); +void SAVE_FPR2(30)(void); +void SAVE_FPR2(31)(void); +void RESTORE_FPR(14)(void); +void RESTORE_FPR(15)(void); +void RESTORE_FPR(16)(void); +void RESTORE_FPR(17)(void); +void RESTORE_FPR(18)(void); +void RESTORE_FPR(19)(void); +void RESTORE_FPR(20)(void); +void RESTORE_FPR(21)(void); +void RESTORE_FPR(22)(void); +void RESTORE_FPR(23)(void); +void RESTORE_FPR(24)(void); +void RESTORE_FPR(25)(void); +void RESTORE_FPR(26)(void); +void RESTORE_FPR(27)(void); +void RESTORE_FPR(28)(void); +void RESTORE_FPR(29)(void); +void RESTORE_FPR(30)(void); +void RESTORE_FPR(31)(void); +void RESTORE_FPR2(14)(void); +void RESTORE_FPR2(15)(void); +void RESTORE_FPR2(16)(void); +void RESTORE_FPR2(17)(void); +void RESTORE_FPR2(18)(void); +void RESTORE_FPR2(19)(void); +void RESTORE_FPR2(20)(void); +void RESTORE_FPR2(21)(void); +void RESTORE_FPR2(22)(void); +void RESTORE_FPR2(23)(void); +void RESTORE_FPR2(24)(void); +void RESTORE_FPR2(25)(void); +void RESTORE_FPR2(26)(void); +void RESTORE_FPR2(27)(void); +void RESTORE_FPR2(28)(void); +void RESTORE_FPR2(29)(void); +void RESTORE_FPR2(30)(void); +void RESTORE_FPR2(31)(void); + +void SAVE_GPR(14)(void); +void SAVE_GPR(15)(void); +void SAVE_GPR(16)(void); +void SAVE_GPR(17)(void); +void SAVE_GPR(18)(void); +void SAVE_GPR(19)(void); +void SAVE_GPR(20)(void); +void SAVE_GPR(21)(void); +void SAVE_GPR(22)(void); +void SAVE_GPR(23)(void); +void SAVE_GPR(24)(void); +void SAVE_GPR(25)(void); +void SAVE_GPR(26)(void); +void SAVE_GPR(27)(void); +void SAVE_GPR(28)(void); +void SAVE_GPR(29)(void); +void SAVE_GPR(30)(void); +void SAVE_GPR(31)(void); +void RESTORE_GPR(14)(void); +void RESTORE_GPR(15)(void); +void RESTORE_GPR(16)(void); +void RESTORE_GPR(17)(void); +void RESTORE_GPR(18)(void); +void RESTORE_GPR(19)(void); +void RESTORE_GPR(20)(void); +void RESTORE_GPR(21)(void); +void RESTORE_GPR(22)(void); +void RESTORE_GPR(23)(void); +void RESTORE_GPR(24)(void); +void RESTORE_GPR(25)(void); +void RESTORE_GPR(26)(void); +void RESTORE_GPR(27)(void); +void RESTORE_GPR(28)(void); +void RESTORE_GPR(29)(void); +void RESTORE_GPR(30)(void); +void RESTORE_GPR(31)(void); + +static const unsigned long long __constants[] = { + 0x0000000000000000, // 0.0 + 0x41F0000000000000, // 2**32 + 0x41E0000000000000, // 2**31 +}; + + +asm unsigned long __cvt_fp2unsigned(register double d) { + nofralloc + stwu r1, -0x10(r1) + lis r4, __constants@h + ori r4, r4, __constants@l + li r3, 0 + lfd f0, 0(r4) + lfd f3, 8(r4) + lfd f4, 0x10(r4) + fcmpu cr0, f1, f0 + fcmpu cr6, f1, f3 + blt lbl_803899A8 + addi r3, r3, -1 + bge cr6, lbl_803899A8 + fcmpu cr7, f1, f4 + fmr f2, f1 + blt cr7, lbl_80389994 + fsub f2, f1, f4 +lbl_80389994: + fctiwz f2, f2 + stfd f2, 8(r1) + lwz r3, 0xc(r1) + blt cr7, lbl_803899A8 + addis r3, r3, 0x8000 +lbl_803899A8: + addi r1, r1, 0x10 + blr +} + + +asm void __save_fpr() { + ENTRY_SAVE_FPR(14) + ENTRY_SAVE_FPR2(14) + stfd fp14,-144 (r11) + ENTRY_SAVE_FPR(15) + ENTRY_SAVE_FPR2(15) + stfd fp15,-136 (r11) + ENTRY_SAVE_FPR(16) + ENTRY_SAVE_FPR2(16) + stfd fp16,-128 (r11) + ENTRY_SAVE_FPR(17) + ENTRY_SAVE_FPR2(17) + stfd fp17,-120 (r11) + ENTRY_SAVE_FPR(18) + ENTRY_SAVE_FPR2(18) + stfd fp18,-112 (r11) + ENTRY_SAVE_FPR(19) + ENTRY_SAVE_FPR2(19) + stfd fp19,-104 (r11) + ENTRY_SAVE_FPR(20) + ENTRY_SAVE_FPR2(20) + stfd fp20,-96 (r11) + ENTRY_SAVE_FPR(21) + ENTRY_SAVE_FPR2(21) + stfd fp21,-88 (r11) + ENTRY_SAVE_FPR(22) + ENTRY_SAVE_FPR2(22) + stfd fp22,-80(r11) + ENTRY_SAVE_FPR(23) + ENTRY_SAVE_FPR2(23) + stfd fp23,-72(r11) + ENTRY_SAVE_FPR(24) + ENTRY_SAVE_FPR2(24) + stfd fp24,-64(r11) + ENTRY_SAVE_FPR(25) + ENTRY_SAVE_FPR2(25) + stfd fp25,-56(r11) + ENTRY_SAVE_FPR(26) + ENTRY_SAVE_FPR2(26) + stfd fp26,-48(r11) + ENTRY_SAVE_FPR(27) + ENTRY_SAVE_FPR2(27) + stfd fp27,-40(r11) + ENTRY_SAVE_FPR(28) + ENTRY_SAVE_FPR2(28) + stfd fp28,-32(r11) + ENTRY_SAVE_FPR(29) + ENTRY_SAVE_FPR2(29) + stfd fp29,-24(r11) + ENTRY_SAVE_FPR(30) + ENTRY_SAVE_FPR2(30) + stfd fp30,-16(r11) + ENTRY_SAVE_FPR(31) + ENTRY_SAVE_FPR2(31) + stfd fp31,-8(r11) + blr +} + +asm void __restore_fpr(void) { + nofralloc + ENTRY_RESTORE_FPR(14) + ENTRY_RESTORE_FPR2(14) + lfd fp14,-144(r11) + ENTRY_RESTORE_FPR(15) + ENTRY_RESTORE_FPR2(15) + lfd fp15,-136(r11) + ENTRY_RESTORE_FPR(16) + ENTRY_RESTORE_FPR2(16) + lfd fp16,-128(r11) + ENTRY_RESTORE_FPR(17) + ENTRY_RESTORE_FPR2(17) + lfd fp17,-120(r11) + ENTRY_RESTORE_FPR(18) + ENTRY_RESTORE_FPR2(18) + lfd fp18,-112(r11) + ENTRY_RESTORE_FPR(19) + ENTRY_RESTORE_FPR2(19) + lfd fp19,-104(r11) + ENTRY_RESTORE_FPR(20) + ENTRY_RESTORE_FPR2(20) + lfd fp20,-96(r11) + ENTRY_RESTORE_FPR(21) + ENTRY_RESTORE_FPR2(21) + lfd fp21,-88(r11) + ENTRY_RESTORE_FPR(22) + ENTRY_RESTORE_FPR2(22) + lfd fp22,-80(r11) + ENTRY_RESTORE_FPR(23) + ENTRY_RESTORE_FPR2(23) + lfd fp23,-72(r11) + ENTRY_RESTORE_FPR(24) + ENTRY_RESTORE_FPR2(24) + lfd fp24,-64(r11) + ENTRY_RESTORE_FPR(25) + ENTRY_RESTORE_FPR2(25) + lfd fp25,-56(r11) + ENTRY_RESTORE_FPR(26) + ENTRY_RESTORE_FPR2(26) + lfd fp26,-48(r11) + ENTRY_RESTORE_FPR(27) + ENTRY_RESTORE_FPR2(27) + lfd fp27,-40(r11) + ENTRY_RESTORE_FPR(28) + ENTRY_RESTORE_FPR2(28) + lfd fp28,-32(r11) + ENTRY_RESTORE_FPR(29) + ENTRY_RESTORE_FPR2(29) + lfd fp29,-24(r11) + ENTRY_RESTORE_FPR(30) + ENTRY_RESTORE_FPR2(30) + lfd fp30,-16(r11) + ENTRY_RESTORE_FPR(31) + ENTRY_RESTORE_FPR2(31) + lfd fp31,-8(r11) + blr +} + +asm void __save_gpr(void) { + nofralloc + ENTRY_SAVE_GPR(14) + stw r14,-72(r11) + ENTRY_SAVE_GPR(15) + stw r15,-68(r11) + ENTRY_SAVE_GPR(16) + stw r16,-64(r11) + ENTRY_SAVE_GPR(17) + stw r17,-60(r11) + ENTRY_SAVE_GPR(18) + stw r18,-56(r11) + ENTRY_SAVE_GPR(19) + stw r19,-52(r11) + ENTRY_SAVE_GPR(20) + stw r20,-48(r11) + ENTRY_SAVE_GPR(21) + stw r21,-44(r11) + ENTRY_SAVE_GPR(22) + stw r22,-40(r11) + ENTRY_SAVE_GPR(23) + stw r23,-36(r11) + ENTRY_SAVE_GPR(24) + stw r24,-32(r11) + ENTRY_SAVE_GPR(25) + stw r25,-28(r11) + ENTRY_SAVE_GPR(26) + stw r26,-24(r11) + ENTRY_SAVE_GPR(27) + stw r27,-20(r11) + ENTRY_SAVE_GPR(28) + stw r28,-16(r11) + ENTRY_SAVE_GPR(29) + stw r29,-12(r11) + ENTRY_SAVE_GPR(30) + stw r30,-8(r11) + ENTRY_SAVE_GPR(31) + stw r31,-4(r11) + blr +} + +asm void __restore_gpr(void) { + nofralloc + ENTRY_RESTORE_GPR(14) + lwz r14,-72(r11) + ENTRY_RESTORE_GPR(15) + lwz r15,-68(r11) + ENTRY_RESTORE_GPR(16) + lwz r16,-64(r11) + ENTRY_RESTORE_GPR(17) + lwz r17,-60(r11) + ENTRY_RESTORE_GPR(18) + lwz r18,-56(r11) + ENTRY_RESTORE_GPR(19) + lwz r19,-52(r11) + ENTRY_RESTORE_GPR(20) + lwz r20,-48(r11) + ENTRY_RESTORE_GPR(21) + lwz r21,-44(r11) + ENTRY_RESTORE_GPR(22) + lwz r22,-40(r11) + ENTRY_RESTORE_GPR(23) + lwz r23,-36(r11) + ENTRY_RESTORE_GPR(24) + lwz r24,-32(r11) + ENTRY_RESTORE_GPR(25) + lwz r25,-28(r11) + ENTRY_RESTORE_GPR(26) + lwz r26,-24(r11) + ENTRY_RESTORE_GPR(27) + lwz r27,-20(r11) + ENTRY_RESTORE_GPR(28) + lwz r28,-16(r11) + ENTRY_RESTORE_GPR(29) + lwz r29,-12(r11) + ENTRY_RESTORE_GPR(30) + lwz r30,-8(r11) + ENTRY_RESTORE_GPR(31) + lwz r31,-4(r11) + blr +} + +asm void __div2u(void) { + nofralloc + cmpwi r3, 0 + cntlzw r0, r3 + cntlzw r9, r4 + bne lbl_80389AF4 + addi r0, r9, 0x20 +lbl_80389AF4: + cmpwi r5, 0 + cntlzw r9, r5 + cntlzw r10, r6 + bne lbl_80389B08 + addi r9, r10, 0x20 +lbl_80389B08: + cmpw r0, r9 + subfic r10, r0, 0x40 + bgt lbl_80389BC0 + addi r9, r9, 1 + subfic r9, r9, 0x40 + add r0, r0, r9 + subf r9, r9, r10 + mtctr r9 + cmpwi r9, 0x20 + addi r7, r9, -32 + blt lbl_80389B40 + srw r8, r3, r7 + li r7, 0 + b lbl_80389B54 +lbl_80389B40: + srw r8, r4, r9 + subfic r7, r9, 0x20 + slw r7, r3, r7 + or r8, r8, r7 + srw r7, r3, r9 +lbl_80389B54: + cmpwi r0, 0x20 + addic r9, r0, -32 + blt lbl_80389B6C + slw r3, r4, r9 + li r4, 0 + b lbl_80389B80 +lbl_80389B6C: + slw r3, r3, r0 + subfic r9, r0, 0x20 + srw r9, r4, r9 + or r3, r3, r9 + slw r4, r4, r0 +lbl_80389B80: + li r10, -1 + addic r7, r7, 0 +lbl_80389B88: + adde r4, r4, r4 + adde r3, r3, r3 + adde r8, r8, r8 + adde r7, r7, r7 + subfc r0, r6, r8 + subfe. r9, r5, r7 + blt lbl_80389BB0 + mr r8, r0 + mr r7, r9 + addic r0, r10, 1 +lbl_80389BB0: + bdnz lbl_80389B88 + adde r4, r4, r4 + adde r3, r3, r3 + blr +lbl_80389BC0: + li r4, 0 + li r3, 0 + blr +} + +asm void __div2i(void) { + nofralloc + stwu r1, -0x10(r1) + rlwinm. r9, r3, 0, 0, 0 + beq lbl_80389BE0 + subfic r4, r4, 0 + subfze r3, r3 +lbl_80389BE0: + stw r9, 8(r1) + rlwinm. r10, r5, 0, 0, 0 + beq lbl_80389BF4 + subfic r6, r6, 0 + subfze r5, r5 +lbl_80389BF4: + stw r10, 0xc(r1) + cmpwi r3, 0 + cntlzw r0, r3 + cntlzw r9, r4 + bne lbl_80389C0C + addi r0, r9, 0x20 +lbl_80389C0C: + cmpwi r5, 0 + cntlzw r9, r5 + cntlzw r10, r6 + bne lbl_80389C20 + addi r9, r10, 0x20 +lbl_80389C20: + cmpw r0, r9 + subfic r10, r0, 0x40 + bgt lbl_80389CF4 + addi r9, r9, 1 + subfic r9, r9, 0x40 + add r0, r0, r9 + subf r9, r9, r10 + mtctr r9 + cmpwi r9, 0x20 + addi r7, r9, -32 + blt lbl_80389C58 + srw r8, r3, r7 + li r7, 0 + b lbl_80389C6C +lbl_80389C58: + srw r8, r4, r9 + subfic r7, r9, 0x20 + slw r7, r3, r7 + or r8, r8, r7 + srw r7, r3, r9 +lbl_80389C6C: + cmpwi r0, 0x20 + addic r9, r0, -32 + blt lbl_80389C84 + slw r3, r4, r9 + li r4, 0 + b lbl_80389C98 +lbl_80389C84: + slw r3, r3, r0 + subfic r9, r0, 0x20 + srw r9, r4, r9 + or r3, r3, r9 + slw r4, r4, r0 +lbl_80389C98: + li r10, -1 + addic r7, r7, 0 +lbl_80389CA0: + adde r4, r4, r4 + adde r3, r3, r3 + adde r8, r8, r8 + adde r7, r7, r7 + subfc r0, r6, r8 + subfe. r9, r5, r7 + blt lbl_80389CC8 + mr r8, r0 + mr r7, r9 + addic r0, r10, 1 +lbl_80389CC8: + bdnz lbl_80389CA0 + adde r4, r4, r4 + adde r3, r3, r3 + lwz r9, 8(r1) + lwz r10, 0xc(r1) + xor. r7, r9, r10 + beq lbl_80389CFC + cmpwi r9, 0 + subfic r4, r4, 0 + subfze r3, r3 + b lbl_80389CFC +lbl_80389CF4: + li r4, 0 + li r3, 0 +lbl_80389CFC: + addi r1, r1, 0x10 + blr +} + +asm void __mod2u() { + nofralloc + cmpwi r3, 0 + cntlzw r0, r3 + cntlzw r9, r4 + bne lbl_80389D18 + addi r0, r9, 0x20 +lbl_80389D18: + cmpwi r5, 0 + cntlzw r9, r5 + cntlzw r10, r6 + bne lbl_80389D2C + addi r9, r10, 0x20 +lbl_80389D2C: + cmpw r0, r9 + subfic r10, r0, 0x40 + bgtlr + addi r9, r9, 1 + subfic r9, r9, 0x40 + add r0, r0, r9 + subf r9, r9, r10 + mtctr r9 + cmpwi r9, 0x20 + addi r7, r9, -32 + blt lbl_80389D64 + srw r8, r3, r7 + li r7, 0 + b lbl_80389D78 +lbl_80389D64: + srw r8, r4, r9 + subfic r7, r9, 0x20 + slw r7, r3, r7 + or r8, r8, r7 + srw r7, r3, r9 +lbl_80389D78: + cmpwi r0, 0x20 + addic r9, r0, -32 + blt lbl_80389D90 + slw r3, r4, r9 + li r4, 0 + b lbl_80389DA4 +lbl_80389D90: + slw r3, r3, r0 + subfic r9, r0, 0x20 + srw r9, r4, r9 + or r3, r3, r9 + slw r4, r4, r0 +lbl_80389DA4: + li r10, -1 + addic r7, r7, 0 +lbl_80389DAC: + adde r4, r4, r4 + adde r3, r3, r3 + adde r8, r8, r8 + adde r7, r7, r7 + subfc r0, r6, r8 + subfe. r9, r5, r7 + blt lbl_80389DD4 + mr r8, r0 + mr r7, r9 + addic r0, r10, 1 +lbl_80389DD4: + bdnz lbl_80389DAC + mr r4, r8 + mr r3, r7 + blr + blr +} + +asm void __mod2i(void) { + nofralloc + cmpwi cr7, r3, 0 + bge cr7, lbl_80389DF8 + subfic r4, r4, 0 + subfze r3, r3 +lbl_80389DF8: + cmpwi r5, 0 + bge lbl_80389E08 + subfic r6, r6, 0 + subfze r5, r5 +lbl_80389E08: + cmpwi r3, 0 + cntlzw r0, r3 + cntlzw r9, r4 + bne lbl_80389E1C + addi r0, r9, 0x20 +lbl_80389E1C: + cmpwi r5, 0 + cntlzw r9, r5 + cntlzw r10, r6 + bne lbl_80389E30 + addi r9, r10, 0x20 +lbl_80389E30: + cmpw r0, r9 + subfic r10, r0, 0x40 + bgt lbl_80389EE4 + addi r9, r9, 1 + subfic r9, r9, 0x40 + add r0, r0, r9 + subf r9, r9, r10 + mtctr r9 + cmpwi r9, 0x20 + addi r7, r9, -32 + blt lbl_80389E68 + srw r8, r3, r7 + li r7, 0 + b lbl_80389E7C +lbl_80389E68: + srw r8, r4, r9 + subfic r7, r9, 0x20 + slw r7, r3, r7 + or r8, r8, r7 + srw r7, r3, r9 +lbl_80389E7C: + cmpwi r0, 0x20 + addic r9, r0, -32 + blt lbl_80389E94 + slw r3, r4, r9 + li r4, 0 + b lbl_80389EA8 +lbl_80389E94: + slw r3, r3, r0 + subfic r9, r0, 0x20 + srw r9, r4, r9 + or r3, r3, r9 + slw r4, r4, r0 +lbl_80389EA8: + li r10, -1 + addic r7, r7, 0 +lbl_80389EB0: + adde r4, r4, r4 + adde r3, r3, r3 + adde r8, r8, r8 + adde r7, r7, r7 + subfc r0, r6, r8 + subfe. r9, r5, r7 + blt lbl_80389ED8 + mr r8, r0 + mr r7, r9 + addic r0, r10, 1 +lbl_80389ED8: + bdnz lbl_80389EB0 + mr r4, r8 + mr r3, r7 +lbl_80389EE4: + bgelr cr7 + subfic r4, r4, 0 + subfze r3, r3 + blr +} + +asm void __shl2i() { + nofralloc + subfic r8, r5, 0x20 + addic r9, r5, -32 + slw r3, r3, r5 + srw r10, r4, r8 + or r3, r3, r10 + slw r10, r4, r9 + or r3, r3, r10 + slw r4, r4, r5 + blr +} + +asm void __shr2u() { + nofralloc + subfic r8, r5, 0x20 + addic r9, r5, -32 + srw r4, r4, r5 + slw r10, r3, r8 + or r4, r4, r10 + srw r10, r3, r9 + or r4, r4, r10 + srw r3, r3, r5 + blr +} + +asm void __shr2i() { + nofralloc + subfic r8, r5, 0x20 + addic. r9, r5, -32 + srw r4, r4, r5 + slw r10, r3, r8 + or r4, r4, r10 + sraw r10, r3, r9 + ble lbl_80389F5C + or r4, r4, r10 +lbl_80389F5C: + sraw r3, r3, r5 + blr +} + +asm void __cvt_sll_flt(void) { + nofralloc + stwu r1, -0x10(r1) + rlwinm. r5, r3, 0, 0, 0 + beq lbl_80389F78 + subfic r4, r4, 0 + subfze r3, r3 +lbl_80389F78: + or. r7, r3, r4 + li r6, 0 + beq lbl_8038A000 + cntlzw r7, r3 + cntlzw r8, r4 + rlwinm r9, r7, 0x1a, 0, 4 + srawi r9, r9, 0x1f + and r9, r9, r8 + add r7, r7, r9 + subfic r8, r7, 0x20 + addic r9, r7, -32 + slw r3, r3, r7 + srw r10, r4, r8 + or r3, r3, r10 + slw r10, r4, r9 + or r3, r3, r10 + slw r4, r4, r7 + subf r6, r7, r6 + clrlwi r7, r4, 0x15 + cmpwi r7, 0x400 + addi r6, r6, 0x43e + blt lbl_80389FE8 + bgt lbl_80389FDC + rlwinm. r7, r4, 0, 0x14, 0x14 + beq lbl_80389FE8 +lbl_80389FDC: + addic r4, r4, 0x800 + addze r3, r3 + addze r6, r6 +lbl_80389FE8: + rotlwi r4, r4, 0x15 + rlwimi r4, r3, 0x15, 0, 0xa + rlwinm r3, r3, 0x15, 0xc, 0x1f + slwi r6, r6, 0x14 + or r3, r6, r3 + or r3, r5, r3 +lbl_8038A000: + stw r3, 8(r1) + stw r4, 0xc(r1) + lfd f1, 8(r1) + frsp f1, f1 + addi r1, r1, 0x10 + blr +} + +asm unsigned long __cvt_dbl_usll(register double d) { + nofralloc + stwu r1, -0x10(r1) + stfd f1, 8(r1) + lwz r3, 8(r1) + lwz r4, 0xc(r1) + rlwinm r5, r3, 0xc, 0x15, 0x1f + cmplwi r5, 0x3ff + bge lbl_8038A040 + li r3, 0 + li r4, 0 + b lbl_8038A0DC +lbl_8038A040: + mr r6, r3 + clrlwi r3, r3, 0xc + oris r3, r3, 0x10 + addi r5, r5, -1075 + cmpwi r5, 0 + bge lbl_8038A080 + neg r5, r5 + subfic r8, r5, 0x20 + addic r9, r5, -32 + srw r4, r4, r5 + slw r10, r3, r8 + or r4, r4, r10 + srw r10, r3, r9 + or r4, r4, r10 + srw r3, r3, r5 + b lbl_8038A0CC +lbl_8038A080: + cmpwi r5, 0xa + ble+ lbl_8038A0AC + rlwinm. r6, r6, 0, 0, 0 + beq lbl_8038A09C + lis r3, 0x8000 + li r4, 0 + b lbl_8038A0DC +lbl_8038A09C: + lis r3, 0x7FFFFFFF@h + ori r3, r3, 0x7FFFFFFF@l + li r4, -1 + b lbl_8038A0DC +lbl_8038A0AC: + subfic r8, r5, 0x20 + addic r9, r5, -32 + slw r3, r3, r5 + srw r10, r4, r8 + or r3, r3, r10 + slw r10, r4, r9 + or r3, r3, r10 + slw r4, r4, r5 +lbl_8038A0CC: + rlwinm. r6, r6, 0, 0, 0 + beq lbl_8038A0DC + subfic r4, r4, 0 + subfze r3, r3 +lbl_8038A0DC: + addi r1, r1, 0x10 + blr +} + +#ifdef __cplusplus +} +#endif |