Skip to content

GitLab

Merged
Created by ROOL@rool:robot:Owner

Library update

1 unresolved thread
Compare
and
18 files
+ 365
- 116
‎c‎
al‎loc‎ +136 -36
arm‎sys‎ +10 -14
st‎dio‎ +5 -3
std‎lib‎ +48 -9
ti‎me‎ +19 -3
cl‎ib‎
‎h‎
ass‎ert‎ +5 -2
com‎plex‎ +7 -2
fl‎oat‎ +24 -3
st‎dio‎ +4 -2
std‎lib‎ +43 -4
ti‎me‎ +27 -9
wc‎har‎ +16 -12
‎s‎
cl_e‎ntry2‎ +8 -0
cl_s‎pare‎ +1 -1
‎h‎
al‎loc‎ +4 -0
hos‎tsys‎ +4 -11
kern‎el/s‎
k_b‎ody‎ +3 -3
Make‎file‎ +1 -2
c/alloc
+ 136
- 36
Show all unchanged lines Show 20 lines
#include <string.h> /* for memset(...), memcpy(...) */
#include <setjmp.h>
#include <signal.h>
#include <stdint.h>
#include "hostsys.h"
#include "alloc.h"
Show 20 lines Show all unchanged lines Show 20 lines
static BlockP sys_heap_top; /* address of top of system heap, should = heapLow
after _init_user_alloc is called */
static void *RMABase; /* base address of RMA */
static void *RMAEnd; /* end address of RMA */
static void *RMAEnd; /* end address of RMA */
static int OSMAligns; /* OS_Module supports aligned RMA requests */
/*
* amount of heap that user can actually write to, does not include bitmaps
* and block overheads
Show 20 lines Show all unchanged lines Show 20 lines
statsP->eventNo--;
}
}
static void init_stats(void)
{
/* grab stats record from heap */
statsP = (StatsPtr) _primitive_alloc(BYTESTOWORDS(sizeof(StatsRec)));
statsP->stats.coalesces = 0; statsP->stats.heapExtensions = 0;
statsP->stats.heapHigh = heapHigh; statsP->stats.heapLow = heapLow;
statsP->stats.userHeap = userHeap; statsP->stats.maxHeapRequirement = 0;
statsP->stats.blocksAllocated = 0; statsP->stats.bytesAllocated = 0;
statsP->stats.blocksDeallocated = 0; statsP->stats.bytesDeallocated = 0;
statsP->events[0].allocates = 0; statsP->events[0].deallocates = 0;
statsP->events[0].bytesAllocated = 0; statsP->events[0].bytesDeallocated = 0;
statsP->nextEvent = 1;
}
#endif
#ifdef BLOCKS_GUARDED
Show 20 lines Show all unchanged lines Show 20 lines
#ifdef BLOCKS_GUARDED
if (check.allocates && check_heap() != OK) RELEASEANDRETURN(CORRUPT)
#endif
/* convert size from words to addresss units */
/* convert size from words to address units */
size *= BYTESPERWORD;
F0("!!primitive_alloc: size ")
FD(size, 10)
Show 20 lines Show all unchanged lines Show 20 lines
extern void *malloc(size_t size)
{ void *ptr;
if (_kernel_processor_mode() & 0xF) /* not USR26 or USR32 */
if (_kernel_processor_mode() & 0xF) { /* not USR26 or USR32 */
if (OSMAligns) { /* no need to track aligned requests */
return _kernel_RMAalloc(size);
} else { /* prefix a header for free() to cope with aligned allocations too */
ptr = _kernel_RMAalloc(size + sizeof(RMABlock));
if (ptr != NULL) {
RMABlock *bp = (RMABlock *)ptr;
bp->real = ptr; /* remember where it came from */
ptr = (void *)(bp + 1);
}
return ptr;
}
}
ENTRYTOALLOC(ptr);
ptr = (void *)_primitive_alloc(BYTESTOWORDS(size));
if ((unsigned)ptr >= MINHEAPERROR) {
Show 20 lines Show all unchanged lines Show 20 lines
extern void free(void *p)
{ int rc;
if (p >= RMABase && p < RMAEnd) {
_kernel_RMAfree(p); return;
if (!OSMAligns) { /* recover the original RMA pointer the kernel expects */
RMABlock *bp = ((RMABlock *)p) - 1;
p = bp->real;
}
_kernel_RMAfree(p);
return;
}
rc = _primitive_dealloc((BlockP)p);
/* following line may not be correct ANSI - but for the moment we
Show 20 lines Show all unchanged lines Show 20 lines
return rc;
}
#ifdef STATS
static void init_stats(void)
{
/* grab stats record from heap */
statsP = (StatsPtr) _primitive_alloc(BYTESTOWORDS(sizeof(StatsRec)));
statsP->stats.coalesces = 0; statsP->stats.heapExtensions = 0;
statsP->stats.heapHigh = heapHigh; statsP->stats.heapLow = heapLow;
statsP->stats.userHeap = userHeap; statsP->stats.maxHeapRequirement = 0;
statsP->stats.blocksAllocated = 0; statsP->stats.bytesAllocated = 0;
statsP->stats.blocksDeallocated = 0; statsP->stats.bytesDeallocated = 0;
statsP->events[0].allocates = 0; statsP->events[0].deallocates = 0;
statsP->events[0].bytesAllocated = 0; statsP->events[0].bytesDeallocated = 0;
statsP->nextEvent = 1;
}
#endif
extern void _terminate_user_alloc(void)
{
heapLow = sys_heap_top;
Show 20 lines Show all unchanged lines Show 20 lines
extern void _init_alloc(void)
{ int j;
_kernel_swi_regs r;
_kernel_oserror *e;
INITMUTEX;
lastFreeBlockOnHeap = NULL;
mapForExistingHeap = NULL;
Show 20 lines Show all unchanged lines Show 20 lines
RMABase = (void *) 0x01800000;
RMAEnd = (void *) 0x01C00000;
}
/* query OS_Module aligned claim */
r.r[0] = 24;
r.r[3] = 128;
r.r[4] = 0; /* expect 'Bad alignment' not 'Unknown subreason' */
e = _kernel_swi(OS_Module,&r,&r);
OSMAligns = !(e && e->errnum == 0x105);
if (!e) { /* succeeded? then free */
r.r[0] = 7;
_kernel_swi(OS_Module,&r,&r);
}
#ifdef STATS
statsP = NULL;
init_stats();
Show 20 lines Show all unchanged lines Show 20 lines
{ int rc;
size_t oldsize;
void *newb = NULL;
if (_kernel_processor_mode() & 0xF) /* not USR26 or USR32? */
if (_kernel_processor_mode() & 0xF) { /* not USR26 or USR32 */
if (OSMAligns) { /* allowed to return differently aligned block */
return _kernel_RMAextend(p, size);
} else {
RMABlock *bp;
if (p != NULL) {
bp = ((RMABlock *)p) - 1;
newb = _kernel_RMAextend(bp->real, size + sizeof(RMABlock));
} else
newb = _kernel_RMAalloc(size + sizeof(RMABlock));
if (newb != NULL) {
bp = (RMABlock *)newb;
bp->real = newb; /* remember where it came from */
newb = (void *)(bp + 1);
}
return newb;
}
}
F0("!!realloc\n");
size = BYTESTOWORDS(size)*BYTESPERWORD;
if (p == NULL) return malloc(size);
Show 20 lines Show all unchanged lines Show 20 lines
* just so that it can verify that the said product really is in range
* for handing to malloc.
*/
unsigned h = (count>>16)*(size>>16);
unsigned m1 = (count>>16)*(size&0xffff);
unsigned m2 = (count&0xffff)*(size>>16);
unsigned l = (count&0xffff)*(size&0xffff);
h += (m1>>16) + (m2>>16);
m1 = (m1&0xffff) + (m2&0xffff) + (l>>16);
l = (l&0xffff) | (m1<<16);
h += m1>>16;
if (h) l = (unsigned)(-1);
if (l >= MAXBYTES) bad_size(l);
r = malloc(l);
unsigned long long l = count * (unsigned long long)size;
if (l >= MAXBYTES) bad_size((size_t)l);
r = malloc((size_t)l);
#ifdef GC
/* if garbage collecting, the block will already have been zeroed */
if ((r != NULL) && (!garbageCollecting)) memset(r, 0, l);
if ((r != NULL) && !garbageCollecting) memset(r, 0, (size_t)l);
#else
if (r != NULL) memset(r, 0, l);
if (r != NULL) memset(r, 0, (size_t)l);
#endif
return r;
}
extern void *aligned_alloc(size_t align, size_t size)
{ void *ptr;
size_t oversize, excess;
if (!align || (align & (align - 1))) /* ensure power of 2 */
return NULL;
if (_kernel_processor_mode() & 0xF) { /* not USR26 or USR32 */
if (OSMAligns) { /* let the kernel do the hard work */
_kernel_oserror *e;
e = _swix(OS_Module, _IN(0)|_INR(3,4)|_OUT(2), 24, size, align, &ptr);
return (e != NULL) ? NULL : ptr;
} else { /* overallocate to ensure alignment, then return the subset */
if (align < sizeof(RMABlock)) align = sizeof(RMABlock);
oversize = size + align - 1 + sizeof(RMABlock);
ptr = _kernel_RMAalloc(oversize);
if (ptr != NULL) {
RMABlock *bp;
uintptr_t user = (uintptr_t)ptr;
user = (user + (align - 1)) & ~(align - 1); /* aligned as the user wished */
bp = ((RMABlock *)user) - 1;
bp->real = ptr; /* remember where it came from */
ptr = (void *)user;
}
return ptr;
}
}
/* otherwise from the heap */
if (align < OVERHEAD) align = OVERHEAD;
if (size < BYTESPERWORD) size = BYTESPERWORD;
excess = 0;
while (1) {
ENTRYTOALLOC(ptr);
oversize = size + align - 1 + OVERHEAD + excess;
ptr = (void *)_primitive_alloc(BYTESTOWORDS(oversize));
if ((unsigned)ptr >= MINHEAPERROR) {
#ifdef STATS
ShowStats();
#endif
if ((int)ptr == CORRUPT)
_alloc_die(_kernel_getmessage("malloc failed", "C12"), CORRUPT);
else return NULL;
} else {
BlockP keepBlock, tempBlock;
uintptr_t user = (uintptr_t)ptr;
user = (user + (align - 1)) & ~(align - 1); /* aligned as the user wished */
user += excess; /* doubly aligned to ensure excess */
if (user != (uintptr_t)ptr) {
/* define a new block at the split point */
tempBlock = ADDBYTES(ptr, -OVERHEAD);
keepBlock = ADDBYTES(user, -OVERHEAD);
oversize = (uintptr_t)keepBlock - (uintptr_t)ptr;
if ((int)oversize <= 0) { /* bad: after OVERHEADs it's an empty block */
_primitive_dealloc((BlockP)ptr);
excess += align;
continue; /* go again but double up alignment */
}
keepBlock->size = SIZE(tempBlock) - oversize - OVERHEAD;
#ifdef BLOCKS_GUARDED
keepBlock->guard = GUARDCONSTANT;
#endif
tempBlock->size = oversize;
_primitive_dealloc((BlockP)ptr); /* aka tempBlock, now adjusted */
}
return (void *)user;
}
}
}
c/armsys
+ 10
- 14
Show all unchanged lines Show 20 lines
#undef str
#undef xstr
static int unused[15];
/* timing things... */
/* struct bbctime objects are used to hold bbc/brazil 5-byte timer value -
Show 20 lines Show all unchanged lines Show 20 lines
/* a = */ 0x3cc, /* a+ = */ 0x3cc };
if (isttyname(filename)) return TTYHANDLE;
else {
char *name = (char *)filename; /* yuk yuk yuk yuk yuk */
FILEHANDLE fh;
int size = 16 * 1024; /* first try for created files */
int osmode = modtab[(openmode >> 1) & 7]; /* forget the 'b'inary bit */
int osmode = modtab[(openmode >> 1) & 7]; /* forget the 'b' & 'x' bits */
_kernel_osfile_block fb;
/* maybe stamp file with current datestamp */
if ((openmode & OPEN_T) || /* update timestamp requested */
(openmode & OPEN_W) ||
(openmode & ~OPEN_B) == OPEN_A) /* or mode = w, w+, or a */
{ if (_kernel_osfile(9, name, &fb) == _kernel_ERROR)
{ if (_kernel_peek_last_oserror()->errnum == 0x108c9)
if ((openmode & (OPEN_X|OPEN_W)) == OPEN_W || /* mode = w, wb, w+, wb+ */
(openmode & ~OPEN_B) == OPEN_A) /* or a, ab (no plus) */
{ if (_kernel_osfile(9, filename, &fb) == _kernel_ERROR)
{ if ((_kernel_peek_last_oserror()->errnum & ~0xFF00) == 0x100c9)
{ errno = -1;
return NONHANDLE; /* (Protected disc) */
}
}
}
retry_open:
fh = _kernel_osfind(osmode & 0xff, name);
fh = _kernel_osfind(osmode & 0xff, (char *) /* yuk */ filename);
if (osmode <= 0x0cc) { /* r or r+ */
if (fh == _kernel_ERROR) errno = -1;
return (fh <= 0) ? NONHANDLE : /* not found */
fh;
} else if (fh > 0) {
if ((osmode == 0x4cc) || (size == 0))
if (_kernel_osargs(3, fh, 0) == _kernel_ERROR) {
if (((openmode & OPEN_X) && size) || /* found, but want eXclusive */
_kernel_osargs(3, fh, 0) == _kernel_ERROR) { /* truncate err */
_kernel_osfind(0, (char *)fh);
errno = -1;
return NONHANDLE;
Show 20 lines Show all unchanged lines Show 20 lines
} else if (fh <= 0) {
/* _kernel_osfile(11) creates an empty file of size 'size', of type */
/* given by fb.load, stamped with the current date & time */
fb.load = (openmode & 1) ? 0xffd : 0xfff; /* data : text */
fb.load = (openmode & OPEN_B) ? 0xffd : 0xfff; /* data : text */
fb.start = 0;
for (; ; size >>= 1) {
if (size < 512) { errno = -1; return NONHANDLE; }
fb.end = size;
if (_kernel_osfile(11, name, &fb) > 0) break;
if (_kernel_osfile(11, filename, &fb) > 0) break;
}
size = 0;
goto retry_open;
Show 20 lines Show all unchanged lines Show 20 lines
{ char *stdinfile = TTYFILENAME,
*stdoutfile = TTYFILENAME,
*stderrfile = TTYFILENAME;
(void) unused;
_getenv_value = NULL;
_error_recursion = 0;
#ifdef DDE
Show 20 lines Show all unchanged lines
c/stdio
+ 5
- 3
Show all unchanged lines Show 20 lines
int flag, openmode; /* nasty magic numbers for openmode */
fclose(iob);
switch (*mode++)
{ default: return(NULL); /* mode is incorrect */
{ default: return NULL; /* 1st of mode must be r/w/a */
case 'r': flag = _IOREAD; openmode = OPEN_R; break;
case 'w': flag = _IOWRITE; openmode = OPEN_W; break;
case 'a': flag = _IOWRITE | _IOAPPEND;
Show 20 lines Show all unchanged lines Show 20 lines
}
for (;;)
{ switch (*mode++)
{
{ /* 2nd can be b/+/b+/+b */
case '+': flag |= _IOREAD+_IOWRITE, openmode |= OPEN_PLUS;
continue;
case 'b': flag |= _IOBIN, openmode |= OPEN_B;
continue;
case 'x': if (*mode != '\0' || /* must be last and writing */
!(openmode & OPEN_W)) return NULL;
openmode |= OPEN_X; break;
}
if (*(mode-1) == 't') openmode |= OPEN_T;
break;
}
if ((fh = _sys_open(name, openmode)) == NONHANDLE) return NULL;
Show 20 lines Show all unchanged lines
c/stdlib
+ 48
- 9
Show all unchanged lines Show 20 lines
typedef void (*vprocp)(void);
static union { vprocp p; int i; } _exitvector[EXIT_LIMIT] = { 0 };
static union { vprocp p; int i; } _qxitvector[EXIT_LIMIT] = { 0 };
/* initialised so not in bss (or shared library trouble) */
static struct {
char number_of_exit_functions;
char number_of_qxit_functions;
char alloc_finalised, io_finalised, getenv_finalised;
} exit_s;
void _exit_init(void)
{
if (_kernel_client_is_module()) {
/* leave SWI mode exit handlers in place. number_of_exit_functions
/* leave SVC mode exit handlers in place. number_of_[q]exit_functions
is guaranteed reasonable */
while (exit_s.number_of_exit_functions != 0)
if (_exitvector[--exit_s.number_of_exit_functions].i & 3) {
++exit_s.number_of_exit_functions; break;
}
} else
while (exit_s.number_of_qxit_functions != 0)
if (_qxitvector[--exit_s.number_of_qxit_functions].i & 3) {
++exit_s.number_of_qxit_functions; break;
}
} else {
exit_s.number_of_exit_functions = 0;
exit_s.number_of_qxit_functions = 0;
}
exit_s.alloc_finalised = 0; exit_s.io_finalised = 0; exit_s.getenv_finalised = 0;
}
Show 20 lines Show all unchanged lines Show 20 lines
return 0; /* success */
}
int at_quick_exit(vprocp func)
{
if (exit_s.number_of_qxit_functions >= EXIT_LIMIT) return 1; /* failure */
_qxitvector[exit_s.number_of_qxit_functions++].i =
(int) func + ((_kernel_processor_mode() & 0xF) != 0);
return 0; /* success */
}
void _lib_shutdown(void)
{
int mode = ((_kernel_processor_mode() & 0xF) != 0);
int isquick = (exit_s.number_of_qxit_functions != 0) &&
(exit_s.number_of_exit_functions == 0);
int ismodule = _kernel_client_is_module(); /* ie is module app, so not */
/* total shutdown */
while (exit_s.number_of_qxit_functions!=0) {
vprocp fn = _qxitvector[--exit_s.number_of_qxit_functions].p;
int flags = _qxitvector[exit_s.number_of_qxit_functions].i;
if ((flags & 3) != mode) { ++exit_s.number_of_qxit_functions; break; };
/* Take extra care with fn ptr - consider Thumb */
fn = (vprocp) ((unsigned) fn &~ 3);
_call_client_0(fn);
}
while (exit_s.number_of_exit_functions!=0) {
vprocp fn = _exitvector[--exit_s.number_of_exit_functions].p;
int flags = _exitvector[exit_s.number_of_exit_functions].i;
Show 20 lines Show all unchanged lines Show 20 lines
{ exit_s.getenv_finalised = 1; _terminate_getenv(); }
if (!exit_s.alloc_finalised)
{ exit_s.alloc_finalised = 1; _terminate_user_alloc(); }
if (!exit_s.io_finalised)
if (!exit_s.io_finalised && !isquick)
{ exit_s.io_finalised = 1; _terminateio(); }
if (ismodule) /* Want terminateio again for module part */
exit_s.io_finalised = 0;
}
void exit(int n)
{
/* No longer calls _lib_shutdown: that is done as C finalisation called
from _kernel_exit.
*/
{ /* Stop any USR mode at_quick_exit's being called */
while (exit_s.number_of_qxit_functions!=0) {
int flags = _qxitvector[--exit_s.number_of_qxit_functions].i;
if ((flags & 3) != 0) { ++exit_s.number_of_qxit_functions; break; };
}
_exit(n);
}
void quick_exit(int n)
{ /* Stop any USR mode atexit's being called */
while (exit_s.number_of_exit_functions!=0) {
int flags = _exitvector[--exit_s.number_of_exit_functions].i;
if ((flags & 3) != 0) { ++exit_s.number_of_exit_functions; break; };
}
_exit(n);
}
Show 20 lines Show all unchanged lines Show 20 lines
* atexit functions either...
*/
while (exit_s.number_of_exit_functions!=0) {
int flags = _exitvector[exit_s.number_of_exit_functions].i;
int flags = _exitvector[--exit_s.number_of_exit_functions].i;
if ((flags & 3) != 0) { ++exit_s.number_of_exit_functions; break; };
}
while (exit_s.number_of_qxit_functions!=0) {
int flags = _qxitvector[--exit_s.number_of_qxit_functions].i;
if ((flags & 3) != 0) { ++exit_s.number_of_qxit_functions; break; };
}
_exit(n);
}
Show 20 lines Show all unchanged lines
c/time
+ 19
- 3
Show all unchanged lines Show 20 lines
/* Adjust for a base at 1 Jan 1970 which is 17 leap years since 1900 */
#define DAYS ((70*365)+17)
t = min + 60*(hour + 24*(v - DAYS));
#undef DAYS
#define days0070 (365*70+17)
t = min + 60*(hour + 24*(v - days0070));
{ int thi = ((int)t >> 16)*60;
int tlo = ((int)t & 0xffff)*60 + sec;
thi += (tlo >> 16) & 0xffff;
Show 20 lines Show all unchanged lines Show 20 lines
/* Now I know why Unix didn't have this */
}
int timespec_get(struct timespec *ts, int base)
{ /* ISO9899:2011 7.27.2.5 */
long long cs; int *req = (int *)&cs; /* doubles as an OS_Word block */
long quot, rem;
if (base != TIME_UTC) return 0;
*(char *)req = 3; req[1] = 0; /* read time as UTC 5 byte integer */
_kernel_osword(14, req);
cs = cs - (8640000uLL * days0070); /* using 1970 epoch */
quot = (long)(cs / 100);
rem = (long)(cs % 100);
if (quot < 0) return 0; /* pre 1970 */
ts->tv_sec = (time_t)quot; /* 32b time_t good 'til 2038 */
ts->tv_nsec = (long)rem * 10000000; /* centi to nano */
return base;
}
#undef days0070
char *asctime(const struct tm *timeptr)
{ static char _timebuf[26+(8+3*9+7)]; /* slop in case illegal args */
sprintf(_timebuf, "%.3s %.3s%3d %.2d:%.2d:%.2d %d\n",
Show 20 lines Show all unchanged lines