chinky/rtt-f030
chinky/rtt-f030
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

add newlib compiler depend

Browse Source 
git-svn-id: https://rt-thread.googlecode.com/svn/trunk@1742 bbd45198-f89e-11dd-88c7-29a3b14d5316
This commit is contained in:
bernard.xiong@gmail.com 2011-10-08 13:02:22 +00:00
parent 0d2624313a
commit 73a117039f
4 changed files with 644 additions and 635 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
components/libc/newlib/SConscript
View File

@ -1,8 +1,17 @@
Import('RTT_ROOT') Import('rtconfig')
from building import *
from building import *
src = Glob('*.c')
CPPPATH = [RTT_ROOT + '/components/libc/newlib'] if rtconfig.CROSS_TOOL != 'gcc':
group = DefineGroup('newlib', src, depend = ['RT_USING_NEWLIB'], CPPPATH = CPPPATH) print '================ERROR============================'
print 'Please use GNU GCC compiler if using newlib'
Return('group') print '================================================='
exit(0)
cwd = GetCurrentDir()
src = Glob('*.c')
CPPPATH = [cwd]
group = DefineGroup('newlib', src, depend = ['RT_USING_NEWLIB'], CPPPATH = CPPPATH)
Return('group')

64
components/libc/newlib/libc.c
View File

@ -1,32 +1,32 @@
#include <rtthread.h> #include <rtthread.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <fcntl.h> #include <fcntl.h>
#include <sys/time.h> #include <sys/time.h>
#include "libc.h" #include "libc.h"
void libc_system_init(const char* tty_name) void libc_system_init(const char* tty_name)
{ {
int fd; int fd;
extern int pthread_system_init(void); extern int pthread_system_init(void);
#ifndef RT_USING_DFS_DEVFS #ifndef RT_USING_DFS_DEVFS
#error Please enable devfs by defining RT_USING_DFS_DEVFS in rtconfig.h #error Please enable devfs by defining RT_USING_DFS_DEVFS in rtconfig.h
#endif #endif
/* init console device */ /* init console device */
rt_console_init(tty_name); rt_console_init(tty_name);
/* open console as stdin/stdout/stderr */ /* open console as stdin/stdout/stderr */
fd = open("/dev/console", O_RDONLY, 0); /* for stdin */ fd = open("/dev/console", O_RDONLY, 0); /* for stdin */
fd = open("/dev/console", O_WRONLY, 0); /* for stdout */ fd = open("/dev/console", O_WRONLY, 0); /* for stdout */
fd = open("/dev/console", O_WRONLY, 0); /* for stderr */ fd = open("/dev/console", O_WRONLY, 0); /* for stderr */
/* set PATH and HOME */ /* set PATH and HOME */
putenv("PATH=/"); putenv("PATH=/");
putenv("HOME=/"); putenv("HOME=/");
#ifdef RT_USING_PTHREADS #ifdef RT_USING_PTHREADS
pthread_system_init(); pthread_system_init();
#endif #endif
} }

520
components/libc/newlib/math.c
View File

@ -1,260 +1,260 @@
#include <math.h> #include <math.h>
/* /*
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS CRT * PROJECT: ReactOS CRT
* FILE: lib/crt/math/cos.c * FILE: lib/crt/math/cos.c
* PURPOSE: Generic C Implementation of cos * PURPOSE: Generic C Implementation of cos
* PROGRAMMER: Timo Kreuzer (timo.kreuzer@reactos.org) * PROGRAMMER: Timo Kreuzer (timo.kreuzer@reactos.org)
*/ */
#define PRECISION 9 #define PRECISION 9
static double cos_off_tbl[] = {0.0, -M_PI/2., 0, -M_PI/2.}; static double cos_off_tbl[] = {0.0, -M_PI/2., 0, -M_PI/2.};
static double cos_sign_tbl[] = {1,-1,-1,1}; static double cos_sign_tbl[] = {1,-1,-1,1};
static double sin_off_tbl[] = {0.0, -M_PI/2., 0, -M_PI/2.}; static double sin_off_tbl[] = {0.0, -M_PI/2., 0, -M_PI/2.};
static double sin_sign_tbl[] = {1,-1,-1,1}; static double sin_sign_tbl[] = {1,-1,-1,1};
double sin(double x) double sin(double x)
{ {
int quadrant; int quadrant;
double x2, result; double x2, result;
/* Calculate the quadrant */ /* Calculate the quadrant */
quadrant = x * (2./M_PI); quadrant = x * (2./M_PI);
/* Get offset inside quadrant */ /* Get offset inside quadrant */
x = x - quadrant * (M_PI/2.); x = x - quadrant * (M_PI/2.);
/* Normalize quadrant to [0..3] */ /* Normalize quadrant to [0..3] */
quadrant = (quadrant - 1) & 0x3; quadrant = (quadrant - 1) & 0x3;
/* Fixup value for the generic function */ /* Fixup value for the generic function */
x += sin_off_tbl[quadrant]; x += sin_off_tbl[quadrant];
/* Calculate the negative of the square of x */ /* Calculate the negative of the square of x */
x2 = - (x * x); x2 = - (x * x);
/* This is an unrolled taylor series using <PRECISION> iterations /* This is an unrolled taylor series using <PRECISION> iterations
* Example with 4 iterations: * Example with 4 iterations:
* result = 1 - x^2/2! + x^4/4! - x^6/6! + x^8/8! * result = 1 - x^2/2! + x^4/4! - x^6/6! + x^8/8!
* To save multiplications and to keep the precision high, it's performed * To save multiplications and to keep the precision high, it's performed
* like this: * like this:
* result = 1 - x^2 * (1/2! - x^2 * (1/4! - x^2 * (1/6! - x^2 * (1/8!)))) * result = 1 - x^2 * (1/2! - x^2 * (1/4! - x^2 * (1/6! - x^2 * (1/8!))))
*/ */
/* Start with 0, compiler will optimize this away */ /* Start with 0, compiler will optimize this away */
result = 0; result = 0;
#if (PRECISION >= 10) #if (PRECISION >= 10)
result += 1./(1.*2*3*4*5*6*7*8*9*10*11*12*13*14*15*16*17*18*19*20); result += 1./(1.*2*3*4*5*6*7*8*9*10*11*12*13*14*15*16*17*18*19*20);
result *= x2; result *= x2;
#endif #endif
#if (PRECISION >= 9) #if (PRECISION >= 9)
result += 1./(1.*2*3*4*5*6*7*8*9*10*11*12*13*14*15*16*17*18); result += 1./(1.*2*3*4*5*6*7*8*9*10*11*12*13*14*15*16*17*18);
result *= x2; result *= x2;
#endif #endif
#if (PRECISION >= 8) #if (PRECISION >= 8)
result += 1./(1.*2*3*4*5*6*7*8*9*10*11*12*13*14*15*16); result += 1./(1.*2*3*4*5*6*7*8*9*10*11*12*13*14*15*16);
result *= x2; result *= x2;
#endif #endif
#if (PRECISION >= 7) #if (PRECISION >= 7)
result += 1./(1.*2*3*4*5*6*7*8*9*10*11*12*13*14); result += 1./(1.*2*3*4*5*6*7*8*9*10*11*12*13*14);
result *= x2; result *= x2;
#endif #endif
#if (PRECISION >= 6) #if (PRECISION >= 6)
result += 1./(1.*2*3*4*5*6*7*8*9*10*11*12); result += 1./(1.*2*3*4*5*6*7*8*9*10*11*12);
result *= x2; result *= x2;
#endif #endif
#if (PRECISION >= 5) #if (PRECISION >= 5)
result += 1./(1.*2*3*4*5*6*7*8*9*10); result += 1./(1.*2*3*4*5*6*7*8*9*10);
result *= x2; result *= x2;
#endif #endif
result += 1./(1.*2*3*4*5*6*7*8); result += 1./(1.*2*3*4*5*6*7*8);
result *= x2; result *= x2;
result += 1./(1.*2*3*4*5*6); result += 1./(1.*2*3*4*5*6);
result *= x2; result *= x2;
result += 1./(1.*2*3*4); result += 1./(1.*2*3*4);
result *= x2; result *= x2;
result += 1./(1.*2); result += 1./(1.*2);
result *= x2; result *= x2;
result += 1; result += 1;
/* Apply correct sign */ /* Apply correct sign */
result *= sin_sign_tbl[quadrant]; result *= sin_sign_tbl[quadrant];
return result; return result;
} }
double cos(double x) double cos(double x)
{ {
int quadrant; int quadrant;
double x2, result; double x2, result;
/* Calculate the quadrant */ /* Calculate the quadrant */
quadrant = x * (2./M_PI); quadrant = x * (2./M_PI);
/* Get offset inside quadrant */ /* Get offset inside quadrant */
x = x - quadrant * (M_PI/2.); x = x - quadrant * (M_PI/2.);
/* Normalize quadrant to [0..3] */ /* Normalize quadrant to [0..3] */
quadrant = quadrant & 0x3; quadrant = quadrant & 0x3;
/* Fixup value for the generic function */ /* Fixup value for the generic function */
x += cos_off_tbl[quadrant]; x += cos_off_tbl[quadrant];
/* Calculate the negative of the square of x */ /* Calculate the negative of the square of x */
x2 = - (x * x); x2 = - (x * x);
/* This is an unrolled taylor series using <PRECISION> iterations /* This is an unrolled taylor series using <PRECISION> iterations
* Example with 4 iterations: * Example with 4 iterations:
* result = 1 - x^2/2! + x^4/4! - x^6/6! + x^8/8! * result = 1 - x^2/2! + x^4/4! - x^6/6! + x^8/8!
* To save multiplications and to keep the precision high, it's performed * To save multiplications and to keep the precision high, it's performed
* like this: * like this:
* result = 1 - x^2 * (1/2! - x^2 * (1/4! - x^2 * (1/6! - x^2 * (1/8!)))) * result = 1 - x^2 * (1/2! - x^2 * (1/4! - x^2 * (1/6! - x^2 * (1/8!))))
*/ */
/* Start with 0, compiler will optimize this away */ /* Start with 0, compiler will optimize this away */
result = 0; result = 0;
#if (PRECISION >= 10) #if (PRECISION >= 10)
result += 1./(1.*2*3*4*5*6*7*8*9*10*11*12*13*14*15*16*17*18*19*20); result += 1./(1.*2*3*4*5*6*7*8*9*10*11*12*13*14*15*16*17*18*19*20);
result *= x2; result *= x2;
#endif #endif
#if (PRECISION >= 9) #if (PRECISION >= 9)
result += 1./(1.*2*3*4*5*6*7*8*9*10*11*12*13*14*15*16*17*18); result += 1./(1.*2*3*4*5*6*7*8*9*10*11*12*13*14*15*16*17*18);
result *= x2; result *= x2;
#endif #endif
#if (PRECISION >= 8) #if (PRECISION >= 8)
result += 1./(1.*2*3*4*5*6*7*8*9*10*11*12*13*14*15*16); result += 1./(1.*2*3*4*5*6*7*8*9*10*11*12*13*14*15*16);
result *= x2; result *= x2;
#endif #endif
#if (PRECISION >= 7) #if (PRECISION >= 7)
result += 1./(1.*2*3*4*5*6*7*8*9*10*11*12*13*14); result += 1./(1.*2*3*4*5*6*7*8*9*10*11*12*13*14);
result *= x2; result *= x2;
#endif #endif
#if (PRECISION >= 6) #if (PRECISION >= 6)
result += 1./(1.*2*3*4*5*6*7*8*9*10*11*12); result += 1./(1.*2*3*4*5*6*7*8*9*10*11*12);
result *= x2; result *= x2;
#endif #endif
#if (PRECISION >= 5) #if (PRECISION >= 5)
result += 1./(1.*2*3*4*5*6*7*8*9*10); result += 1./(1.*2*3*4*5*6*7*8*9*10);
result *= x2; result *= x2;
#endif #endif
result += 1./(1.*2*3*4*5*6*7*8); result += 1./(1.*2*3*4*5*6*7*8);
result *= x2; result *= x2;
result += 1./(1.*2*3*4*5*6); result += 1./(1.*2*3*4*5*6);
result *= x2; result *= x2;
result += 1./(1.*2*3*4); result += 1./(1.*2*3*4);
result *= x2; result *= x2;
result += 1./(1.*2); result += 1./(1.*2);
result *= x2; result *= x2;
result += 1; result += 1;
/* Apply correct sign */ /* Apply correct sign */
result *= cos_sign_tbl[quadrant]; result *= cos_sign_tbl[quadrant];
return result; return result;
} }
static const int N = 100; static const int N = 100;
double coef(int n) double coef(int n)
{ {
double t; double t;
if (n == 0) if (n == 0)
{ {
return 0; return 0;
} }
t = 1.0/n; t = 1.0/n;
if (n%2 == 0) if (n%2 == 0)
{ {
t = -t; t = -t;
} }
return t; return t;
} }
double horner(double x) double horner(double x)
{ {
double u = coef(N); double u = coef(N);
int i; int i;
for(i=N-1; i>=0; i--) for(i=N-1; i>=0; i--)
{ {
u = u*x + coef(i); u = u*x + coef(i);
} }
return u; return u;
} }
double sqrt(double b) double sqrt(double b)
{ {
double x = 1; double x = 1;
int step = 0; int step = 0;
while ((x*x-b<-0.000000000000001 || x*x-b>0.000000000000001) && step<50) while ((x*x-b<-0.000000000000001 || x*x-b>0.000000000000001) && step<50)
{ {
x = (b/x+x)/2.0; x = (b/x+x)/2.0;
step++; step++;
} }
return x; return x;
} }
double ln(double x) double ln(double x)
{ {
int i; int i;
if (x > 1.5) if (x > 1.5)
{ {
for(i=0; x>1.25; i++) for(i=0; x>1.25; i++)
{ {
x = sqrt(x); x = sqrt(x);
} }
return (1<<i)*horner(x-1); return (1<<i)*horner(x-1);
} }
else if (x<0.7 && x>0) else if (x<0.7 && x>0)
{ {
for(i=0; x<0.7; i++) for(i=0; x<0.7; i++)
{ {
x = sqrt(x); x = sqrt(x);
} }
return (1<<i)*horner(x-1); return (1<<i)*horner(x-1);
} }
else if(x > 0) else if(x > 0)
{ {
return horner(x-1); return horner(x-1);
} }
} }
double exp(double x) double exp(double x)
{ {
double sum = 1; double sum = 1;
int i; int i;
for(i=N; i>0; i--) for(i=N; i>0; i--)
{ {
sum /= i; sum /= i;
sum *= x; sum *= x;
sum += 1; sum += 1;
} }
return sum; return sum;
} }
double pow(double m, double n) double pow(double m, double n)
{ {
return exp(n*ln(m)); return exp(n*ln(m));
} }

670
components/libc/newlib/syscalls.c
View File

@ -1,335 +1,335 @@
#include <reent.h> #include <reent.h>
#include <sys/errno.h> #include <sys/errno.h>
#include <sys/time.h> #include <sys/time.h>
#include <rtthread.h> #include <rtthread.h>
/* Reentrant versions of system calls. */ /* Reentrant versions of system calls. */
int int
_close_r(struct _reent *ptr, int fd) _close_r(struct _reent *ptr, int fd)
{ {
return close(fd); return close(fd);
} }
int int
_execve_r(struct _reent *ptr, const char * name, char *const *argv, char *const *env) _execve_r(struct _reent *ptr, const char * name, char *const *argv, char *const *env)
{ {
/* return "not supported" */ /* return "not supported" */
ptr->_errno = ENOTSUP; ptr->_errno = ENOTSUP;
return -1; return -1;
} }
int int
_fcntl_r(struct _reent *ptr, int fd, int cmd, int arg) _fcntl_r(struct _reent *ptr, int fd, int cmd, int arg)
{ {
/* return "not supported" */ /* return "not supported" */
ptr->_errno = ENOTSUP; ptr->_errno = ENOTSUP;
return -1; return -1;
} }
int int
_fork_r(struct _reent *ptr) _fork_r(struct _reent *ptr)
{ {
/* return "not supported" */ /* return "not supported" */
ptr->_errno = ENOTSUP; ptr->_errno = ENOTSUP;
return -1; return -1;
} }
int int
_fstat_r(struct _reent *ptr, int fd, struct stat *pstat) _fstat_r(struct _reent *ptr, int fd, struct stat *pstat)
{ {
/* return "not supported" */ /* return "not supported" */
ptr->_errno = ENOTSUP; ptr->_errno = ENOTSUP;
return -1; return -1;
} }
int int
_getpid_r(struct _reent *ptr) _getpid_r(struct _reent *ptr)
{ {
return 0; return 0;
} }
int int
_isatty_r(struct _reent *ptr, int fd) _isatty_r(struct _reent *ptr, int fd)
{ {
if (fd >=0 && fd < 3) return 1; if (fd >=0 && fd < 3) return 1;
/* return "not supported" */ /* return "not supported" */
ptr->_errno = ENOTSUP; ptr->_errno = ENOTSUP;
return -1; return -1;
} }
int int
_kill_r(struct _reent *ptr, int pid, int sig) _kill_r(struct _reent *ptr, int pid, int sig)
{ {
/* return "not supported" */ /* return "not supported" */
ptr->_errno = ENOTSUP; ptr->_errno = ENOTSUP;
return -1; return -1;
} }
int int
_link_r(struct _reent *ptr, const char *old, const char *new) _link_r(struct _reent *ptr, const char *old, const char *new)
{ {
/* return "not supported" */ /* return "not supported" */
ptr->_errno = ENOTSUP; ptr->_errno = ENOTSUP;
return -1; return -1;
} }
_off_t _off_t
_lseek_r(struct _reent *ptr, int fd, _off_t pos, int whence) _lseek_r(struct _reent *ptr, int fd, _off_t pos, int whence)
{ {
_off_t rc; _off_t rc;
rc = lseek(fd, pos, whence); rc = lseek(fd, pos, whence);
return rc; return rc;
} }
int int
_mkdir_r(struct _reent *ptr, const char *name, int mode) _mkdir_r(struct _reent *ptr, const char *name, int mode)
{ {
int rc; int rc;
rc = mkdir(name, mode); rc = mkdir(name, mode);
return rc; return rc;
} }
int int
_open_r(struct _reent *ptr, const char *file, int flags, int mode) _open_r(struct _reent *ptr, const char *file, int flags, int mode)
{ {
int rc; int rc;
rc = open(file, flags, mode); rc = open(file, flags, mode);
return rc; return rc;
} }
_ssize_t _ssize_t
_read_r(struct _reent *ptr, int fd, void *buf, size_t nbytes) _read_r(struct _reent *ptr, int fd, void *buf, size_t nbytes)
{ {
_ssize_t rc; _ssize_t rc;
rc = read(fd, buf, nbytes); rc = read(fd, buf, nbytes);
return rc; return rc;
} }
int int
_rename_r(struct _reent *ptr, const char *old, const char *new) _rename_r(struct _reent *ptr, const char *old, const char *new)
{ {
int rc; int rc;
rc = rename(old, new); rc = rename(old, new);
return rc; return rc;
} }
void * void *
_sbrk_r(struct _reent *ptr, ptrdiff_t incr) _sbrk_r(struct _reent *ptr, ptrdiff_t incr)
{ {
/* no use this routine to get memory */ /* no use this routine to get memory */
return RT_NULL; return RT_NULL;
} }
int int
_stat_r(struct _reent *ptr, const char *file, struct stat *pstat) _stat_r(struct _reent *ptr, const char *file, struct stat *pstat)
{ {
int rc; int rc;
rc = stat(file, pstat); rc = stat(file, pstat);
return rc; return rc;
} }
_CLOCK_T_ _CLOCK_T_
_times_r(struct _reent *ptr, struct tms *ptms) _times_r(struct _reent *ptr, struct tms *ptms)
{ {
/* return "not supported" */ /* return "not supported" */
ptr->_errno = ENOTSUP; ptr->_errno = ENOTSUP;
return -1; return -1;
} }
int int
_unlink_r(struct _reent *ptr, const char *file) _unlink_r(struct _reent *ptr, const char *file)
{ {
int rc; int rc;
rc = unlink(file); rc = unlink(file);
return rc; return rc;
} }
int int
_wait_r(struct _reent *ptr, int *status) _wait_r(struct _reent *ptr, int *status)
{ {
/* return "not supported" */ /* return "not supported" */
ptr->_errno = ENOTSUP; ptr->_errno = ENOTSUP;
return -1; return -1;
} }
_ssize_t _ssize_t
_write_r(struct _reent *ptr, int fd, const void *buf, size_t nbytes) _write_r(struct _reent *ptr, int fd, const void *buf, size_t nbytes)
{ {
_ssize_t rc; _ssize_t rc;
rc = write(fd, buf, nbytes); rc = write(fd, buf, nbytes);
return rc; return rc;
} }
#ifndef RT_USING_PTHREADS #ifndef RT_USING_PTHREADS
#ifndef MILLISECOND_PER_SECOND #ifndef MILLISECOND_PER_SECOND
#define MILLISECOND_PER_SECOND 1000UL #define MILLISECOND_PER_SECOND 1000UL
#endif #endif
#ifndef MICROSECOND_PER_SECOND #ifndef MICROSECOND_PER_SECOND
#define MICROSECOND_PER_SECOND 1000000UL #define MICROSECOND_PER_SECOND 1000000UL
#endif #endif
#ifndef NANOSECOND_PER_SECOND #ifndef NANOSECOND_PER_SECOND
#define NANOSECOND_PER_SECOND 1000000000UL #define NANOSECOND_PER_SECOND 1000000000UL
#endif #endif
#define MILLISECOND_PER_TICK (MILLISECOND_PER_SECOND / RT_TICK_PER_SECOND) #define MILLISECOND_PER_TICK (MILLISECOND_PER_SECOND / RT_TICK_PER_SECOND)
#define MICROSECOND_PER_TICK (MICROSECOND_PER_SECOND / RT_TICK_PER_SECOND) #define MICROSECOND_PER_TICK (MICROSECOND_PER_SECOND / RT_TICK_PER_SECOND)
#define NANOSECOND_PER_TICK (NANOSECOND_PER_SECOND / RT_TICK_PER_SECOND) #define NANOSECOND_PER_TICK (NANOSECOND_PER_SECOND / RT_TICK_PER_SECOND)
struct timeval _timevalue = {0}; struct timeval _timevalue = {0};
static void libc_system_time_init() static void libc_system_time_init()
{ {
time_t time; time_t time;
rt_tick_t tick; rt_tick_t tick;
rt_device_t device; rt_device_t device;
time = 0; time = 0;
device = rt_device_find("rtc"); device = rt_device_find("rtc");
if (device != RT_NULL) if (device != RT_NULL)
{ {
/* get realtime seconds */ /* get realtime seconds */
rt_device_control(device, RT_DEVICE_CTRL_RTC_GET_TIME, &time); rt_device_control(device, RT_DEVICE_CTRL_RTC_GET_TIME, &time);
} }
/* get tick */ /* get tick */
tick = rt_tick_get(); tick = rt_tick_get();
_timevalue.tv_usec = MICROSECOND_PER_SECOND - (tick%RT_TICK_PER_SECOND) * MICROSECOND_PER_TICK; _timevalue.tv_usec = MICROSECOND_PER_SECOND - (tick%RT_TICK_PER_SECOND) * MICROSECOND_PER_TICK;
_timevalue.tv_sec = time - tick/RT_TICK_PER_SECOND - 1; _timevalue.tv_sec = time - tick/RT_TICK_PER_SECOND - 1;
} }
int libc_get_time(struct timespec *time) int libc_get_time(struct timespec *time)
{ {
rt_tick_t tick; rt_tick_t tick;
static rt_bool_t inited = 0; static rt_bool_t inited = 0;
RT_ASSERT(time != RT_NULL); RT_ASSERT(time != RT_NULL);
/* initialize system time */ /* initialize system time */
if (inited == 0) if (inited == 0)
{ {
libc_system_time_init(); libc_system_time_init();
inited = 1; inited = 1;
} }
/* get tick */ /* get tick */
tick = rt_tick_get(); tick = rt_tick_get();
time->tv_sec = _timevalue.tv_sec + tick / RT_TICK_PER_SECOND; time->tv_sec = _timevalue.tv_sec + tick / RT_TICK_PER_SECOND;
time->tv_nsec = (_timevalue.tv_usec + (tick % RT_TICK_PER_SECOND) * NANOSECOND_PER_TICK) * 1000; time->tv_nsec = (_timevalue.tv_usec + (tick % RT_TICK_PER_SECOND) * NANOSECOND_PER_TICK) * 1000;
return 0; return 0;
} }
int int
_gettimeofday_r(struct _reent *ptr, struct timeval *__tp, void *__tzp) _gettimeofday_r(struct _reent *ptr, struct timeval *__tp, void *__tzp)
{ {
struct timespec tp; struct timespec tp;
if (libc_get_time(&tp) == 0) if (libc_get_time(&tp) == 0)
{ {
if (__tp != RT_NULL) if (__tp != RT_NULL)
{ {
__tp->tv_sec = tp.tv_sec; __tp->tv_sec = tp.tv_sec;
__tp->tv_usec = tp.tv_nsec * 1000UL; __tp->tv_usec = tp.tv_nsec * 1000UL;
} }
return tp.tv_sec; return tp.tv_sec;
} }
/* return "not supported" */ /* return "not supported" */
ptr->_errno = ENOTSUP; ptr->_errno = ENOTSUP;
return -1; return -1;
} }
#else #else
/* POSIX thread provides clock_gettime function */ /* POSIX thread provides clock_gettime function */
#include <time.h> #include <time.h>
int int
_gettimeofday_r(struct _reent *ptr, struct timeval *__tp, void *__tzp) _gettimeofday_r(struct _reent *ptr, struct timeval *__tp, void *__tzp)
{ {
struct timespec tp; struct timespec tp;
if (clock_gettime(CLOCK_REALTIME, &tp) == 0) if (clock_gettime(CLOCK_REALTIME, &tp) == 0)
{ {
if (__tp != RT_NULL) if (__tp != RT_NULL)
{ {
__tp->tv_sec = tp.tv_sec; __tp->tv_sec = tp.tv_sec;
__tp->tv_usec = tp.tv_nsec * 1000UL; __tp->tv_usec = tp.tv_nsec * 1000UL;
} }
return tp.tv_sec; return tp.tv_sec;
} }
/* return "not supported" */ /* return "not supported" */
ptr->_errno = ENOTSUP; ptr->_errno = ENOTSUP;
return -1; return -1;
} }
#endif #endif
/* Memory routine */ /* Memory routine */
void * void *
_malloc_r (struct _reent *ptr, size_t size) _malloc_r (struct _reent *ptr, size_t size)
{ {
void* result; void* result;
result = (void*)rt_malloc (size); result = (void*)rt_malloc (size);
if (result == RT_NULL) if (result == RT_NULL)
{ {
ptr->_errno = ENOMEM; ptr->_errno = ENOMEM;
} }
return result; return result;
} }
void * void *
_realloc_r (struct _reent *ptr, void *old, size_t newlen) _realloc_r (struct _reent *ptr, void *old, size_t newlen)
{ {
void* result; void* result;
result = (void*)rt_realloc (old, newlen); result = (void*)rt_realloc (old, newlen);
if (result == RT_NULL) if (result == RT_NULL)
{ {
ptr->_errno = ENOMEM; ptr->_errno = ENOMEM;
} }
return result; return result;
} }
void *_calloc_r (struct _reent *ptr, size_t size, size_t len) void *_calloc_r (struct _reent *ptr, size_t size, size_t len)
{ {
void* result; void* result;
result = (void*)rt_calloc (size, len); result = (void*)rt_calloc (size, len);
if (result == RT_NULL) if (result == RT_NULL)
{ {
ptr->_errno = ENOMEM; ptr->_errno = ENOMEM;
} }
return result; return result;
} }
void void
_free_r (struct _reent *ptr, void *addr) _free_r (struct _reent *ptr, void *addr)
{ {
rt_free (addr); rt_free (addr);
} }
void void
_exit (int status) _exit (int status)
{ {
rt_kprintf("thread:%s exit with %d\n", rt_thread_self()->name, status); rt_kprintf("thread:%s exit with %d\n", rt_thread_self()->name, status);
RT_ASSERT(0); RT_ASSERT(0);
} }