summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/Dolphin/dvd/dvd.c8
-rw-r--r--src/Dolphin/vi/vi.c0
-rw-r--r--src/MSL_C.PPCEABI.bare.H/CPlusLibPPC.cpp25
-rw-r--r--src/MSL_C.PPCEABI.bare.H/FILE_POS.c102
-rw-r--r--src/MSL_C.PPCEABI.bare.H/MWCPlusLib.h15
-rw-r--r--src/MSL_C.PPCEABI.bare.H/abort_exit.c38
-rw-r--r--src/MSL_C.PPCEABI.bare.H/alloc.c7
-rw-r--r--src/MSL_C.PPCEABI.bare.H/ansi_files.c119
-rw-r--r--src/MSL_C.PPCEABI.bare.H/arith.c15
-rw-r--r--src/MSL_C.PPCEABI.bare.H/buffer_io.c43
-rw-r--r--src/MSL_C.PPCEABI.bare.H/ctype.c69
-rw-r--r--src/MSL_C.PPCEABI.bare.H/direct_io.c114
-rw-r--r--src/MSL_C.PPCEABI.bare.H/e_acos.c107
-rw-r--r--src/MSL_C.PPCEABI.bare.H/e_asin.c115
-rw-r--r--src/MSL_C.PPCEABI.bare.H/e_atan2.c143
-rw-r--r--src/MSL_C.PPCEABI.bare.H/e_exp.c162
-rw-r--r--src/MSL_C.PPCEABI.bare.H/e_fmod.c167
-rw-r--r--src/MSL_C.PPCEABI.bare.H/e_log.c158
-rw-r--r--src/MSL_C.PPCEABI.bare.H/e_pow.c353
-rw-r--r--src/MSL_C.PPCEABI.bare.H/e_rem_pio2.c184
-rw-r--r--src/MSL_C.PPCEABI.bare.H/errno.c3
-rw-r--r--src/MSL_C.PPCEABI.bare.H/fdlibm.h149
-rw-r--r--src/MSL_C.PPCEABI.bare.H/file_io.c70
-rw-r--r--src/MSL_C.PPCEABI.bare.H/float.c17
-rw-r--r--src/MSL_C.PPCEABI.bare.H/hyperbolicsf.c1
-rw-r--r--src/MSL_C.PPCEABI.bare.H/k_cos.c92
-rw-r--r--src/MSL_C.PPCEABI.bare.H/k_rem_pio2.c349
-rw-r--r--src/MSL_C.PPCEABI.bare.H/k_sin.c79
-rw-r--r--src/MSL_C.PPCEABI.bare.H/k_tan.c134
-rw-r--r--src/MSL_C.PPCEABI.bare.H/locale.c33
-rw-r--r--src/MSL_C.PPCEABI.bare.H/math_ppc.c2
-rw-r--r--src/MSL_C.PPCEABI.bare.H/mbstring.c115
-rw-r--r--src/MSL_C.PPCEABI.bare.H/mem.c70
-rw-r--r--src/MSL_C.PPCEABI.bare.H/mem_funcs.c235
-rw-r--r--src/MSL_C.PPCEABI.bare.H/misc_io.c4
-rw-r--r--src/MSL_C.PPCEABI.bare.H/qsort.c76
-rw-r--r--src/MSL_C.PPCEABI.bare.H/rand.c10
-rw-r--r--src/MSL_C.PPCEABI.bare.H/s_atan.c142
-rw-r--r--src/MSL_C.PPCEABI.bare.H/s_copysign.c30
-rw-r--r--src/MSL_C.PPCEABI.bare.H/s_cos.c75
-rw-r--r--src/MSL_C.PPCEABI.bare.H/s_floor.c87
-rw-r--r--src/MSL_C.PPCEABI.bare.H/s_frexp.c57
-rw-r--r--src/MSL_C.PPCEABI.bare.H/s_ldexp.c54
-rw-r--r--src/MSL_C.PPCEABI.bare.H/s_modf.c79
-rw-r--r--src/MSL_C.PPCEABI.bare.H/s_nextafter.c88
-rw-r--r--src/MSL_C.PPCEABI.bare.H/s_sin.c84
-rw-r--r--src/MSL_C.PPCEABI.bare.H/s_tan.c73
-rw-r--r--src/MSL_C.PPCEABI.bare.H/sscanf.c26
-rw-r--r--src/MSL_C.PPCEABI.bare.H/string.c201
-rw-r--r--src/MSL_C.PPCEABI.bare.H/uart_console_io.c34
-rw-r--r--src/MSL_C.PPCEABI.bare.H/w_acos.c39
-rw-r--r--src/MSL_C.PPCEABI.bare.H/w_asin.c40
-rw-r--r--src/MSL_C.PPCEABI.bare.H/w_atan2.c40
-rw-r--r--src/MSL_C.PPCEABI.bare.H/w_exp.c49
-rw-r--r--src/MSL_C.PPCEABI.bare.H/w_fmod.c38
-rw-r--r--src/MSL_C.PPCEABI.bare.H/w_log.c38
-rw-r--r--src/MSL_C.PPCEABI.bare.H/w_pow.c58
-rw-r--r--src/MSL_C.PPCEABI.bare.H/wchar_io.c28
-rw-r--r--src/Runtime/NMWException.cpp49
-rw-r--r--src/Runtime/NMWException.h16
-rw-r--r--src/Runtime/__mem.c85
-rw-r--r--src/Runtime/__va_arg.c57
-rw-r--r--src/Runtime/abort_exit.c17
-rw-r--r--src/Runtime/global_destructor_chain.c36
-rw-r--r--src/Runtime/ptmf.c45
-rw-r--r--src/Runtime/runtime.c842
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