/contrib/sdk/sources/newlib/libc/Makefile |
---|
26,7 → 26,13 |
crt/crt1.c \ |
crt/crt2.c \ |
crt/chkstk.S \ |
crt/exit.S \ |
crt/exit.S |
LIBCRT_SRCS:= \ |
crt/start.S \ |
crt/crt3.c \ |
crt/chkstk.S \ |
crt/pseudo-reloc.c \ |
pe/crtloader.c |
LIBDLL_SRCS:= \ |
39,21 → 45,16 |
LIBCDLL_SRCS:= \ |
crt/crtdll.c \ |
crt/crt2.c \ |
crt/pseudo-reloc.c \ |
crt/chkstk.S \ |
crt/exit.S \ |
pe/loader.c |
LIBCRT_SRCS:= \ |
crt/start.S \ |
crt/chkstk.S \ |
crt/crt3.c \ |
crt/pseudo-reloc.c \ |
pe/crtloader.c |
CORE_SRCS:= \ |
argz/buf_findstr.c \ |
argz/envz_get.c \ |
crt/console.asm \ |
crt/emutls.c \ |
crt/thread.S \ |
crt/tls.S \ |
119,6 → 120,7 |
signal/signal.c \ |
sys/access.c \ |
sys/close.c \ |
sys/conio.c \ |
sys/create.c \ |
sys/errno.c \ |
sys/finfo.c \ |
/contrib/sdk/sources/newlib/libc/crt/crt_amz.S |
---|
File deleted |
/contrib/sdk/sources/newlib/libc/crt/console.asm |
---|
0,0 → 1,271 |
include '../proc32.inc' |
format MS COFF |
public _load_libconsole |
public _con_init@20 |
public _con_exit@4 |
public _con_get_flags |
public _con_set_flags@4 |
public _con_cls |
public _con_write_string@8 |
section '.text' align 16 |
;void* __fastcall getprocaddr(export, name) |
align 4 |
getprocaddress: |
push esi |
push edi |
xor eax, eax |
test ecx, ecx ; If hlib = 0 then goto .end |
jz .end |
.next: |
cmp [ecx], dword 0 ; If end of export table then goto .end |
jz .end |
xor eax, eax |
mov esi, [ecx] |
mov edi, edx ; name |
.next_: |
lodsb |
scasb |
jne .fail |
or al, al |
jnz .next_ |
jmp .ok |
.fail: |
add ecx, 8 |
jmp .next |
.ok: |
mov eax, [ecx + 4] ; return address |
.end: |
pop edi |
pop esi |
ret |
;void fastcall dll_link(export, import) |
align 4 |
dll_link: |
push esi |
push ecx |
mov esi, edx |
test esi, esi |
jz .done |
.next: |
mov edx, [esi] |
test edx, edx |
jz .done |
mov ecx, [esp] |
call getprocaddress |
test eax, eax |
jz .done |
mov [esi], eax |
add esi, 4 |
jmp .next |
.done: |
pop ecx |
pop esi |
ret |
align 4 |
dll_load: |
push ebp |
push ebx |
push esi |
push edi |
mov ebp, [esp+20] |
.next_lib: |
mov edx, [ebp] |
test edx, edx |
jz .exit |
mov esi, [ebp+4] |
mov edi, s_libdir.fname |
@@: |
lodsb |
stosb |
test al, al |
jnz @b |
mov eax, 68 |
mov ebx, 19 |
mov ecx, s_libdir |
int 0x40 |
test eax, eax |
jz .fail |
mov ecx, eax |
call dll_link |
mov eax, [ecx] |
cmp dword[eax], 'lib_' |
jnz @f |
mov esi, [ecx+4] |
pushad |
mov eax, mem.Alloc |
mov ebx, mem.Free |
mov ecx, mem.ReAlloc |
mov edx, dll_load |
call esi |
popad |
@@: |
add ebp, 8 |
jmp .next_lib |
.exit: |
pop edi |
pop esi |
pop ebx |
pop ebp |
xor eax, eax |
ret 4 |
.fail: |
pop edi |
pop esi |
pop ebx |
pop ebp |
inc eax |
ret 4 |
align 4 |
_load_libconsole: |
push ebx |
mov eax, 40 |
mov ebx, 1 shl 8 |
int 0x40 |
pop ebx |
push @IMPORT |
call dll_load |
test eax, eax |
jnz .fail |
push 1 |
call [con_start] |
xor eax, eax |
.fail: |
ret |
align 4 |
_con_init@20: |
jmp [con_init] |
align 4 |
_con_exit@4: |
jmp [con_exit] |
align 4 |
_con_write_string@8: |
jmp [con_write_string] |
_con_get_flags: |
_con_set_flags@4: |
_con_cls: |
ret |
proc mem.Alloc, size |
push ebx ecx |
mov ecx, [size] |
mov eax, 68 |
mov ebx, 12 |
int 0x40 |
pop ecx ebx |
ret |
endp |
;----------------------------------------------------------------------------- |
proc mem.ReAlloc, mptr, size |
push ebx ecx edx |
mov ecx, [size] |
test ecx, ecx |
jz @f |
@@: |
mov edx, [mptr] |
test edx, edx |
jz @f |
@@: |
mov eax, 68 |
mov ebx, 20 |
int 0x40 |
test eax, eax |
jz @f |
@@: |
pop edx ecx ebx |
ret |
endp |
;----------------------------------------------------------------------------- |
proc mem.Free, mptr |
push ebx ecx |
mov ecx,[mptr] |
test ecx,ecx |
jz @f |
@@: |
mov eax, 68 |
mov ebx, 13 |
int 0x40 |
pop ecx ebx |
ret |
endp |
;section '.ctors' align 4 |
;align 4 |
;dd _load_libconsole |
section '.data' align 16 |
; ------------------------- |
macro library [lname,fname] |
{ |
forward |
dd __#lname#_library_table__,__#lname#_library_name__ |
common |
dd 0 |
forward |
align 4 |
__#lname#_library_name__ db fname,0 |
} |
macro import lname,[name,sname] |
{ |
common |
align 4 |
__#lname#_library_table__: |
forward |
if used name |
name dd __#name#_import_name__ |
end if |
common |
dd 0 |
forward |
if used name |
align 4 |
__#name#_import_name__ db sname,0 |
end if |
} |
align 4 |
@IMPORT: |
library console, 'console.obj' |
import console, \ |
con_start, 'START', \ |
con_init, 'con_init', \ |
con_exit, 'con_exit', \ |
con_gets, 'con_gets', \ |
con_cls, 'con_cls', \ |
con_getch2, 'con_getch2', \ |
con_set_cursor_pos, 'con_set_cursor_pos',\ |
con_write_string, 'con_write_string',\ |
con_get_flags, 'con_get_flags', \ |
con_set_flags, 'con_set_flags' |
s_libdir: |
db '/sys/lib/' |
.fname rb 32 |
/contrib/sdk/sources/newlib/libc/crt/crt1.c |
---|
19,8 → 19,19 |
#include <stdio.h> |
#include <sys/kos_io.h> |
#include "cpu_features.h" |
struct app_hdr |
{ |
char banner[8]; |
int version; |
int start; |
int iend; |
int memsize; |
int stacktop; |
char *cmdline; |
char *path; |
}; |
extern int main (int, char **, char **); |
/* NOTE: The code for initializing the _argv, _argc, and environ variables |
* has been moved to a separate .c file which is included in both |
28,100 → 39,163 |
* be manually synchronized, but it does lead to this not-generally- |
* a-good-idea use of include. */ |
char* __appenv; |
int __appenv_size; |
extern char __cmdline[]; |
extern char __pgmname[]; |
extern char _tls_map[128]; |
extern int main (int, char **, char **); |
char * __libc_getenv(const char *name) |
{ |
return NULL; |
} |
int _errno; |
int _fmode; |
static int split_cmdline(char *cmdline, char **argv) |
{ |
enum quote_state |
{ |
QUOTE_NONE, /* no " active in current parm */ |
QUOTE_DELIMITER, /* " was first char and must be last */ |
QUOTE_STARTED /* " was seen, look for a match */ |
}; |
int _argc; |
char **_argv; |
enum quote_state state; |
unsigned int argc; |
char *p = cmdline; |
char *new_arg, *start; |
static char *arg[2]; |
argc = 0; |
void _exit(int __status) __attribute__((noreturn)); |
for(;;) |
{ |
/* skip over spaces and tabs */ |
if ( *p ) |
{ |
while (*p == ' ' || *p == '\t') |
++p; |
} |
if (*p == '\0') |
break; |
char * __libc_getenv(const char *name) |
state = QUOTE_NONE; |
if( *p == '\"' ) |
{ |
return NULL; |
p++; |
state = QUOTE_DELIMITER; |
} |
new_arg = start = p; |
for (;;) |
{ |
if( *p == '\"' ) |
{ |
p++; |
if( state == QUOTE_NONE ) |
{ |
state = QUOTE_STARTED; |
} |
else |
{ |
state = QUOTE_NONE; |
} |
continue; |
} |
void __main (){}; |
struct app_hdr |
if( *p == ' ' || *p == '\t' ) |
{ |
char banner[8]; |
int version; |
int start; |
int iend; |
int memsize; |
int stacktop; |
char *cmdline; |
char *path; |
}; |
if( state == QUOTE_NONE ) |
{ |
break; |
} |
} |
typedef void (*ctp)(); |
static void __do_global_ctors () |
if( *p == '\0' ) |
break; |
if( *p == '\\' ) |
{ |
extern int __CTOR_LIST__; |
int *c = &__CTOR_LIST__; |
c++; |
while (*c) |
if( p[1] == '\"' ) |
{ |
ctp d = (ctp)*c; |
(d)(); |
c++; |
++p; |
if( p[-2] == '\\' ) |
{ |
continue; |
} |
} |
} |
if( argv ) |
{ |
*(new_arg++) = *p; |
} |
++p; |
}; |
void __attribute__((noreturn)) |
__crt_startup (void) |
if( argv ) |
{ |
int nRet; |
struct app_hdr *header; |
argv[ argc ] = start; |
++argc; |
init_global_reent(); |
/* |
* Initialize floating point unit. |
The *new = '\0' is req'd in case there was a \" to " |
translation. It must be after the *p check against |
'\0' because new and p could point to the same char |
in which case the scan would be terminated too soon. |
*/ |
__cpu_features_init (); /* Do we have SSE, etc.*/ |
// _fpreset (); /* Supplied by the runtime library. */ |
__do_global_ctors(); |
if( *p == '\0' ) |
{ |
*new_arg = '\0'; |
break; |
} |
*new_arg = '\0'; |
++p; |
} |
else |
{ |
++argc; |
if( *p == '\0' ) |
{ |
break; |
} |
++p; |
} |
} |
arg[0] = &__pgmname[0]; |
return argc; |
}; |
if( __cmdline[0] != 0) |
void __attribute__((noreturn)) |
__crt_startup (void) |
{ |
_argc = 2; |
arg[1] = &__cmdline[0]; |
} else _argc = 1; |
struct app_hdr *header = NULL; |
int retval = 0; |
_argv = arg; |
char **argv; |
int argc; |
/* |
* Sets the default file mode. |
* If _CRT_fmode is set, also set mode for stdin, stdout |
* and stderr, as well |
* NOTE: DLLs don't do this because that would be rude! |
*/ |
// _mingw32_init_fmode (); |
memset(_tls_map, 0xFF, 32*4); |
_tls_map[0] = 0xE0; |
init_reent(); |
init_stdio(); |
nRet = main (_argc, _argv, NULL); |
if( header->cmdline[0] != 0) |
{ |
argc = split_cmdline(header->cmdline, NULL) + 1; |
argv = alloca((argc+1)*sizeof(char*)); |
argv[0] = header->path; |
/* |
* Perform exit processing for the C library. This means |
* flushing output and calling 'atexit' registered functions. |
*/ |
exit (nRet); |
split_cmdline(header->cmdline, argv + 1); |
} |
else |
{ |
argc = 1; |
argv = alloca((argc+1)*sizeof(char*)); |
argv[0] = header->path; |
} |
argv[argc] = NULL; |
retval = main(argc, argv, NULL); |
done: |
exit (retval); |
} |
/contrib/sdk/sources/newlib/libc/crt/crt2.c |
---|
2,6 → 2,8 |
void init_reent(); |
void _exit(int __status) __attribute__((noreturn)); |
void __attribute__((noreturn)) |
__thread_startup (int (*entry)(void*), void *param, |
void *stacklow, void *stackhigh) |
/contrib/sdk/sources/newlib/libc/crt/crtdll.c |
---|
1,3 → 1,13 |
/* |
* crtdll.c |
* This file has no copyright assigned and is placed in the Public Domain. |
* This file is a part of the mingw-runtime package. |
* No warranty is given; refer to the file DISCLAIMER within the package. |
* |
* Source code for the shared libc startup proceedures. This code is compiled |
* to make libc.dll, which should be located in the library path. |
* |
*/ |
#include <_ansi.h> |
#include <reent.h> |
38,26 → 48,6 |
extern char _tls_map[128]; |
void __attribute__((noreturn)) |
__thread_startup (int (*entry)(void*), void *param, |
void *stacklow, void *stackhigh) |
{ |
int retval; |
// asm volatile ( "xchgw %bx, %bx"); |
__asm__ __volatile__( // save stack limits |
"movl %0, %%fs:8 \n\t" // use TLS |
"movl %1, %%fs:12 \n\t" |
::"r"(stacklow), "r"(stackhigh)); |
init_reent(); // initialize thread reentry structure |
retval = entry(param); // call user thread function |
_exit(retval); |
}; |
char * __libc_getenv(const char *name) |
{ |
return NULL; |
192,6 → 182,7 |
_tls_map[0] = 0xE0; |
init_reent(); |
init_stdio(); |
__do_global_ctors(); |
// __appenv = load_file("/sys/system.env", &__appenv_size); |
221,4 → 212,3 |
exit (retval); |
} |
/contrib/sdk/sources/newlib/libc/include/libsync.h |
---|
1,16 → 1,106 |
#ifndef __LBSYNC_H__ |
#define __LBSYNC_H__ |
#define FUTEX_INIT 0 |
#define FUTEX_DESTROY 1 |
#define FUTEX_WAIT 2 |
#define FUTEX_WAKE 3 |
#define exchange_acquire(ptr, new) \ |
__atomic_exchange_4((ptr), (new), __ATOMIC_ACQUIRE) |
#define exchange_release(ptr, new) \ |
__atomic_exchange_4((ptr), (new), __ATOMIC_RELEASE) |
typedef struct |
{ |
volatile int lock; |
unsigned int handle; |
int handle; |
}mutex_t; |
int __fastcall mutex_init(mutex_t *mutex); |
int __fastcall mutex_destroy(mutex_t *mutex); |
void __fastcall mutex_lock(mutex_t *mutex); |
int __fastcall mutex_trylock (mutex_t *mutex); |
void __fastcall mutex_unlock(mutex_t *mutex); |
static inline int mutex_init(mutex_t *mutex) |
{ |
int handle; |
mutex->lock = 0; |
asm volatile( |
"int $0x40\t" |
:"=a"(handle) |
:"a"(77),"b"(FUTEX_INIT),"c"(mutex)); |
mutex->handle = handle; |
return handle; |
}; |
static inline int mutex_destroy(mutex_t *mutex) |
{ |
int retval; |
asm volatile( |
"int $0x40\t" |
:"=a"(retval) |
:"a"(77),"b"(FUTEX_DESTROY),"c"(mutex->handle)); |
return retval; |
}; |
static inline void mutex_lock(mutex_t *mutex) |
{ |
int tmp; |
if( __sync_fetch_and_add(&mutex->lock, 1) == 0) |
return; |
while (exchange_acquire (&mutex->lock, 2) != 0) |
{ |
asm volatile( |
"int $0x40\t" |
:"=a"(tmp) |
:"a"(77),"b"(FUTEX_WAIT), |
"c"(mutex->handle),"d"(2),"S"(0)); |
} |
}; |
static inline void mutex_lock_timeout(mutex_t *mutex, int timeout) |
{ |
int tmp; |
if( __sync_fetch_and_add(&mutex->lock, 1) == 0) |
return; |
while (exchange_acquire (&mutex->lock, 2) != 0) |
{ |
asm volatile( |
"int $0x40\t" |
:"=a"(tmp) |
:"a"(77),"b"(FUTEX_WAIT), |
"c"(mutex->handle),"d"(2),"S"(timeout)); |
} |
}; |
static inline int mutex_trylock (mutex_t *mutex) |
{ |
int zero = 0; |
return __atomic_compare_exchange_4(&mutex->lock, &zero, 1,0,__ATOMIC_ACQUIRE,__ATOMIC_RELAXED); |
}; |
static inline void mutex_unlock(mutex_t *mutex) |
{ |
int prev; |
prev = exchange_release (&mutex->lock, 0); |
if (prev != 1) |
{ |
asm volatile( |
"int $0x40\t" |
:"=a"(prev) |
:"a"(77),"b"(FUTEX_WAKE), |
"c"(mutex->handle),"d"(1)); |
}; |
}; |
#endif |
/contrib/sdk/sources/newlib/libc/proc32.inc |
---|
0,0 → 1,301 |
; Macroinstructions for defining and calling procedures |
macro stdcall proc,[arg] ; directly call STDCALL procedure |
{ common |
if ~ arg eq |
reverse |
pushd arg |
common |
end if |
call proc } |
macro invoke proc,[arg] ; indirectly call STDCALL procedure |
{ common |
if ~ arg eq |
reverse |
pushd arg |
common |
end if |
call [proc] } |
macro ccall proc,[arg] ; directly call CDECL procedure |
{ common |
size@ccall = 0 |
if ~ arg eq |
reverse |
pushd arg |
size@ccall = size@ccall+4 |
common |
end if |
call proc |
if size@ccall |
add esp,size@ccall |
end if } |
macro cinvoke proc,[arg] ; indirectly call CDECL procedure |
{ common |
size@ccall = 0 |
if ~ arg eq |
reverse |
pushd arg |
size@ccall = size@ccall+4 |
common |
end if |
call [proc] |
if size@ccall |
add esp,size@ccall |
end if } |
macro proc [args] ; define procedure |
{ common |
match name params, args> |
\{ define@proc name,<params \} } |
prologue@proc equ prologuedef |
macro prologuedef procname,flag,parmbytes,localbytes,reglist |
{ local loc |
loc = (localbytes+3) and (not 3) |
parmbase@proc equ ebp+8 |
localbase@proc equ ebp-loc |
if parmbytes | localbytes |
push ebp |
mov ebp,esp |
if localbytes |
sub esp,loc |
end if |
end if |
irps reg, reglist \{ push reg \} } |
epilogue@proc equ epiloguedef |
macro epiloguedef procname,flag,parmbytes,localbytes,reglist |
{ irps reg, reglist \{ reverse pop reg \} |
if parmbytes | localbytes |
leave |
end if |
if flag and 10000b |
retn |
else |
retn parmbytes |
end if } |
close@proc equ |
macro define@proc name,statement |
{ local params,flag,regs,parmbytes,localbytes,current |
if used name |
name: |
match =stdcall args, statement \{ params equ args |
flag = 11b \} |
match =stdcall, statement \{ params equ |
flag = 11b \} |
match =c args, statement \{ params equ args |
flag = 10001b \} |
match =c, statement \{ params equ |
flag = 10001b \} |
match =params, params \{ params equ statement |
flag = 0 \} |
match =uses reglist=,args, params \{ regs equ reglist |
params equ args \} |
match =regs =uses reglist, regs params \{ regs equ reglist |
params equ \} |
match =regs, regs \{ regs equ \} |
match prologue:reglist, prologue@proc:<regs> \{ prologue name,flag,parmbytes,localbytes,reglist \} |
virtual at parmbase@proc |
match =,args, params \{ defargs@proc args \} |
match =args@proc args, args@proc params \{ defargs@proc args \} |
parmbytes = $-(parmbase@proc) |
end virtual |
name # % = parmbytes/4 |
all@vars equ |
current = 0 |
macro locals |
\{ virtual at localbase@proc+current |
macro label def \\{ match . type,def> \\\{ deflocal@proc .,label,<type \\\} \\} |
struc db [val] \\{ \common deflocal@proc .,db,val \\} |
struc du [val] \\{ \common deflocal@proc .,du,val \\} |
struc dw [val] \\{ \common deflocal@proc .,dw,val \\} |
struc dp [val] \\{ \common deflocal@proc .,dp,val \\} |
struc dd [val] \\{ \common deflocal@proc .,dd,val \\} |
struc dt [val] \\{ \common deflocal@proc .,dt,val \\} |
struc dq [val] \\{ \common deflocal@proc .,dq,val \\} |
struc rb cnt \\{ deflocal@proc .,rb cnt, \\} |
struc rw cnt \\{ deflocal@proc .,rw cnt, \\} |
struc rp cnt \\{ deflocal@proc .,rp cnt, \\} |
struc rd cnt \\{ deflocal@proc .,rd cnt, \\} |
struc rt cnt \\{ deflocal@proc .,rt cnt, \\} |
struc rq cnt \\{ deflocal@proc .,rq cnt, \\} \} |
macro endl |
\{ purge label |
restruc db,du,dw,dp,dd,dt,dq |
restruc rb,rw,rp,rd,rt,rq |
current = $-(localbase@proc) |
end virtual \} |
macro ret operand |
\{ match any, operand \\{ retn operand \\} |
match , operand \\{ match epilogue:reglist, epilogue@proc:<regs> \\\{ epilogue name,flag,parmbytes,localbytes,reglist \\\} \\} \} |
macro finish@proc |
\{ localbytes = current |
match close:reglist, close@proc:<regs> \\{ close name,flag,parmbytes,localbytes,reglist \\} |
end if \} } |
macro defargs@proc [arg] |
{ common |
if ~ arg eq |
forward |
local ..arg,current@arg |
match argname:type, arg |
\{ current@arg equ argname |
label ..arg type |
argname equ ..arg |
if qqword eq type |
dd ?,?,?,?,?,?,?,? |
else if dqword eq type |
dd ?,?,?,? |
else if tbyte eq type |
dd ?,?,? |
else if qword eq type | pword eq type |
dd ?,? |
else |
dd ? |
end if \} |
match =current@arg,current@arg |
\{ current@arg equ arg |
arg equ ..arg |
..arg dd ? \} |
common |
args@proc equ current@arg |
forward |
restore current@arg |
common |
end if } |
macro deflocal@proc name,def,[val] { name def val } |
macro deflocal@proc name,def,[val] |
{ common |
match vars, all@vars \{ all@vars equ all@vars, \} |
all@vars equ all@vars name |
forward |
local ..var,..tmp |
..var def val |
match =?, val \{ ..tmp equ \} |
match any =?, val \{ ..tmp equ \} |
match any (=?), val \{ ..tmp equ \} |
match =label, def \{ ..tmp equ \} |
match tmp : value, ..tmp : val |
\{ tmp: end virtual |
initlocal@proc ..var,def value |
virtual at tmp\} |
common |
match first rest, ..var, \{ name equ first \} } |
struc label type { label . type } |
macro initlocal@proc name,def |
{ virtual at name |
def |
size@initlocal = $ - name |
end virtual |
position@initlocal = 0 |
while size@initlocal > position@initlocal |
virtual at name |
def |
if size@initlocal - position@initlocal < 2 |
current@initlocal = 1 |
load byte@initlocal byte from name+position@initlocal |
else if size@initlocal - position@initlocal < 4 |
current@initlocal = 2 |
load word@initlocal word from name+position@initlocal |
else |
current@initlocal = 4 |
load dword@initlocal dword from name+position@initlocal |
end if |
end virtual |
if current@initlocal = 1 |
mov byte [name+position@initlocal],byte@initlocal |
else if current@initlocal = 2 |
mov word [name+position@initlocal],word@initlocal |
else |
mov dword [name+position@initlocal],dword@initlocal |
end if |
position@initlocal = position@initlocal + current@initlocal |
end while } |
macro endp |
{ purge ret,locals,endl |
finish@proc |
purge finish@proc |
restore regs@proc |
match all,args@proc \{ restore all \} |
restore args@proc |
match all,all@vars \{ restore all \} } |
macro local [var] |
{ common |
locals |
forward done@local equ |
match varname[count]:vartype, var |
\{ match =BYTE, vartype \\{ varname rb count |
restore done@local \\} |
match =WORD, vartype \\{ varname rw count |
restore done@local \\} |
match =DWORD, vartype \\{ varname rd count |
restore done@local \\} |
match =PWORD, vartype \\{ varname rp count |
restore done@local \\} |
match =QWORD, vartype \\{ varname rq count |
restore done@local \\} |
match =TBYTE, vartype \\{ varname rt count |
restore done@local \\} |
match =DQWORD, vartype \\{ label varname dqword |
rq count*2 |
restore done@local \\} |
match =QQWORD, vartype \\{ label varname qqword |
rq count*4 |
restore done@local \\} |
match =XWORD, vartype \\{ label varname xword |
rq count*2 |
restore done@local \\} |
match =YWORD, vartype \\{ label varname yword |
rq count*4 |
restore done@local \\} |
match , done@local \\{ virtual |
varname vartype |
end virtual |
rb count*sizeof.\#vartype |
restore done@local \\} \} |
match :varname:vartype, done@local:var |
\{ match =BYTE, vartype \\{ varname db ? |
restore done@local \\} |
match =WORD, vartype \\{ varname dw ? |
restore done@local \\} |
match =DWORD, vartype \\{ varname dd ? |
restore done@local \\} |
match =PWORD, vartype \\{ varname dp ? |
restore done@local \\} |
match =QWORD, vartype \\{ varname dq ? |
restore done@local \\} |
match =TBYTE, vartype \\{ varname dt ? |
restore done@local \\} |
match =DQWORD, vartype \\{ label varname dqword |
dq ?,? |
restore done@local \\} |
match =QQWORD, vartype \\{ label varname qqword |
dq ?,?,?,? |
restore done@local \\} |
match =XWORD, vartype \\{ label varname xword |
dq ?,? |
restore done@local \\} |
match =YWORD, vartype \\{ label varname yword |
dq ?,?,?,? |
restore done@local \\} |
match , done@local \\{ varname vartype |
restore done@local \\} \} |
match ,done@local |
\{ var |
restore done@local \} |
common |
endl } |
/contrib/sdk/sources/newlib/libc/stdio/printf.c |
---|
22,6 → 22,8 |
#include <stdarg.h> |
#include "local.h" |
int __gui_mode; |
int |
_DEFUN(_printf_r, (ptr, fmt), |
struct _reent *ptr _AND |
55,3 → 57,11 |
} |
#endif /* ! _REENT_ONLY */ |
extern int __gui_mode; |
extern void __attribute__ ((constructor)) __init_conio(); |
static void __attribute__ ((constructor)) init_printf() |
{ |
__gui_mode = (int)&__init_conio; |
} |
/contrib/sdk/sources/newlib/libc/stdio/puts.c |
---|
139,3 → 139,12 |
} |
#endif |
extern int __gui_mode; |
extern void __attribute__ ((constructor)) __init_conio(); |
static void __attribute__ ((constructor)) init_puts() |
{ |
__gui_mode = (int)&__init_conio; |
} |
/contrib/sdk/sources/newlib/libc/stdlib/mallocr.c |
---|
550,7 → 550,7 |
#define CORRUPTION_ERROR_ACTION(m) \ |
do { \ |
printf("%s malloc heap corrupted\n",__FUNCTION__); \ |
/*printf("%s malloc heap corrupted\n",__FUNCTION__); */\ |
__asm__("int3"); \ |
}while(0) \ |
557,7 → 557,7 |
#define USAGE_ERROR_ACTION(m, p) \ |
do { \ |
printf("%s malloc heap corrupted\n",__FUNCTION__); \ |
/*printf("%s malloc heap corrupted\n",__FUNCTION__); */\ |
__asm__("int3"); \ |
}while(0) \ |
/contrib/sdk/sources/newlib/libc/sys/conio.c |
---|
0,0 → 1,43 |
#include <_ansi.h> |
#include <sys/unistd.h> |
#include "io.h" |
void load_libconsole(); |
void __stdcall con_init(unsigned w_w, unsigned w_h, unsigned s_w, unsigned s_h, const char* t); |
void __stdcall con_exit(char bCloseWindow); |
unsigned __stdcall con_get_flags(void); |
unsigned __stdcall con_set_flags(unsigned new_flags); |
void __stdcall con_cls(void); |
void __stdcall con_write_string(const char* string, unsigned length); |
int __gui_mode; |
static int console_write(const char *path, const void *buff, |
size_t offset, size_t count, size_t *writes) |
{ |
con_write_string(buff, count); |
*writes = count; |
return count; |
}; |
void __attribute__ ((constructor)) __init_conio() |
{ |
__io_handle *ioh; |
load_libconsole(); |
con_init(80, 25, 80, 250, "Console application"); |
ioh = &__io_tab[STDOUT_FILENO]; |
ioh->mode = _WRITE|_ISTTY; |
ioh->write = &console_write; |
}; |
static void __attribute__ ((destructor)) __fini_conio() |
{ |
con_exit(0); |
} |
/contrib/sdk/sources/newlib/static.lds |
---|
0,0 → 1,118 |
/*OUTPUT_FORMAT("binary")*/ |
ENTRY(__start) |
SECTIONS |
{ |
.text 0x000000: |
{ |
LONG(0x554e454D); |
LONG(0x32305445); |
LONG(1); |
LONG(__start); |
LONG(___iend); |
LONG(___memsize); |
LONG(___stacktop); |
LONG(___cmdline); |
LONG(___pgmname); /* full path */ |
LONG(0); /*FIXME tls data */ |
*(.init) |
*(.text) |
*(SORT(.text$*)) |
*(.text.*) |
*(.glue_7t) |
*(.glue_7) |
___CTOR_LIST__ = .; __CTOR_LIST__ = . ; |
LONG (-1);*(.ctors); *(.ctor); *(SORT(.ctors.*)); LONG (0); |
___DTOR_LIST__ = .; __DTOR_LIST__ = . ; |
LONG (-1); *(.dtors); *(.dtor); *(SORT(.dtors.*)); LONG (0); |
*(.fini) |
/* ??? Why is .gcc_exc here? */ |
*(.gcc_exc) |
PROVIDE (etext = .); |
*(.gcc_except_table) |
} |
.rdata ALIGN(16) : |
{ |
*(.rdata) |
*(SORT(.rdata$*)) |
___RUNTIME_PSEUDO_RELOC_LIST__ = .; |
__RUNTIME_PSEUDO_RELOC_LIST__ = .; |
*(.rdata_runtime_pseudo_reloc) |
___RUNTIME_PSEUDO_RELOC_LIST_END__ = .; |
__RUNTIME_PSEUDO_RELOC_LIST_END__ = .; |
} |
.CRT ALIGN(16) : |
{ |
___crt_xc_start__ = . ; |
*(SORT(.CRT$XC*)) /* C initialization */ |
___crt_xc_end__ = . ; |
___crt_xi_start__ = . ; |
*(SORT(.CRT$XI*)) /* C++ initialization */ |
___crt_xi_end__ = . ; |
___crt_xl_start__ = . ; |
*(SORT(.CRT$XL*)) /* TLS callbacks */ |
/* ___crt_xl_end__ is defined in the TLS Directory support code */ |
___crt_xp_start__ = . ; |
*(SORT(.CRT$XP*)) /* Pre-termination */ |
___crt_xp_end__ = . ; |
___crt_xt_start__ = . ; |
*(SORT(.CRT$XT*)) /* Termination */ |
___crt_xt_end__ = . ; |
} |
.data ALIGN(16) : |
{ |
PROVIDE ( __data_start__ = .) ; |
*(.data) |
*(.data2) |
*(SORT(.data$*)) |
*(.jcr) |
__CRT_MT = .; |
LONG(0); |
PROVIDE ( __data_end__ = .) ; |
*(.data_cygwin_nocopy) |
___iend = . ; |
} |
/* .eh_frame BLOCK(16) : |
{ |
PROVIDE (___EH_FRAME_BEGIN__ = .) ; |
*(.eh_frame*) |
} |
*/ |
bss ALIGN(16): |
{ |
*(.bss) |
*(COMMON) |
. = ALIGN(16); |
___cmdline = .; |
. = . + 256; |
___pgmname = .; |
. = . + 1024 + 16; |
___stacktop = .; |
___memsize = . ; |
} |
/DISCARD/ : |
{ |
*(.debug$S) |
*(.debug$T) |
*(.debug$F) |
*(.drectve) |
*(.note.GNU-stack) |
*(.comment) |
*(.eh_frame) |
*(.debug_abbrev) |
*(.debug_info) |
*(.debug_line) |
*(.debug_frame) |
*(.debug_loc) |
*(.debug_pubnames) |
*(.debug_aranges) |
*(.debug_ranges) |
} |
} |