andy/player
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

初始提交

Browse Source
This commit is contained in:
andy
2025-06-27 00:32:57 +08:00
commit e40bb2ba8a
5134 changed files with 2158460 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
Project/Src/rt-thread/components/libc/compilers/newlib/SConscript Normal file
View File

@@ -0,0 +1,21 @@
from building import *
Import('rtconfig')
src = Glob('*.c')
cwd = GetCurrentDir()
group = []
CPPPATH = [cwd]
CPPDEFINES = ['RT_USING_NEWLIB']
# link with libc and libm:
# libm is a frequently used lib. Newlib is compiled with -ffunction-sections in
# recent GCC tool chains. The linker would just link in the functions that have
# been referenced. So setting this won't result in bigger text size.
LIBS = ['c', 'm']
if rtconfig.PLATFORM == 'gcc':
group = DefineGroup('newlib', src, depend = ['RT_USING_LIBC'],
CPPPATH = CPPPATH, CPPDEFINES = CPPDEFINES, LIBS = LIBS)
Return('group')

50
Project/Src/rt-thread/components/libc/compilers/newlib/libc.c Normal file
View File

@@ -0,0 +1,50 @@
/*
* Copyright (c) 2006-2018, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
* 2017/10/15 bernard the first version
*/
#include <rtthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/time.h>
#include "libc.h"
#ifdef RT_USING_PTHREADS
#include <pthread.h>
#endif
int _EXFUN(putenv,(char *__string));
int libc_system_init(void)
{
#if defined(RT_USING_DFS) & defined(RT_USING_DFS_DEVFS) & defined(RT_USING_CONSOLE)
rt_device_t dev_console;
dev_console = rt_console_get_device();
if (dev_console)
{
#if defined(RT_USING_POSIX)
libc_stdio_set_console(dev_console->parent.name, O_RDWR);
#else
libc_stdio_set_console(dev_console->parent.name, O_WRONLY);
#endif
}
/* set PATH and HOME */
putenv("PATH=/bin");
putenv("HOME=/home");
#endif
#if defined RT_USING_PTHREADS && !defined RT_USING_COMPONENTS_INIT
pthread_system_init();
#endif
return 0;
}
INIT_COMPONENT_EXPORT(libc_system_init);

39
Project/Src/rt-thread/components/libc/compilers/newlib/libc.h Normal file
View File

@@ -0,0 +1,39 @@
/*
* Copyright (c) 2006-2018, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
* 2017/10/15 bernard the first version
*/
#ifndef __RTT_LIBC_H__
#define __RTT_LIBC_H__
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <sys/time.h>
#ifndef _EXFUN
#define _EXFUN(name, proto) name proto
#endif
#define MILLISECOND_PER_SECOND 1000UL
#define MICROSECOND_PER_SECOND 1000000UL
#define NANOSECOND_PER_SECOND 1000000000UL
#define MILLISECOND_PER_TICK (MILLISECOND_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)
int libc_system_init(void);
int libc_stdio_set_console(const char* device_name, int mode);
int libc_stdio_get_console(void);
/* some time related function */
int libc_set_time(const struct timespec *time);
int libc_get_time(struct timespec *time);
int libc_time_to_tick(const struct timespec *time);
#endif

56
Project/Src/rt-thread/components/libc/compilers/newlib/libc_syms.c Normal file
View File

@@ -0,0 +1,56 @@
/*
* Copyright (c) 2006-2018, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
* 2017/10/15 bernard the first version
*/
#include <rtthread.h>
#include <rtm.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
RTM_EXPORT(strcpy);
RTM_EXPORT(strncpy);
RTM_EXPORT(strlen);
RTM_EXPORT(strcat);
RTM_EXPORT(strstr);
RTM_EXPORT(strchr);
RTM_EXPORT(strcmp);
RTM_EXPORT(strtol);
RTM_EXPORT(strtoul);
RTM_EXPORT(strncmp);
RTM_EXPORT(memcpy);
RTM_EXPORT(memcmp);
RTM_EXPORT(memmove);
RTM_EXPORT(memset);
RTM_EXPORT(memchr);
RTM_EXPORT(putchar);
RTM_EXPORT(puts);
RTM_EXPORT(printf);
RTM_EXPORT(sprintf);
RTM_EXPORT(snprintf);
RTM_EXPORT(fwrite);
#include <time.h>
RTM_EXPORT(localtime);
RTM_EXPORT(time);
#include <setjmp.h>
RTM_EXPORT(longjmp);
RTM_EXPORT(setjmp);
RTM_EXPORT(exit);
RTM_EXPORT(abort);
RTM_EXPORT(rand);
#include <assert.h>
RTM_EXPORT(__assert_func);

80
Project/Src/rt-thread/components/libc/compilers/newlib/stdio.c Normal file
View File

@@ -0,0 +1,80 @@
/*
* Copyright (c) 2006-2018, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
* 2017/10/15 bernard the first version
*/
#include <stdio.h>
#include <stdlib.h>
#include <rtthread.h>
#include "libc.h"
#define STDIO_DEVICE_NAME_MAX 32
int _EXFUN(fileno, (FILE *));
static FILE* std_console = NULL;
int libc_stdio_set_console(const char* device_name, int mode)
{
FILE *fp;
char name[STDIO_DEVICE_NAME_MAX];
char *file_mode;
snprintf(name, sizeof(name) - 1, "/dev/%s", device_name);
name[STDIO_DEVICE_NAME_MAX - 1] = '\0';
if (mode == O_RDWR) file_mode = "r+";
else if (mode == O_WRONLY) file_mode = "wb";
else file_mode = "rb";
fp = fopen(name, file_mode);
if (fp)
{
setvbuf(fp, NULL, _IONBF, 0);
if (std_console)
{
fclose(std_console);
std_console = NULL;
}
std_console = fp;
if (mode == O_RDWR)
{
_GLOBAL_REENT->_stdin = std_console;
}
else
{
_GLOBAL_REENT->_stdin = NULL;
}
if (mode == O_RDONLY)
{
_GLOBAL_REENT->_stdout = NULL;
_GLOBAL_REENT->_stderr = NULL;
}
else
{
_GLOBAL_REENT->_stdout = std_console;
_GLOBAL_REENT->_stderr = std_console;
}
_GLOBAL_REENT->__sdidinit = 1;
}
if (std_console) return fileno(std_console);
return -1;
}
int libc_stdio_get_console(void) {
if (std_console)
return fileno(std_console);
else
return -1;
}

65
Project/Src/rt-thread/components/libc/compilers/newlib/sys/dirent.h Normal file
View File

@@ -0,0 +1,65 @@
/*
* Copyright (c) 2006-2018, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
*/
#ifndef __RTT_DIRENT_H__
#define __RTT_DIRENT_H__
#include <rtthread.h>
/*
* dirent.h - format of directory entries
* Ref: http://www.opengroup.org/onlinepubs/009695399/basedefs/dirent.h.html
*/
/* File types */
#define FT_REGULAR 0 /* regular file */
#define FT_SOCKET 1 /* socket file */
#define FT_DIRECTORY 2 /* directory */
#define FT_USER 3 /* user defined */
#define DT_UNKNOWN 0x00
#define DT_REG 0x01
#define DT_DIR 0x02
#ifdef __cplusplus
extern "C" {
#endif
#ifndef HAVE_DIR_STRUCTURE
typedef struct
{
int fd; /* directory file */
char buf[512];
int num;
int cur;
} DIR;
#endif
#ifndef HAVE_DIRENT_STRUCTURE
struct dirent
{
rt_uint8_t d_type; /* The type of the file */
rt_uint8_t d_namlen; /* The length of the not including the terminating null file name */
rt_uint16_t d_reclen; /* length of this record */
char d_name[256]; /* The null-terminated file name */
};
#endif
int closedir(DIR *);
DIR *opendir(const char *);
struct dirent *readdir(DIR *);
int readdir_r(DIR *, struct dirent *, struct dirent **);
void rewinddir(DIR *);
void seekdir(DIR *, long int);
long telldir(DIR *);
#ifdef __cplusplus
}
#endif
#endif

58
Project/Src/rt-thread/components/libc/compilers/newlib/sys/mman.h Normal file
View File

@@ -0,0 +1,58 @@
/*
* Copyright (c) 2006-2018, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
* 2017/11/30 Bernard The first version.
*/
#ifndef _SYS_MMAN_H
#define _SYS_MMAN_H
#ifdef __cplusplus
extern "C" {
#endif
#define MAP_FAILED ((void *) -1)
#define MAP_SHARED 0x01
#define MAP_PRIVATE 0x02
#define MAP_TYPE 0x0f
#define MAP_FIXED 0x10
#define MAP_ANON 0x20
#define MAP_ANONYMOUS MAP_ANON
#define MAP_NORESERVE 0x4000
#define MAP_GROWSDOWN 0x0100
#define MAP_DENYWRITE 0x0800
#define MAP_EXECUTABLE 0x1000
#define MAP_LOCKED 0x2000
#define MAP_POPULATE 0x8000
#define MAP_NONBLOCK 0x10000
#define MAP_STACK 0x20000
#define MAP_HUGETLB 0x40000
#define MAP_FILE 0
#define PROT_NONE 0
#define PROT_READ 1
#define PROT_WRITE 2
#define PROT_EXEC 4
#define PROT_GROWSDOWN 0x01000000
#define PROT_GROWSUP 0x02000000
#define MS_ASYNC 1
#define MS_INVALIDATE 2
#define MS_SYNC 4
#define MCL_CURRENT 1
#define MCL_FUTURE 2
#define MCL_ONFAULT 4
void *mmap (void *start, size_t len, int prot, int flags, int fd, off_t off);
int munmap (void *start, size_t len);
#ifdef __cplusplus
}
#endif
#endif

21
Project/Src/rt-thread/components/libc/compilers/newlib/sys/statfs.h Normal file
View File

@@ -0,0 +1,21 @@
/*
* Copyright (c) 2006-2018, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
*/
#ifndef __RTT_STATFS_H__
#define __RTT_STATFS_H__
#include <rtthread.h>
struct statfs
{
rt_size_t f_bsize; /* block size */
rt_size_t f_blocks; /* total data blocks in file system */
rt_size_t f_bfree; /* free blocks in file system */
};
#endif

8
Project/Src/rt-thread/components/libc/compilers/newlib/sys/termios.h Normal file
View File

@@ -0,0 +1,8 @@
/*
* Copyright (c) 2006-2018, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
*/

436
Project/Src/rt-thread/components/libc/compilers/newlib/syscalls.c Normal file
View File

@@ -0,0 +1,436 @@
/*
* Copyright (c) 2006-2018, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
*/
#include <reent.h>
#include <sys/errno.h>
#include <sys/time.h>
#include <stdio.h>
#include <rtthread.h>
#ifdef RT_USING_DFS
#include <dfs_posix.h>
#endif
#ifdef RT_USING_PTHREADS
#include <pthread.h>
#endif
#ifdef RT_USING_MODULE
#include <dlmodule.h>
#endif
/* Reentrant versions of system calls. */
int
_close_r(struct _reent *ptr, int fd)
{
#ifndef RT_USING_DFS
return 0;
#else
return close(fd);
#endif
}
int
_execve_r(struct _reent *ptr, const char * name, char *const *argv, char *const *env)
{
/* return "not supported" */
ptr->_errno = ENOTSUP;
return -1;
}
int
_fcntl_r(struct _reent *ptr, int fd, int cmd, int arg)
{
/* return "not supported" */
ptr->_errno = ENOTSUP;
return -1;
}
int
_fork_r(struct _reent *ptr)
{
/* return "not supported" */
ptr->_errno = ENOTSUP;
return -1;
}
int
_fstat_r(struct _reent *ptr, int fd, struct stat *pstat)
{
/* return "not supported" */
ptr->_errno = ENOTSUP;
return -1;
}
int
_getpid_r(struct _reent *ptr)
{
return 0;
}
int
_isatty_r(struct _reent *ptr, int fd)
{
if (fd >=0 && fd < 3) return 1;
/* return "not supported" */
ptr->_errno = ENOTSUP;
return -1;
}
int
_kill_r(struct _reent *ptr, int pid, int sig)
{
/* return "not supported" */
ptr->_errno = ENOTSUP;
return -1;
}
int
_link_r(struct _reent *ptr, const char *old, const char *new)
{
/* return "not supported" */
ptr->_errno = ENOTSUP;
return -1;
}
_off_t
_lseek_r(struct _reent *ptr, int fd, _off_t pos, int whence)
{
#ifndef RT_USING_DFS
return 0;
#else
_off_t rc;
rc = lseek(fd, pos, whence);
return rc;
#endif
}
int
_mkdir_r(struct _reent *ptr, const char *name, int mode)
{
#ifndef RT_USING_DFS
return 0;
#else
int rc;
rc = mkdir(name, mode);
return rc;
#endif
}
int
_open_r(struct _reent *ptr, const char *file, int flags, int mode)
{
#ifndef RT_USING_DFS
return 0;
#else
int rc;
rc = open(file, flags, mode);
return rc;
#endif
}
_ssize_t
_read_r(struct _reent *ptr, int fd, void *buf, size_t nbytes)
{
#ifndef RT_USING_DFS
return 0;
#else
_ssize_t rc;
rc = read(fd, buf, nbytes);
return rc;
#endif
}
int
_rename_r(struct _reent *ptr, const char *old, const char *new)
{
#ifndef RT_USING_DFS
return 0;
#else
int rc;
rc = rename(old, new);
return rc;
#endif
}
void *
_sbrk_r(struct _reent *ptr, ptrdiff_t incr)
{
/* no use this routine to get memory */
return RT_NULL;
}
int
_stat_r(struct _reent *ptr, const char *file, struct stat *pstat)
{
#ifndef RT_USING_DFS
return 0;
#else
int rc;
rc = stat(file, pstat);
return rc;
#endif
}
_CLOCK_T_
_times_r(struct _reent *ptr, struct tms *ptms)
{
/* return "not supported" */
ptr->_errno = ENOTSUP;
return -1;
}
int
_unlink_r(struct _reent *ptr, const char *file)
{
#ifndef RT_USING_DFS
return 0;
#else
int rc;
rc = unlink(file);
return rc;
#endif
}
int
_wait_r(struct _reent *ptr, int *status)
{
/* return "not supported" */
ptr->_errno = ENOTSUP;
return -1;
}
#ifdef RT_USING_DEVICE
_ssize_t
_write_r(struct _reent *ptr, int fd, const void *buf, size_t nbytes)
{
#ifndef RT_USING_DFS
if (fileno(stdout) == fd)
{
rt_device_t console;
console = rt_console_get_device();
if (console) return rt_device_write(console, -1, buf, nbytes);
}
return 0;
#else
_ssize_t rc;
rc = write(fd, buf, nbytes);
return rc;
#endif
}
#endif
#ifdef RT_USING_PTHREADS
#include <clock_time.h>
/* POSIX timer provides clock_gettime function */
#include <time.h>
int
_gettimeofday_r(struct _reent *ptr, struct timeval *__tp, void *__tzp)
{
struct timespec tp;
if (clock_gettime(CLOCK_REALTIME, &tp) == 0)
{
if (__tp != RT_NULL)
{
__tp->tv_sec = tp.tv_sec;
__tp->tv_usec = tp.tv_nsec / 1000UL;
}
return tp.tv_sec;
}
/* return "not supported" */
ptr->_errno = ENOTSUP;
return -1;
}
#else
#define MILLISECOND_PER_SECOND 1000UL
#define MICROSECOND_PER_SECOND 1000000UL
#define NANOSECOND_PER_SECOND 1000000000UL
#define MILLISECOND_PER_TICK (MILLISECOND_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)
struct timeval _timevalue = {0};
#ifdef RT_USING_DEVICE
static void libc_system_time_init(void)
{
time_t time;
rt_tick_t tick;
rt_device_t device;
time = 0;
device = rt_device_find("rtc");
if (device != RT_NULL)
{
/* get realtime seconds */
rt_device_control(device, RT_DEVICE_CTRL_RTC_GET_TIME, &time);
}
/* get tick */
tick = rt_tick_get();
_timevalue.tv_usec = MICROSECOND_PER_SECOND - (tick%RT_TICK_PER_SECOND) * MICROSECOND_PER_TICK;
_timevalue.tv_sec = time - tick/RT_TICK_PER_SECOND - 1;
}
#endif
int libc_get_time(struct timespec *time)
{
rt_tick_t tick;
static rt_bool_t inited = 0;
RT_ASSERT(time != RT_NULL);
/* initialize system time */
if (inited == 0)
{
libc_system_time_init();
inited = 1;
}
/* get tick */
tick = rt_tick_get();
time->tv_sec = _timevalue.tv_sec + tick / RT_TICK_PER_SECOND;
time->tv_nsec = (_timevalue.tv_usec + (tick % RT_TICK_PER_SECOND) * MICROSECOND_PER_TICK) * 1000;
return 0;
}
int
_gettimeofday_r(struct _reent *ptr, struct timeval *__tp, void *__tzp)
{
struct timespec tp;
if (libc_get_time(&tp) == 0)
{
if (__tp != RT_NULL)
{
__tp->tv_sec = tp.tv_sec;
__tp->tv_usec = tp.tv_nsec / 1000UL;
}
return tp.tv_sec;
}
/* return "not supported" */
ptr->_errno = ENOTSUP;
return -1;
}
#endif
/* Memory routine */
void *
_malloc_r (struct _reent *ptr, size_t size)
{
void* result;
result = (void*)rt_malloc (size);
if (result == RT_NULL)
{
ptr->_errno = ENOMEM;
}
return result;
}
void *
_realloc_r (struct _reent *ptr, void *old, size_t newlen)
{
void* result;
result = (void*)rt_realloc (old, newlen);
if (result == RT_NULL)
{
ptr->_errno = ENOMEM;
}
return result;
}
void *_calloc_r (struct _reent *ptr, size_t size, size_t len)
{
void* result;
result = (void*)rt_calloc (size, len);
if (result == RT_NULL)
{
ptr->_errno = ENOMEM;
}
return result;
}
void
_free_r (struct _reent *ptr, void *addr)
{
rt_free (addr);
}
void
exit (int status)
{
#ifdef RT_USING_MODULE
if (dlmodule_self())
{
dlmodule_exit(status);
}
#endif
rt_kprintf("thread:%s exit with %d\n", rt_thread_self()->name, status);
RT_ASSERT(0);
while (1);
}
void
_system(const char *s)
{
/* not support this call */
return;
}
void __libc_init_array(void)
{
/* we not use __libc init_aray to initialize C++ objects */
}
void abort(void)
{
if (rt_thread_self())
{
rt_thread_t self = rt_thread_self();
rt_kprintf("thread:%-8.*s abort!\n", RT_NAME_MAX, self->name);
rt_thread_suspend(self);
rt_schedule();
}
while (1);
}

15
Project/Src/rt-thread/components/libc/compilers/newlib/termios.h Normal file
View File

@@ -0,0 +1,15 @@
/*
* Copyright (c) 2006-2018, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
*/
#ifndef _TERMIOS_H__
#define _TERMIOS_H__
#include <sys/types.h>
#include <posix_termios.h>
#endif

85
Project/Src/rt-thread/components/libc/compilers/newlib/time.c Normal file
View File

@@ -0,0 +1,85 @@
/*
* Copyright (c) 2006-2018, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
*/
#include <sys/time.h>
#include <rtthread.h>
#ifdef RT_USING_DEVICE
int gettimeofday(struct timeval *tp, void *ignore)
{
time_t time;
rt_device_t device;
device = rt_device_find("rtc");
if (device != RT_NULL)
{
rt_device_control(device, RT_DEVICE_CTRL_RTC_GET_TIME, &time);
if (tp != RT_NULL)
{
tp->tv_sec = time;
tp->tv_usec = 0;
}
return time;
}
return 0;
}
#endif
/**
* Returns the current time.
*
* @param time_t * t the timestamp pointer, if not used, keep NULL.
*
* @return time_t return timestamp current.
*
*/
/* for IAR 6.2 later Compiler */
#if defined (__IAR_SYSTEMS_ICC__) && (__VER__) >= 6020000
#pragma module_name = "?time"
time_t (__time32)(time_t *t) /* Only supports 32-bit timestamp */
#else
time_t time(time_t *t)
#endif
{
time_t time_now = 0;
#ifdef RT_USING_RTC
static rt_device_t device = RT_NULL;
/* optimization: find rtc device only first. */
if (device == RT_NULL)
{
device = rt_device_find("rtc");
}
/* read timestamp from RTC device. */
if (device != RT_NULL)
{
if (rt_device_open(device, 0) == RT_EOK)
{
rt_device_control(device, RT_DEVICE_CTRL_RTC_GET_TIME, &time_now);
rt_device_close(device);
}
}
#endif /* RT_USING_RTC */
/* if t is not NULL, write timestamp to *t */
if (t != RT_NULL)
{
*t = time_now;
}
return time_now;
}
RT_WEAK clock_t clock(void)
{
return rt_tick_get();
}