From 1ccb57b9f87f928da88ebc75f1e89cb5169cb093 Mon Sep 17 00:00:00 2001 From: zzulilyw <378305181@qq.com> Date: Sat, 28 Oct 2023 17:44:04 +0800 Subject: [PATCH] Add new libc-ndk interface Issue: https://gitee.com/openharmony/interface_sdk_c/issues/I869YN Test:Build & Boot devices & xts Signed-off-by: zzulilyw <378305181@qq.com> --- third_party/musl/ndk_musl_include/execinfo.h | 46 + third_party/musl/ndk_musl_include/stdlib.h | 4 + third_party/musl/ndk_musl_include/sys/cdefs.h | 82 ++ third_party/musl/ndk_musl_include/sys/mman.h | 3 + third_party/musl/ndk_musl_include/sys/queue.h | 880 ++++++++++++++++++ third_party/musl/ndk_musl_include/unistd.h | 1 + third_party/musl/ndk_musl_include/wordexp.h | 3 + third_party/musl/ndk_script/BUILD.gn | 761 +++++++-------- .../musl/ndk_script/adapter/libc.ndk.json | 11 + 9 files changed, 1411 insertions(+), 380 deletions(-) create mode 100644 third_party/musl/ndk_musl_include/execinfo.h create mode 100644 third_party/musl/ndk_musl_include/sys/cdefs.h create mode 100644 third_party/musl/ndk_musl_include/sys/queue.h diff --git a/third_party/musl/ndk_musl_include/execinfo.h b/third_party/musl/ndk_musl_include/execinfo.h new file mode 100644 index 0000000000..0b538f7c7c --- /dev/null +++ b/third_party/musl/ndk_musl_include/execinfo.h @@ -0,0 +1,46 @@ +/* $OpenBSD: execinfo.h,v 1.1 2021/06/09 19:37:43 mortimer Exp $ */ + +/*- + * Copyright (c) 2012 The NetBSD Foundation, Inc. + * All rights reserved. + * + * This code is derived from software contributed to The NetBSD Foundation + * by Christos Zoulas. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS + * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ +#ifndef _EXECINFO_H +#define _EXECINFO_H 1 + +#include +#ifdef __cplusplus +__BEGIN_EXTERN_C +#endif +int backtrace(void **, int); +char **backtrace_symbols(void *const *, int); +int backtrace_symbols_fd(void *const *, int, int); + +#ifdef __cplusplus +__END_EXTERN_C +#endif + +#endif /* execinfo.h */ diff --git a/third_party/musl/ndk_musl_include/stdlib.h b/third_party/musl/ndk_musl_include/stdlib.h index c27c12f0e2..2e6d495eda 100644 --- a/third_party/musl/ndk_musl_include/stdlib.h +++ b/third_party/musl/ndk_musl_include/stdlib.h @@ -73,6 +73,10 @@ int wctomb (char *, wchar_t); size_t mbstowcs (wchar_t *__restrict, const char *__restrict, size_t); size_t wcstombs (char *__restrict, const wchar_t *__restrict, size_t); +unsigned int arc4random(void); +unsigned int arc4random_uniform(unsigned int); +void arc4random_buf(void *, size_t); + #define EXIT_FAILURE 1 #define EXIT_SUCCESS 0 diff --git a/third_party/musl/ndk_musl_include/sys/cdefs.h b/third_party/musl/ndk_musl_include/sys/cdefs.h new file mode 100644 index 0000000000..4f7352c270 --- /dev/null +++ b/third_party/musl/ndk_musl_include/sys/cdefs.h @@ -0,0 +1,82 @@ +/* + * SPDX-License-Identifier: BSD-3-Clause + * + * Copyright (c) 1991, 1993 + * The Regents of the University of California. All rights reserved. + * + * This code is derived from software contributed to Berkeley by + * Berkeley Software Design, Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * @(#)cdefs.h 8.8 (Berkeley) 1/9/95 + */ + +#ifndef CDEFS_H +#define CDEFS_H + +#if defined(__cplusplus) +#define __BEGIN_EXTERN_C extern "C" { +#define __END_EXTERN_C } +#else +#define __BEGIN_EXTERN_C +#define __END_EXTERN_C +#endif + +#define __P(protos) protos /* full-blown ANSI C */ +#define __CONCAT(x,y) x ## y +#define __STRING(x) #x + +#define __aligned(x) __attribute__((__aligned__(x))) +#define __section(x) __attribute__((__section__(x))) + +#define __always_inline __attribute__((__always_inline__)) +#define __attribute_const__ __attribute__((__const__)) +#define __attribute_pure__ __attribute__((__pure__)) +#define __dead __attribute__((__noreturn__)) +#define __noreturn __attribute__((__noreturn__)) +#define __mallocfunc __attribute__((__malloc__)) +#define __packed __attribute__((__packed__)) +#define __returns_twice __attribute__((__returns_twice__)) +#define __unused __attribute__((__unused__)) +#define __used __attribute__((__used__)) + +#define __printflike(x, y) __attribute__((__format__(printf, x, y))) +#define __scanflike(x, y) __attribute__((__format__(scanf, x, y))) +#define __strftimelike(x) __attribute__((__format__(strftime, x, 0))) + + +#if defined(__cplusplus) +#define __CAST(_k,_t,_v) (_k<_t>(_v)) +#else +#define __CAST(_k,_t,_v) ((_t) (_v)) +#endif + +#define __ALIGN(value, alignment) (((value) + (alignment)-1) & ~((alignment)-1)) + +#define __GLOBL(sym) __asm__(".globl " __STRING(sym)) +#define __WEAK(sym) __asm__(".weak " __STRING(sym)) + +#endif \ No newline at end of file diff --git a/third_party/musl/ndk_musl_include/sys/mman.h b/third_party/musl/ndk_musl_include/sys/mman.h index c45451dc31..648d8104d1 100644 --- a/third_party/musl/ndk_musl_include/sys/mman.h +++ b/third_party/musl/ndk_musl_include/sys/mman.h @@ -136,6 +136,9 @@ int madvise (void *, size_t, int); int mincore (void *, size_t, unsigned char *); #endif +int shm_open (const char *, int, mode_t); +int shm_unlink (const char *); + #if defined(_LARGEFILE64_SOURCE) || defined(_GNU_SOURCE) #define mmap64 mmap #define off64_t off_t diff --git a/third_party/musl/ndk_musl_include/sys/queue.h b/third_party/musl/ndk_musl_include/sys/queue.h new file mode 100644 index 0000000000..ca45ef6e46 --- /dev/null +++ b/third_party/musl/ndk_musl_include/sys/queue.h @@ -0,0 +1,880 @@ +/*- + * SPDX-License-Identifier: BSD-3-Clause + * + * Copyright (c) 1991, 1993 + * The Regents of the University of California. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * @(#)queue.h 8.5 (Berkeley) 8/20/94 + * $FreeBSD$ + */ + +#ifndef _SYS_QUEUE_H_ +#define _SYS_QUEUE_H_ + +#include + +/* + * This file defines four types of data structures: singly-linked lists, + * singly-linked tail queues, lists and tail queues. + * + * A singly-linked list is headed by a single forward pointer. The elements + * are singly linked for minimum space and pointer manipulation overhead at + * the expense of O(n) removal for arbitrary elements. New elements can be + * added to the list after an existing element or at the head of the list. + * Elements being removed from the head of the list should use the explicit + * macro for this purpose for optimum efficiency. A singly-linked list may + * only be traversed in the forward direction. Singly-linked lists are ideal + * for applications with large datasets and few or no removals or for + * implementing a LIFO queue. + * + * A singly-linked tail queue is headed by a pair of pointers, one to the + * head of the list and the other to the tail of the list. The elements are + * singly linked for minimum space and pointer manipulation overhead at the + * expense of O(n) removal for arbitrary elements. New elements can be added + * to the list after an existing element, at the head of the list, or at the + * end of the list. Elements being removed from the head of the tail queue + * should use the explicit macro for this purpose for optimum efficiency. + * A singly-linked tail queue may only be traversed in the forward direction. + * Singly-linked tail queues are ideal for applications with large datasets + * and few or no removals or for implementing a FIFO queue. + * + * A list is headed by a single forward pointer (or an array of forward + * pointers for a hash table header). The elements are doubly linked + * so that an arbitrary element can be removed without a need to + * traverse the list. New elements can be added to the list before + * or after an existing element or at the head of the list. A list + * may be traversed in either direction. + * + * A tail queue is headed by a pair of pointers, one to the head of the + * list and the other to the tail of the list. The elements are doubly + * linked so that an arbitrary element can be removed without a need to + * traverse the list. New elements can be added to the list before or + * after an existing element, at the head of the list, or at the end of + * the list. A tail queue may be traversed in either direction. + * + * For details on the use of these macros, see the queue(3) manual page. + * + * Below is a summary of implemented functions where: + * + means the macro is available + * - means the macro is not available + * s means the macro is available but is slow (runs in O(n) time) + * + * SLIST LIST STAILQ TAILQ + * _HEAD + + + + + * _CLASS_HEAD + + + + + * _HEAD_INITIALIZER + + + + + * _ENTRY + + + + + * _CLASS_ENTRY + + + + + * _INIT + + + + + * _EMPTY + + + + + * _END + + + + + * _FIRST + + + + + * _NEXT + + + + + * _PREV - + - + + * _LAST - - + + + * _LAST_FAST - - - + + * _FOREACH + + + + + * _FOREACH_FROM + + + + + * _FOREACH_SAFE + + + + + * _FOREACH_FROM_SAFE + + + + + * _FOREACH_REVERSE - - - + + * _FOREACH_REVERSE_FROM - - - + + * _FOREACH_REVERSE_SAFE - - - + + * _FOREACH_REVERSE_FROM_SAFE - - - + + * _INSERT_HEAD + + + + + * _INSERT_BEFORE - + - + + * _INSERT_AFTER + + + + + * _INSERT_TAIL - - + + + * _CONCAT s s + + + * _REMOVE_AFTER + - + - + * _REMOVE_HEAD + - + - + * _REMOVE s + s + + * _SWAP + + + + + * + */ +#ifdef QUEUE_MACRO_DEBUG +/* Store the last 2 places the queue element or head was altered */ +struct qm_trace { + unsigned long lastline; + unsigned long prevline; + const char *lastfile; + const char *prevfile; +}; + +#define TRACEBUF struct qm_trace trace; +#define TRACEBUF_INITIALIZER { __LINE__, 0, __FILE__, NULL } , +#define TRASHIT(x) do {(x) = (void *)-1;} while (0) +#define QMD_SAVELINK(name, link) void **name = (void *)&(link) + +#define QMD_TRACE_HEAD(head) do { \ + (head)->trace.prevline = (head)->trace.lastline; \ + (head)->trace.prevfile = (head)->trace.lastfile; \ + (head)->trace.lastline = __LINE__; \ + (head)->trace.lastfile = __FILE__; \ +} while (0) + +#define QMD_TRACE_ELEM(elem) do { \ + (elem)->trace.prevline = (elem)->trace.lastline; \ + (elem)->trace.prevfile = (elem)->trace.lastfile; \ + (elem)->trace.lastline = __LINE__; \ + (elem)->trace.lastfile = __FILE__; \ +} while (0) + +#else /* !QUEUE_MACRO_DEBUG_TRACE */ +#define QMD_TRACE_ELEM(elem) +#define QMD_TRACE_HEAD(head) +#define TRACEBUF +#define TRACEBUF_INITIALIZER +#endif /* QUEUE_MACRO_DEBUG_TRACE */ + +#ifdef QUEUE_MACRO_DEBUG_TRASH +#define TRASHIT(x) do {(x) = (void *)-1;} while (0) +#define QMD_IS_TRASHED(x) ((x) == (void *)(intptr_t)-1) +#else /* !QUEUE_MACRO_DEBUG_TRASH */ +#define TRASHIT(x) +#define QMD_IS_TRASHED(x) 0 +#endif /* QUEUE_MACRO_DEBUG_TRASH */ + +#if defined(QUEUE_MACRO_DEBUG_TRACE) || defined(QUEUE_MACRO_DEBUG_TRASH) +#define QMD_SAVELINK(name, link) void **name = (void *)&(link) +#else /* !QUEUE_MACRO_DEBUG_TRACE && !QUEUE_MACRO_DEBUG_TRASH */ +#define QMD_SAVELINK(name, link) +#endif /* QUEUE_MACRO_DEBUG_TRACE || QUEUE_MACRO_DEBUG_TRASH */ + +#ifdef __cplusplus +/* + * In C++ there can be structure lists and class lists: + */ +#define QUEUE_TYPEOF(type) type +#else +#define QUEUE_TYPEOF(type) struct type +#endif + +/* + * Singly-linked List declarations. + */ +#define SLIST_HEAD(name, type) \ +struct name { \ + struct type *slh_first; /* first element */ \ +} + +#define SLIST_CLASS_HEAD(name, type) \ +struct name { \ + class type *slh_first; /* first element */ \ +} + +#define SLIST_HEAD_INITIALIZER(head) \ + { NULL } + +#define SLIST_ENTRY(type) \ +struct { \ + struct type *sle_next; /* next element */ \ +} + +#define SLIST_CLASS_ENTRY(type) \ +struct { \ + class type *sle_next; /* next element */ \ +} + +/* + * Singly-linked List functions. + */ +#if (defined(_KERNEL) && defined(INVARIANTS)) +#define QMD_SLIST_CHECK_PREVPTR(prevp, elm) do { \ + if (*(prevp) != (elm)) \ + panic("Bad prevptr *(%p) == %p != %p", \ + (prevp), *(prevp), (elm)); \ +} while (0) +#else +#define QMD_SLIST_CHECK_PREVPTR(prevp, elm) +#endif + +#define SLIST_CONCAT(head1, head2, type, field) do { \ + QUEUE_TYPEOF(type) *curelm = SLIST_FIRST(head1); \ + if (curelm == NULL) { \ + if ((SLIST_FIRST(head1) = SLIST_FIRST(head2)) != NULL) \ + SLIST_INIT(head2); \ + } else if (SLIST_FIRST(head2) != NULL) { \ + while (SLIST_NEXT(curelm, field) != NULL) \ + curelm = SLIST_NEXT(curelm, field); \ + SLIST_NEXT(curelm, field) = SLIST_FIRST(head2); \ + SLIST_INIT(head2); \ + } \ +} while (0) + +#define SLIST_EMPTY(head) ((head)->slh_first == NULL) + +#define SLIST_FIRST(head) ((head)->slh_first) + +#define SLIST_FOREACH(var, head, field) \ + for ((var) = SLIST_FIRST((head)); \ + (var); \ + (var) = SLIST_NEXT((var), field)) + +#define SLIST_FOREACH_FROM(var, head, field) \ + for ((var) = ((var) ? (var) : SLIST_FIRST((head))); \ + (var); \ + (var) = SLIST_NEXT((var), field)) + +#define SLIST_FOREACH_SAFE(var, head, field, tvar) \ + for ((var) = SLIST_FIRST((head)); \ + (var) && ((tvar) = SLIST_NEXT((var), field), 1); \ + (var) = (tvar)) + +#define SLIST_FOREACH_FROM_SAFE(var, head, field, tvar) \ + for ((var) = ((var) ? (var) : SLIST_FIRST((head))); \ + (var) && ((tvar) = SLIST_NEXT((var), field), 1); \ + (var) = (tvar)) + +#define SLIST_FOREACH_PREVPTR(var, varp, head, field) \ + for ((varp) = &SLIST_FIRST((head)); \ + ((var) = *(varp)) != NULL; \ + (varp) = &SLIST_NEXT((var), field)) + +#define SLIST_INIT(head) do { \ + SLIST_FIRST((head)) = NULL; \ +} while (0) + +#define SLIST_INSERT_AFTER(slistelm, elm, field) do { \ + SLIST_NEXT((elm), field) = SLIST_NEXT((slistelm), field); \ + SLIST_NEXT((slistelm), field) = (elm); \ +} while (0) + +#define SLIST_INSERT_HEAD(head, elm, field) do { \ + SLIST_NEXT((elm), field) = SLIST_FIRST((head)); \ + SLIST_FIRST((head)) = (elm); \ +} while (0) + +#define SLIST_NEXT(elm, field) ((elm)->field.sle_next) + +#define SLIST_REMOVE(head, elm, type, field) do { \ + QMD_SAVELINK(oldnext, (elm)->field.sle_next); \ + if (SLIST_FIRST((head)) == (elm)) { \ + SLIST_REMOVE_HEAD((head), field); \ + } \ + else { \ + QUEUE_TYPEOF(type) *curelm = SLIST_FIRST(head); \ + while (SLIST_NEXT(curelm, field) != (elm)) \ + curelm = SLIST_NEXT(curelm, field); \ + SLIST_REMOVE_AFTER(curelm, field); \ + } \ + TRASHIT(*oldnext); \ +} while (0) + +#define SLIST_REMOVE_AFTER(elm, field) do { \ + SLIST_NEXT(elm, field) = \ + SLIST_NEXT(SLIST_NEXT(elm, field), field); \ +} while (0) + +#define SLIST_REMOVE_HEAD(head, field) do { \ + SLIST_FIRST((head)) = SLIST_NEXT(SLIST_FIRST((head)), field); \ +} while (0) + +#define SLIST_REMOVE_PREVPTR(prevp, elm, field) do { \ + QMD_SLIST_CHECK_PREVPTR(prevp, elm); \ + *(prevp) = SLIST_NEXT(elm, field); \ + TRASHIT((elm)->field.sle_next); \ +} while (0) + +#define SLIST_SWAP(head1, head2, type) do { \ + QUEUE_TYPEOF(type) *swap_first = SLIST_FIRST(head1); \ + SLIST_FIRST(head1) = SLIST_FIRST(head2); \ + SLIST_FIRST(head2) = swap_first; \ +} while (0) + +#define SLIST_END(head) NULL + +/* + * Singly-linked Tail queue declarations. + */ +#define STAILQ_HEAD(name, type) \ +struct name { \ + struct type *stqh_first;/* first element */ \ + struct type **stqh_last;/* addr of last next element */ \ +} + +#define STAILQ_CLASS_HEAD(name, type) \ +struct name { \ + class type *stqh_first; /* first element */ \ + class type **stqh_last; /* addr of last next element */ \ +} + +#define STAILQ_HEAD_INITIALIZER(head) \ + { NULL, &(head).stqh_first } + +#define STAILQ_ENTRY(type) \ +struct { \ + struct type *stqe_next; /* next element */ \ +} + +#define STAILQ_CLASS_ENTRY(type) \ +struct { \ + class type *stqe_next; /* next element */ \ +} + +/* + * Singly-linked Tail queue functions. + */ +#define STAILQ_CONCAT(head1, head2) do { \ + if (!STAILQ_EMPTY((head2))) { \ + *(head1)->stqh_last = (head2)->stqh_first; \ + (head1)->stqh_last = (head2)->stqh_last; \ + STAILQ_INIT((head2)); \ + } \ +} while (0) + +#define STAILQ_EMPTY(head) ((head)->stqh_first == NULL) + +#define STAILQ_FIRST(head) ((head)->stqh_first) + +#define STAILQ_FOREACH(var, head, field) \ + for((var) = STAILQ_FIRST((head)); \ + (var); \ + (var) = STAILQ_NEXT((var), field)) + +#define STAILQ_FOREACH_FROM(var, head, field) \ + for ((var) = ((var) ? (var) : STAILQ_FIRST((head))); \ + (var); \ + (var) = STAILQ_NEXT((var), field)) + +#define STAILQ_FOREACH_SAFE(var, head, field, tvar) \ + for ((var) = STAILQ_FIRST((head)); \ + (var) && ((tvar) = STAILQ_NEXT((var), field), 1); \ + (var) = (tvar)) + +#define STAILQ_FOREACH_FROM_SAFE(var, head, field, tvar) \ + for ((var) = ((var) ? (var) : STAILQ_FIRST((head))); \ + (var) && ((tvar) = STAILQ_NEXT((var), field), 1); \ + (var) = (tvar)) + +#define STAILQ_INIT(head) do { \ + STAILQ_FIRST((head)) = NULL; \ + (head)->stqh_last = &STAILQ_FIRST((head)); \ +} while (0) + +#define STAILQ_INSERT_AFTER(head, tqelm, elm, field) do { \ + if ((STAILQ_NEXT((elm), field) = STAILQ_NEXT((tqelm), field)) == NULL)\ + (head)->stqh_last = &STAILQ_NEXT((elm), field); \ + STAILQ_NEXT((tqelm), field) = (elm); \ +} while (0) + +#define STAILQ_INSERT_HEAD(head, elm, field) do { \ + if ((STAILQ_NEXT((elm), field) = STAILQ_FIRST((head))) == NULL) \ + (head)->stqh_last = &STAILQ_NEXT((elm), field); \ + STAILQ_FIRST((head)) = (elm); \ +} while (0) + +#define STAILQ_INSERT_TAIL(head, elm, field) do { \ + STAILQ_NEXT((elm), field) = NULL; \ + *(head)->stqh_last = (elm); \ + (head)->stqh_last = &STAILQ_NEXT((elm), field); \ +} while (0) + +#define STAILQ_LAST(head, type, field) \ + (STAILQ_EMPTY((head)) ? NULL : \ + __containerof((head)->stqh_last, \ + QUEUE_TYPEOF(type), field.stqe_next)) + +#define STAILQ_NEXT(elm, field) ((elm)->field.stqe_next) + +#define STAILQ_REMOVE(head, elm, type, field) do { \ + QMD_SAVELINK(oldnext, (elm)->field.stqe_next); \ + if (STAILQ_FIRST((head)) == (elm)) { \ + STAILQ_REMOVE_HEAD((head), field); \ + } \ + else { \ + QUEUE_TYPEOF(type) *curelm = STAILQ_FIRST(head); \ + while (STAILQ_NEXT(curelm, field) != (elm)) \ + curelm = STAILQ_NEXT(curelm, field); \ + STAILQ_REMOVE_AFTER(head, curelm, field); \ + } \ + TRASHIT(*oldnext); \ +} while (0) + +#define STAILQ_REMOVE_AFTER(head, elm, field) do { \ + if ((STAILQ_NEXT(elm, field) = \ + STAILQ_NEXT(STAILQ_NEXT(elm, field), field)) == NULL) \ + (head)->stqh_last = &STAILQ_NEXT((elm), field); \ +} while (0) + +#define STAILQ_REMOVE_HEAD(head, field) do { \ + if ((STAILQ_FIRST((head)) = \ + STAILQ_NEXT(STAILQ_FIRST((head)), field)) == NULL) \ + (head)->stqh_last = &STAILQ_FIRST((head)); \ +} while (0) + +#define STAILQ_SWAP(head1, head2, type) do { \ + QUEUE_TYPEOF(type) *swap_first = STAILQ_FIRST(head1); \ + QUEUE_TYPEOF(type) **swap_last = (head1)->stqh_last; \ + STAILQ_FIRST(head1) = STAILQ_FIRST(head2); \ + (head1)->stqh_last = (head2)->stqh_last; \ + STAILQ_FIRST(head2) = swap_first; \ + (head2)->stqh_last = swap_last; \ + if (STAILQ_EMPTY(head1)) \ + (head1)->stqh_last = &STAILQ_FIRST(head1); \ + if (STAILQ_EMPTY(head2)) \ + (head2)->stqh_last = &STAILQ_FIRST(head2); \ +} while (0) + +#define STAILQ_END(head) NULL + + +/* + * List declarations. + */ +#define LIST_HEAD(name, type) \ +struct name { \ + struct type *lh_first; /* first element */ \ +} + +#define LIST_CLASS_HEAD(name, type) \ +struct name { \ + class type *lh_first; /* first element */ \ +} + +#define LIST_HEAD_INITIALIZER(head) \ + { NULL } + +#define LIST_ENTRY(type) \ +struct { \ + struct type *le_next; /* next element */ \ + struct type **le_prev; /* address of previous next element */ \ +} + +#define LIST_CLASS_ENTRY(type) \ +struct { \ + class type *le_next; /* next element */ \ + class type **le_prev; /* address of previous next element */ \ +} + +/* + * List functions. + */ + +#if (defined(_KERNEL) && defined(INVARIANTS)) +/* + * QMD_LIST_CHECK_HEAD(LIST_HEAD *head, LIST_ENTRY NAME) + * + * If the list is non-empty, validates that the first element of the list + * points back at 'head.' + */ +#define QMD_LIST_CHECK_HEAD(head, field) do { \ + if (LIST_FIRST((head)) != NULL && \ + LIST_FIRST((head))->field.le_prev != \ + &LIST_FIRST((head))) \ + panic("Bad list head %p first->prev != head", (head)); \ +} while (0) + +/* + * QMD_LIST_CHECK_NEXT(TYPE *elm, LIST_ENTRY NAME) + * + * If an element follows 'elm' in the list, validates that the next element + * points back at 'elm.' + */ +#define QMD_LIST_CHECK_NEXT(elm, field) do { \ + if (LIST_NEXT((elm), field) != NULL && \ + LIST_NEXT((elm), field)->field.le_prev != \ + &((elm)->field.le_next)) \ + panic("Bad link elm %p next->prev != elm", (elm)); \ +} while (0) + +/* + * QMD_LIST_CHECK_PREV(TYPE *elm, LIST_ENTRY NAME) + * + * Validates that the previous element (or head of the list) points to 'elm.' + */ +#define QMD_LIST_CHECK_PREV(elm, field) do { \ + if (*(elm)->field.le_prev != (elm)) \ + panic("Bad link elm %p prev->next != elm", (elm)); \ +} while (0) +#else +#define QMD_LIST_CHECK_HEAD(head, field) +#define QMD_LIST_CHECK_NEXT(elm, field) +#define QMD_LIST_CHECK_PREV(elm, field) +#endif /* (_KERNEL && INVARIANTS) */ + +#define LIST_CONCAT(head1, head2, type, field) do { \ + QUEUE_TYPEOF(type) *curelm = LIST_FIRST(head1); \ + if (curelm == NULL) { \ + if ((LIST_FIRST(head1) = LIST_FIRST(head2)) != NULL) { \ + LIST_FIRST(head2)->field.le_prev = \ + &LIST_FIRST((head1)); \ + LIST_INIT(head2); \ + } \ + } else if (LIST_FIRST(head2) != NULL) { \ + while (LIST_NEXT(curelm, field) != NULL) \ + curelm = LIST_NEXT(curelm, field); \ + LIST_NEXT(curelm, field) = LIST_FIRST(head2); \ + LIST_FIRST(head2)->field.le_prev = &LIST_NEXT(curelm, field); \ + LIST_INIT(head2); \ + } \ +} while (0) + +#define LIST_EMPTY(head) ((head)->lh_first == NULL) + +#define LIST_FIRST(head) ((head)->lh_first) + +#define LIST_FOREACH(var, head, field) \ + for ((var) = LIST_FIRST((head)); \ + (var); \ + (var) = LIST_NEXT((var), field)) + +#define LIST_FOREACH_FROM(var, head, field) \ + for ((var) = ((var) ? (var) : LIST_FIRST((head))); \ + (var); \ + (var) = LIST_NEXT((var), field)) + +#define LIST_FOREACH_SAFE(var, head, field, tvar) \ + for ((var) = LIST_FIRST((head)); \ + (var) && ((tvar) = LIST_NEXT((var), field), 1); \ + (var) = (tvar)) + +#define LIST_FOREACH_FROM_SAFE(var, head, field, tvar) \ + for ((var) = ((var) ? (var) : LIST_FIRST((head))); \ + (var) && ((tvar) = LIST_NEXT((var), field), 1); \ + (var) = (tvar)) + +#define LIST_INIT(head) do { \ + LIST_FIRST((head)) = NULL; \ +} while (0) + +#define LIST_INSERT_AFTER(listelm, elm, field) do { \ + QMD_LIST_CHECK_NEXT(listelm, field); \ + if ((LIST_NEXT((elm), field) = LIST_NEXT((listelm), field)) != NULL)\ + LIST_NEXT((listelm), field)->field.le_prev = \ + &LIST_NEXT((elm), field); \ + LIST_NEXT((listelm), field) = (elm); \ + (elm)->field.le_prev = &LIST_NEXT((listelm), field); \ +} while (0) + +#define LIST_INSERT_BEFORE(listelm, elm, field) do { \ + QMD_LIST_CHECK_PREV(listelm, field); \ + (elm)->field.le_prev = (listelm)->field.le_prev; \ + LIST_NEXT((elm), field) = (listelm); \ + *(listelm)->field.le_prev = (elm); \ + (listelm)->field.le_prev = &LIST_NEXT((elm), field); \ +} while (0) + +#define LIST_INSERT_HEAD(head, elm, field) do { \ + QMD_LIST_CHECK_HEAD((head), field); \ + if ((LIST_NEXT((elm), field) = LIST_FIRST((head))) != NULL) \ + LIST_FIRST((head))->field.le_prev = &LIST_NEXT((elm), field);\ + LIST_FIRST((head)) = (elm); \ + (elm)->field.le_prev = &LIST_FIRST((head)); \ +} while (0) + +#define LIST_NEXT(elm, field) ((elm)->field.le_next) + +#define LIST_PREV(elm, head, type, field) \ + ((elm)->field.le_prev == &LIST_FIRST((head)) ? NULL : \ + __containerof((elm)->field.le_prev, \ + QUEUE_TYPEOF(type), field.le_next)) + +#define LIST_REMOVE(elm, field) do { \ + QMD_SAVELINK(oldnext, (elm)->field.le_next); \ + QMD_SAVELINK(oldprev, (elm)->field.le_prev); \ + QMD_LIST_CHECK_NEXT(elm, field); \ + QMD_LIST_CHECK_PREV(elm, field); \ + if (LIST_NEXT((elm), field) != NULL) \ + LIST_NEXT((elm), field)->field.le_prev = \ + (elm)->field.le_prev; \ + *(elm)->field.le_prev = LIST_NEXT((elm), field); \ + TRASHIT(*oldnext); \ + TRASHIT(*oldprev); \ +} while (0) + +#define LIST_SWAP(head1, head2, type, field) do { \ + QUEUE_TYPEOF(type) *swap_tmp = LIST_FIRST(head1); \ + LIST_FIRST((head1)) = LIST_FIRST((head2)); \ + LIST_FIRST((head2)) = swap_tmp; \ + if ((swap_tmp = LIST_FIRST((head1))) != NULL) \ + swap_tmp->field.le_prev = &LIST_FIRST((head1)); \ + if ((swap_tmp = LIST_FIRST((head2))) != NULL) \ + swap_tmp->field.le_prev = &LIST_FIRST((head2)); \ +} while (0) + +#define LIST_END(head) NULL + +/* + * Tail queue declarations. + */ +#define TAILQ_HEAD(name, type) \ +struct name { \ + struct type *tqh_first; /* first element */ \ + struct type **tqh_last; /* addr of last next element */ \ + TRACEBUF \ +} + +#define TAILQ_CLASS_HEAD(name, type) \ +struct name { \ + class type *tqh_first; /* first element */ \ + class type **tqh_last; /* addr of last next element */ \ + TRACEBUF \ +} + +#define TAILQ_HEAD_INITIALIZER(head) \ + { NULL, &(head).tqh_first, TRACEBUF_INITIALIZER } + +#define TAILQ_ENTRY(type) \ +struct { \ + struct type *tqe_next; /* next element */ \ + struct type **tqe_prev; /* address of previous next element */ \ + TRACEBUF \ +} + +#define TAILQ_CLASS_ENTRY(type) \ +struct { \ + class type *tqe_next; /* next element */ \ + class type **tqe_prev; /* address of previous next element */ \ + TRACEBUF \ +} + +/* + * Tail queue functions. + */ +#if (defined(_KERNEL) && defined(INVARIANTS)) +/* + * QMD_TAILQ_CHECK_HEAD(TAILQ_HEAD *head, TAILQ_ENTRY NAME) + * + * If the tailq is non-empty, validates that the first element of the tailq + * points back at 'head.' + */ +#define QMD_TAILQ_CHECK_HEAD(head, field) do { \ + if (!TAILQ_EMPTY(head) && \ + TAILQ_FIRST((head))->field.tqe_prev != \ + &TAILQ_FIRST((head))) \ + panic("Bad tailq head %p first->prev != head", (head)); \ +} while (0) + +/* + * QMD_TAILQ_CHECK_TAIL(TAILQ_HEAD *head, TAILQ_ENTRY NAME) + * + * Validates that the tail of the tailq is a pointer to pointer to NULL. + */ +#define QMD_TAILQ_CHECK_TAIL(head, field) do { \ + if (*(head)->tqh_last != NULL) \ + panic("Bad tailq NEXT(%p->tqh_last) != NULL", (head)); \ +} while (0) + +/* + * QMD_TAILQ_CHECK_NEXT(TYPE *elm, TAILQ_ENTRY NAME) + * + * If an element follows 'elm' in the tailq, validates that the next element + * points back at 'elm.' + */ +#define QMD_TAILQ_CHECK_NEXT(elm, field) do { \ + if (TAILQ_NEXT((elm), field) != NULL && \ + TAILQ_NEXT((elm), field)->field.tqe_prev != \ + &((elm)->field.tqe_next)) \ + panic("Bad link elm %p next->prev != elm", (elm)); \ +} while (0) + +/* + * QMD_TAILQ_CHECK_PREV(TYPE *elm, TAILQ_ENTRY NAME) + * + * Validates that the previous element (or head of the tailq) points to 'elm.' + */ +#define QMD_TAILQ_CHECK_PREV(elm, field) do { \ + if (*(elm)->field.tqe_prev != (elm)) \ + panic("Bad link elm %p prev->next != elm", (elm)); \ +} while (0) +#else +#define QMD_TAILQ_CHECK_HEAD(head, field) +#define QMD_TAILQ_CHECK_TAIL(head, headname) +#define QMD_TAILQ_CHECK_NEXT(elm, field) +#define QMD_TAILQ_CHECK_PREV(elm, field) +#endif /* (_KERNEL && INVARIANTS) */ + +#define TAILQ_CONCAT(head1, head2, field) do { \ + if (!TAILQ_EMPTY(head2)) { \ + *(head1)->tqh_last = (head2)->tqh_first; \ + (head2)->tqh_first->field.tqe_prev = (head1)->tqh_last; \ + (head1)->tqh_last = (head2)->tqh_last; \ + TAILQ_INIT((head2)); \ + QMD_TRACE_HEAD(head1); \ + QMD_TRACE_HEAD(head2); \ + } \ +} while (0) + +#define TAILQ_EMPTY(head) ((head)->tqh_first == NULL) + +#define TAILQ_FIRST(head) ((head)->tqh_first) + +#define TAILQ_FOREACH(var, head, field) \ + for ((var) = TAILQ_FIRST((head)); \ + (var); \ + (var) = TAILQ_NEXT((var), field)) + +#define TAILQ_FOREACH_FROM(var, head, field) \ + for ((var) = ((var) ? (var) : TAILQ_FIRST((head))); \ + (var); \ + (var) = TAILQ_NEXT((var), field)) + +#define TAILQ_FOREACH_SAFE(var, head, field, tvar) \ + for ((var) = TAILQ_FIRST((head)); \ + (var) && ((tvar) = TAILQ_NEXT((var), field), 1); \ + (var) = (tvar)) + +#define TAILQ_FOREACH_FROM_SAFE(var, head, field, tvar) \ + for ((var) = ((var) ? (var) : TAILQ_FIRST((head))); \ + (var) && ((tvar) = TAILQ_NEXT((var), field), 1); \ + (var) = (tvar)) + +#define TAILQ_FOREACH_REVERSE(var, head, headname, field) \ + for ((var) = TAILQ_LAST((head), headname); \ + (var); \ + (var) = TAILQ_PREV((var), headname, field)) + +#define TAILQ_FOREACH_REVERSE_FROM(var, head, headname, field) \ + for ((var) = ((var) ? (var) : TAILQ_LAST((head), headname)); \ + (var); \ + (var) = TAILQ_PREV((var), headname, field)) + +#define TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar) \ + for ((var) = TAILQ_LAST((head), headname); \ + (var) && ((tvar) = TAILQ_PREV((var), headname, field), 1); \ + (var) = (tvar)) + +#define TAILQ_FOREACH_REVERSE_FROM_SAFE(var, head, headname, field, tvar) \ + for ((var) = ((var) ? (var) : TAILQ_LAST((head), headname)); \ + (var) && ((tvar) = TAILQ_PREV((var), headname, field), 1); \ + (var) = (tvar)) + +#define TAILQ_INIT(head) do { \ + TAILQ_FIRST((head)) = NULL; \ + (head)->tqh_last = &TAILQ_FIRST((head)); \ + QMD_TRACE_HEAD(head); \ +} while (0) + +#define TAILQ_INSERT_AFTER(head, listelm, elm, field) do { \ + QMD_TAILQ_CHECK_NEXT(listelm, field); \ + if ((TAILQ_NEXT((elm), field) = TAILQ_NEXT((listelm), field)) != NULL)\ + TAILQ_NEXT((elm), field)->field.tqe_prev = \ + &TAILQ_NEXT((elm), field); \ + else { \ + (head)->tqh_last = &TAILQ_NEXT((elm), field); \ + QMD_TRACE_HEAD(head); \ + } \ + TAILQ_NEXT((listelm), field) = (elm); \ + (elm)->field.tqe_prev = &TAILQ_NEXT((listelm), field); \ + QMD_TRACE_ELEM(&(elm)->field); \ + QMD_TRACE_ELEM(&(listelm)->field); \ +} while (0) + +#define TAILQ_INSERT_BEFORE(listelm, elm, field) do { \ + QMD_TAILQ_CHECK_PREV(listelm, field); \ + (elm)->field.tqe_prev = (listelm)->field.tqe_prev; \ + TAILQ_NEXT((elm), field) = (listelm); \ + *(listelm)->field.tqe_prev = (elm); \ + (listelm)->field.tqe_prev = &TAILQ_NEXT((elm), field); \ + QMD_TRACE_ELEM(&(elm)->field); \ + QMD_TRACE_ELEM(&(listelm)->field); \ +} while (0) + +#define TAILQ_INSERT_HEAD(head, elm, field) do { \ + QMD_TAILQ_CHECK_HEAD(head, field); \ + if ((TAILQ_NEXT((elm), field) = TAILQ_FIRST((head))) != NULL) \ + TAILQ_FIRST((head))->field.tqe_prev = \ + &TAILQ_NEXT((elm), field); \ + else \ + (head)->tqh_last = &TAILQ_NEXT((elm), field); \ + TAILQ_FIRST((head)) = (elm); \ + (elm)->field.tqe_prev = &TAILQ_FIRST((head)); \ + QMD_TRACE_HEAD(head); \ + QMD_TRACE_ELEM(&(elm)->field); \ +} while (0) + +#define TAILQ_INSERT_TAIL(head, elm, field) do { \ + QMD_TAILQ_CHECK_TAIL(head, field); \ + TAILQ_NEXT((elm), field) = NULL; \ + (elm)->field.tqe_prev = (head)->tqh_last; \ + *(head)->tqh_last = (elm); \ + (head)->tqh_last = &TAILQ_NEXT((elm), field); \ + QMD_TRACE_HEAD(head); \ + QMD_TRACE_ELEM(&(elm)->field); \ +} while (0) + +#define TAILQ_LAST(head, headname) \ + (*(((struct headname *)((head)->tqh_last))->tqh_last)) + +/* + * The FAST function is fast in that it causes no data access other + * then the access to the head. The standard LAST function above + * will cause a data access of both the element you want and + * the previous element. FAST is very useful for instances when + * you may want to prefetch the last data element. + */ +#define TAILQ_LAST_FAST(head, type, field) \ + (TAILQ_EMPTY(head) ? NULL : __containerof((head)->tqh_last, QUEUE_TYPEOF(type), field.tqe_next)) + +#define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next) + +#define TAILQ_PREV(elm, headname, field) \ + (*(((struct headname *)((elm)->field.tqe_prev))->tqh_last)) + +#define TAILQ_PREV_FAST(elm, head, type, field) \ + ((elm)->field.tqe_prev == &(head)->tqh_first ? NULL : \ + __containerof((elm)->field.tqe_prev, QUEUE_TYPEOF(type), field.tqe_next)) + +#define TAILQ_REMOVE(head, elm, field) do { \ + QMD_SAVELINK(oldnext, (elm)->field.tqe_next); \ + QMD_SAVELINK(oldprev, (elm)->field.tqe_prev); \ + QMD_TAILQ_CHECK_NEXT(elm, field); \ + QMD_TAILQ_CHECK_PREV(elm, field); \ + if ((TAILQ_NEXT((elm), field)) != NULL) \ + TAILQ_NEXT((elm), field)->field.tqe_prev = \ + (elm)->field.tqe_prev; \ + else { \ + (head)->tqh_last = (elm)->field.tqe_prev; \ + QMD_TRACE_HEAD(head); \ + } \ + *(elm)->field.tqe_prev = TAILQ_NEXT((elm), field); \ + TRASHIT(*oldnext); \ + TRASHIT(*oldprev); \ + QMD_TRACE_ELEM(&(elm)->field); \ +} while (0) + +#define TAILQ_SWAP(head1, head2, type, field) do { \ + QUEUE_TYPEOF(type) *swap_first = (head1)->tqh_first; \ + QUEUE_TYPEOF(type) **swap_last = (head1)->tqh_last; \ + (head1)->tqh_first = (head2)->tqh_first; \ + (head1)->tqh_last = (head2)->tqh_last; \ + (head2)->tqh_first = swap_first; \ + (head2)->tqh_last = swap_last; \ + if ((swap_first = (head1)->tqh_first) != NULL) \ + swap_first->field.tqe_prev = &(head1)->tqh_first; \ + else \ + (head1)->tqh_last = &(head1)->tqh_first; \ + if ((swap_first = (head2)->tqh_first) != NULL) \ + swap_first->field.tqe_prev = &(head2)->tqh_first; \ + else \ + (head2)->tqh_last = &(head2)->tqh_first; \ +} while (0) + +#define TAILQ_END(head) NULL + +#endif /* !_SYS_QUEUE_H_ */ diff --git a/third_party/musl/ndk_musl_include/unistd.h b/third_party/musl/ndk_musl_include/unistd.h index b1706ca213..c0556ab7ff 100644 --- a/third_party/musl/ndk_musl_include/unistd.h +++ b/third_party/musl/ndk_musl_include/unistd.h @@ -125,6 +125,7 @@ extern int optind, opterr, optopt; long pathconf(const char *, int); long fpathconf(int, int); long sysconf(int); +size_t confstr(int, char *, size_t); #if defined(_XOPEN_SOURCE) || defined(_GNU_SOURCE) || defined(_BSD_SOURCE) #define F_ULOCK 0 diff --git a/third_party/musl/ndk_musl_include/wordexp.h b/third_party/musl/ndk_musl_include/wordexp.h index 42de360f33..5705736516 100644 --- a/third_party/musl/ndk_musl_include/wordexp.h +++ b/third_party/musl/ndk_musl_include/wordexp.h @@ -31,6 +31,9 @@ typedef struct { #define WRDE_CMDSUB 4 #define WRDE_SYNTAX 5 +int wordexp (const char *__restrict, wordexp_t *__restrict, int); +void wordfree (wordexp_t *); + #ifdef __cplusplus } #endif diff --git a/third_party/musl/ndk_script/BUILD.gn b/third_party/musl/ndk_script/BUILD.gn index b28fcf8807..bbca1b91eb 100644 --- a/third_party/musl/ndk_script/BUILD.gn +++ b/third_party/musl/ndk_script/BUILD.gn @@ -1,384 +1,385 @@ -# Copyright (C) 2021 Huawei Device Co., Ltd. -# Copyright (C) 2019 The Android Open Source Project -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and +# Copyright (C) 2021 Huawei Device Co., Ltd. +# Copyright (C) 2019 The Android Open Source Project +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and # limitations under the License. - -import("//build/ohos/ndk/ndk.gni") -import("//third_party/musl/musl_config.gni") -import("//third_party/musl/musl_src.gni") -import("//third_party/musl/musl_template.gni") - -toolchains_dir = "//prebuilts/clang/ohos" -musl_target_out_dir = "${root_out_dir}/obj/third_party/musl" -ndk_musl_include = "ndk_musl_include" - -if (host_os == "mac") { - if (host_cpu == "arm64") { - toolchains_file_name = "darwin-arm64" - deps_name = "darwin_arm64" - } else { - toolchains_file_name = "darwin-x86_64" - deps_name = "darwin_x86_64" - } - - darwin_system_toolchains_dir = "${toolchains_dir}/${toolchains_file_name}" - ohos_ndk_toolchains("${deps_name}") { - dest_dir = "$ndk_darwin_toolchains_out_dir" - sources = [ - "${darwin_system_toolchains_dir}/llvm/NOTICE", - "${darwin_system_toolchains_dir}/llvm/bin", - "${darwin_system_toolchains_dir}/llvm/include", - "${darwin_system_toolchains_dir}/llvm/lib", - "${darwin_system_toolchains_dir}/llvm/libexec", - "${darwin_system_toolchains_dir}/llvm/python3", - "${darwin_system_toolchains_dir}/llvm/script", - "${darwin_system_toolchains_dir}/llvm/share", - ] - license_file = "${darwin_system_toolchains_dir}/llvm/NOTICE" - } - - action("darwin_toolchain") { - outputs = [ "${ndk_darwin_toolchains_out_dir}" ] - script = "toolchain.sh" - args = - [ "-i" ] + [ rebase_path("${darwin_system_toolchains_dir}/libcxx-ndk") ] - args += [ "-o" ] + [ rebase_path("${ndk_darwin_toolchains_out_dir}") ] - if (host_cpu == "arm64") { - deps = [ ":darwin_arm64" ] - } else { - deps = [ ":darwin_x86_64" ] - } - } -} else { - linux_x86_64_toolchains_dir = "${toolchains_dir}/linux-x86_64" - windows_x86_64_toolchain_dir = "${toolchains_dir}/windows-x86_64" - - ohos_ndk_toolchains("linux_x86_64") { - dest_dir = "$ndk_linux_toolchains_out_dir" - sources = [ - "${linux_x86_64_toolchains_dir}/llvm/NOTICE", - "${linux_x86_64_toolchains_dir}/llvm/bin", - "${linux_x86_64_toolchains_dir}/llvm/include", - "${linux_x86_64_toolchains_dir}/llvm/lib", - "${linux_x86_64_toolchains_dir}/llvm/libexec", - "${linux_x86_64_toolchains_dir}/llvm/python3", - "${linux_x86_64_toolchains_dir}/llvm/script", - "${linux_x86_64_toolchains_dir}/llvm/share", - ] - license_file = "${linux_x86_64_toolchains_dir}/llvm/NOTICE" - } - - ohos_ndk_toolchains("windows_x86_64") { - dest_dir = "$ndk_windows_toolchains_out_dir" - sources = [ - "${windows_x86_64_toolchain_dir}/llvm/NOTICE", - "${windows_x86_64_toolchain_dir}/llvm/bin", - "${windows_x86_64_toolchain_dir}/llvm/include", - "${windows_x86_64_toolchain_dir}/llvm/lib", - "${windows_x86_64_toolchain_dir}/llvm/libexec", - "${windows_x86_64_toolchain_dir}/llvm/script", - "${windows_x86_64_toolchain_dir}/llvm/share", - ] - args = [ "--follow-all-symlinks" ] - license_file = "${windows_x86_64_toolchain_dir}/llvm/NOTICE" - } - action("linux_toolchain") { - outputs = [ "${ndk_linux_toolchains_out_dir}" ] - script = "toolchain.sh" - args = - [ "-i" ] + [ rebase_path("${linux_x86_64_toolchains_dir}/libcxx-ndk") ] - args += [ "-o" ] + [ rebase_path("${ndk_linux_toolchains_out_dir}") ] - deps = [ ":linux_x86_64" ] - } - - action("windows_toolchain") { - outputs = [ "${ndk_windows_toolchains_out_dir}" ] - script = "toolchain.sh" - args = - [ "-i" ] + [ rebase_path("${windows_x86_64_toolchain_dir}/libcxx-ndk") ] - args += [ "-o" ] + [ rebase_path("${ndk_windows_toolchains_out_dir}") ] - deps = [ ":windows_x86_64" ] - } -} - -group("ndk_toolchain") { - if (host_os == "mac") { - deps = [ ":darwin_toolchain" ] - } else { - deps = [ - ":linux_toolchain", - ":windows_toolchain", - ] - } -} - -group("musl_sysroot") { - deps = [ - ":copy_musl_sysroot", - ":musl_arm_bits_arm32", - ":musl_arm_uapi_arm32", - ":musl_bits_aarch64", - ":musl_bits_x86_64", - ] -} - -action("copy_ndk_uapi") { - outputs = [ "${musl_target_out_dir}/${ndk_musl_include}/linux" ] - script = "${musl_dir}/scripts/copy_uapi.sh" - args = [ "-i" ] + [ rebase_path("${uapi_dir}") ] - args += - [ "-o" ] + [ rebase_path("${musl_target_out_dir}/${ndk_musl_include}") ] - args += [ "-t" ] + [ "${musl_arch}" ] -} - -action("copy_ndk_musl_headers") { - outputs = [ "${musl_target_out_dir}/${ndk_musl_include}" ] - script = "copy_ndk_musl_headers.sh" - args = [ "-i" ] + [ rebase_path("${musl_dir}/${ndk_musl_include}") ] - args += - [ "-o" ] + [ rebase_path("${musl_target_out_dir}/${ndk_musl_include}") ] - deps = [ ":copy_ndk_uapi" ] -} - -action("copy_musl_sysroot") { - outputs = [ "${ndk_headers_out_dir}" ] - script = "copy_musl_sysroot.sh" - args = - [ "-i" ] + [ rebase_path("${musl_target_out_dir}/${ndk_musl_include}") ] - args += [ "-o" ] + [ rebase_path("${ndk_headers_out_dir}") ] - args += [ "-t" ] + [ "${musl_arch}" ] - deps = [ ":copy_ndk_musl_headers" ] -} - -musl_libs_arm32 = [ - "//third_party/musl:create_alltypes_h(//build/toolchain/ohos:ohos_clang_arm)", - "//third_party/musl:create_syscall_h(//build/toolchain/ohos:ohos_clang_arm)", - "//third_party/musl:musl_copy_inc_bits(//build/toolchain/ohos:ohos_clang_arm)", -] - -musl_libs_aarch64 = [ - "//third_party/musl:create_alltypes_h(//build/toolchain/ohos:ohos_clang_arm64)", - "//third_party/musl:create_syscall_h(//build/toolchain/ohos:ohos_clang_arm64)", - "//third_party/musl:musl_copy_inc_bits(//build/toolchain/ohos:ohos_clang_arm64)", -] - -musl_libs_x86_64 = [ - "//third_party/musl:create_alltypes_h(//build/toolchain/ohos:ohos_clang_x86_64)", - "//third_party/musl:create_syscall_h(//build/toolchain/ohos:ohos_clang_x86_64)", - "//third_party/musl:musl_copy_inc_bits(//build/toolchain/ohos:ohos_clang_x86_64)", -] - -musl_lib_arm32 = [ - "//third_party/musl:soft_musl_crt_install_action(//build/toolchain/ohos:ohos_clang_arm)", - "//third_party/musl:soft_libc_musl_static(//build/toolchain/ohos:ohos_clang_arm)", - "//third_party/musl:soft_libm(//build/toolchain/ohos:ohos_clang_arm)", - "//third_party/musl:soft_libdl(//build/toolchain/ohos:ohos_clang_arm)", - "//third_party/musl:soft_libpthread(//build/toolchain/ohos:ohos_clang_arm)", - "//third_party/musl:soft_libcrypt(//build/toolchain/ohos:ohos_clang_arm)", - "//third_party/musl:soft_libutil(//build/toolchain/ohos:ohos_clang_arm)", - "//third_party/musl:soft_libxnet(//build/toolchain/ohos:ohos_clang_arm)", - "//third_party/musl:soft_libresolv(//build/toolchain/ohos:ohos_clang_arm)", - "//third_party/musl:soft_librt(//build/toolchain/ohos:ohos_clang_arm)", -] - -musl_lib_arm64 = [ - "//third_party/musl:soft_musl_crt_install_action(//build/toolchain/ohos:ohos_clang_arm64)", - "//third_party/musl:soft_libc_musl_static(//build/toolchain/ohos:ohos_clang_arm64)", - "//third_party/musl:soft_libm(//build/toolchain/ohos:ohos_clang_arm64)", - "//third_party/musl:soft_libdl(//build/toolchain/ohos:ohos_clang_arm64)", - "//third_party/musl:soft_libpthread(//build/toolchain/ohos:ohos_clang_arm64)", - "//third_party/musl:soft_libcrypt(//build/toolchain/ohos:ohos_clang_arm64)", - "//third_party/musl:soft_libutil(//build/toolchain/ohos:ohos_clang_arm64)", - "//third_party/musl:soft_libxnet(//build/toolchain/ohos:ohos_clang_arm64)", - "//third_party/musl:soft_libresolv(//build/toolchain/ohos:ohos_clang_arm64)", - "//third_party/musl:soft_librt(//build/toolchain/ohos:ohos_clang_arm64)", -] - -musl_lib_x86_64 = [ - "//third_party/musl:soft_musl_crt_install_action(//build/toolchain/ohos:ohos_clang_x86_64)", - "//third_party/musl:soft_libc_musl_static(//build/toolchain/ohos:ohos_clang_x86_64)", - "//third_party/musl:soft_libm(//build/toolchain/ohos:ohos_clang_x86_64)", - "//third_party/musl:soft_libdl(//build/toolchain/ohos:ohos_clang_x86_64)", - "//third_party/musl:soft_libpthread(//build/toolchain/ohos:ohos_clang_x86_64)", - "//third_party/musl:soft_libcrypt(//build/toolchain/ohos:ohos_clang_x86_64)", - "//third_party/musl:soft_libutil(//build/toolchain/ohos:ohos_clang_x86_64)", - "//third_party/musl:soft_libxnet(//build/toolchain/ohos:ohos_clang_x86_64)", - "//third_party/musl:soft_libresolv(//build/toolchain/ohos:ohos_clang_x86_64)", - "//third_party/musl:soft_librt(//build/toolchain/ohos:ohos_clang_x86_64)", -] - -## arm-linux-ohos asm directory -ohos_ndk_copy("musl_arm_uapi_arm32") { - dest_dir = "$ndk_os_irrelevant_out_dir/sysroot/usr/include/arm-linux-ohos" - - sources = - [ "//kernel/linux/patches/linux-5.10/prebuilts/usr/include/asm-arm/asm" ] - args = [ "--ignore-stale" ] -} - -## arm-linux-ohos bits directory -ohos_copy("musl_arm_bits_arm32") { - deps = musl_libs_arm32 - sources = [] - sources_temp = [ - "alltypes.h", - "syscall.h", - ] - sources_temp += musl_inc_bits_files - sources_orig = get_path_info(sources_temp, "file") - + +import("//build/ohos/ndk/ndk.gni") +import("//third_party/musl/musl_config.gni") +import("//third_party/musl/musl_src.gni") +import("//third_party/musl/musl_template.gni") + +toolchains_dir = "//prebuilts/clang/ohos" +musl_target_out_dir = "${root_out_dir}/obj/third_party/musl" +ndk_musl_include = "ndk_musl_include" +interface_musl_dir = "//interface/sdk_c/third_party/musl" + +if (host_os == "mac") { + if (host_cpu == "arm64") { + toolchains_file_name = "darwin-arm64" + deps_name = "darwin_arm64" + } else { + toolchains_file_name = "darwin-x86_64" + deps_name = "darwin_x86_64" + } + + darwin_system_toolchains_dir = "${toolchains_dir}/${toolchains_file_name}" + ohos_ndk_toolchains("${deps_name}") { + dest_dir = "$ndk_darwin_toolchains_out_dir" + sources = [ + "${darwin_system_toolchains_dir}/llvm/NOTICE", + "${darwin_system_toolchains_dir}/llvm/bin", + "${darwin_system_toolchains_dir}/llvm/include", + "${darwin_system_toolchains_dir}/llvm/lib", + "${darwin_system_toolchains_dir}/llvm/libexec", + "${darwin_system_toolchains_dir}/llvm/python3", + "${darwin_system_toolchains_dir}/llvm/script", + "${darwin_system_toolchains_dir}/llvm/share", + ] + license_file = "${darwin_system_toolchains_dir}/llvm/NOTICE" + } + + action("darwin_toolchain") { + outputs = [ "${ndk_darwin_toolchains_out_dir}" ] + script = "toolchain.sh" + args = + [ "-i" ] + [ rebase_path("${darwin_system_toolchains_dir}/libcxx-ndk") ] + args += [ "-o" ] + [ rebase_path("${ndk_darwin_toolchains_out_dir}") ] + if (host_cpu == "arm64") { + deps = [ ":darwin_arm64" ] + } else { + deps = [ ":darwin_x86_64" ] + } + } +} else { + linux_x86_64_toolchains_dir = "${toolchains_dir}/linux-x86_64" + windows_x86_64_toolchain_dir = "${toolchains_dir}/windows-x86_64" + + ohos_ndk_toolchains("linux_x86_64") { + dest_dir = "$ndk_linux_toolchains_out_dir" + sources = [ + "${linux_x86_64_toolchains_dir}/llvm/NOTICE", + "${linux_x86_64_toolchains_dir}/llvm/bin", + "${linux_x86_64_toolchains_dir}/llvm/include", + "${linux_x86_64_toolchains_dir}/llvm/lib", + "${linux_x86_64_toolchains_dir}/llvm/libexec", + "${linux_x86_64_toolchains_dir}/llvm/python3", + "${linux_x86_64_toolchains_dir}/llvm/script", + "${linux_x86_64_toolchains_dir}/llvm/share", + ] + license_file = "${linux_x86_64_toolchains_dir}/llvm/NOTICE" + } + + ohos_ndk_toolchains("windows_x86_64") { + dest_dir = "$ndk_windows_toolchains_out_dir" + sources = [ + "${windows_x86_64_toolchain_dir}/llvm/NOTICE", + "${windows_x86_64_toolchain_dir}/llvm/bin", + "${windows_x86_64_toolchain_dir}/llvm/include", + "${windows_x86_64_toolchain_dir}/llvm/lib", + "${windows_x86_64_toolchain_dir}/llvm/libexec", + "${windows_x86_64_toolchain_dir}/llvm/script", + "${windows_x86_64_toolchain_dir}/llvm/share", + ] + args = [ "--follow-all-symlinks" ] + license_file = "${windows_x86_64_toolchain_dir}/llvm/NOTICE" + } + action("linux_toolchain") { + outputs = [ "${ndk_linux_toolchains_out_dir}" ] + script = "toolchain.sh" + args = + [ "-i" ] + [ rebase_path("${linux_x86_64_toolchains_dir}/libcxx-ndk") ] + args += [ "-o" ] + [ rebase_path("${ndk_linux_toolchains_out_dir}") ] + deps = [ ":linux_x86_64" ] + } + + action("windows_toolchain") { + outputs = [ "${ndk_windows_toolchains_out_dir}" ] + script = "toolchain.sh" + args = + [ "-i" ] + [ rebase_path("${windows_x86_64_toolchain_dir}/libcxx-ndk") ] + args += [ "-o" ] + [ rebase_path("${ndk_windows_toolchains_out_dir}") ] + deps = [ ":windows_x86_64" ] + } +} + +group("ndk_toolchain") { + if (host_os == "mac") { + deps = [ ":darwin_toolchain" ] + } else { + deps = [ + ":linux_toolchain", + ":windows_toolchain", + ] + } +} + +group("musl_sysroot") { + deps = [ + ":copy_musl_sysroot", + ":musl_arm_bits_arm32", + ":musl_arm_uapi_arm32", + ":musl_bits_aarch64", + ":musl_bits_x86_64", + ] +} + +action("copy_ndk_uapi") { + outputs = [ "${musl_target_out_dir}/${ndk_musl_include}/linux" ] + script = "${musl_dir}/scripts/copy_uapi.sh" + args = [ "-i" ] + [ rebase_path("${uapi_dir}") ] + args += + [ "-o" ] + [ rebase_path("${musl_target_out_dir}/${ndk_musl_include}") ] + args += [ "-t" ] + [ "${musl_arch}" ] +} + +action("copy_ndk_musl_headers") { + outputs = [ "${musl_target_out_dir}/${ndk_musl_include}" ] + script = "copy_ndk_musl_headers.sh" + args = [ "-i" ] + [ rebase_path("${interface_musl_dir}/${ndk_musl_include}") ] + args += + [ "-o" ] + [ rebase_path("${musl_target_out_dir}/${ndk_musl_include}") ] + deps = [ ":copy_ndk_uapi" ] +} + +action("copy_musl_sysroot") { + outputs = [ "${ndk_headers_out_dir}" ] + script = "copy_musl_sysroot.sh" + args = + [ "-i" ] + [ rebase_path("${musl_target_out_dir}/${ndk_musl_include}") ] + args += [ "-o" ] + [ rebase_path("${ndk_headers_out_dir}") ] + args += [ "-t" ] + [ "${musl_arch}" ] + deps = [ ":copy_ndk_musl_headers" ] +} + +musl_libs_arm32 = [ + "//third_party/musl:create_alltypes_h(//build/toolchain/ohos:ohos_clang_arm)", + "//third_party/musl:create_syscall_h(//build/toolchain/ohos:ohos_clang_arm)", + "//third_party/musl:musl_copy_inc_bits(//build/toolchain/ohos:ohos_clang_arm)", +] + +musl_libs_aarch64 = [ + "//third_party/musl:create_alltypes_h(//build/toolchain/ohos:ohos_clang_arm64)", + "//third_party/musl:create_syscall_h(//build/toolchain/ohos:ohos_clang_arm64)", + "//third_party/musl:musl_copy_inc_bits(//build/toolchain/ohos:ohos_clang_arm64)", +] + +musl_libs_x86_64 = [ + "//third_party/musl:create_alltypes_h(//build/toolchain/ohos:ohos_clang_x86_64)", + "//third_party/musl:create_syscall_h(//build/toolchain/ohos:ohos_clang_x86_64)", + "//third_party/musl:musl_copy_inc_bits(//build/toolchain/ohos:ohos_clang_x86_64)", +] + +musl_lib_arm32 = [ + "//third_party/musl:soft_musl_crt_install_action(//build/toolchain/ohos:ohos_clang_arm)", + "//third_party/musl:soft_libc_musl_static(//build/toolchain/ohos:ohos_clang_arm)", + "//third_party/musl:soft_libm(//build/toolchain/ohos:ohos_clang_arm)", + "//third_party/musl:soft_libdl(//build/toolchain/ohos:ohos_clang_arm)", + "//third_party/musl:soft_libpthread(//build/toolchain/ohos:ohos_clang_arm)", + "//third_party/musl:soft_libcrypt(//build/toolchain/ohos:ohos_clang_arm)", + "//third_party/musl:soft_libutil(//build/toolchain/ohos:ohos_clang_arm)", + "//third_party/musl:soft_libxnet(//build/toolchain/ohos:ohos_clang_arm)", + "//third_party/musl:soft_libresolv(//build/toolchain/ohos:ohos_clang_arm)", + "//third_party/musl:soft_librt(//build/toolchain/ohos:ohos_clang_arm)", +] + +musl_lib_arm64 = [ + "//third_party/musl:soft_musl_crt_install_action(//build/toolchain/ohos:ohos_clang_arm64)", + "//third_party/musl:soft_libc_musl_static(//build/toolchain/ohos:ohos_clang_arm64)", + "//third_party/musl:soft_libm(//build/toolchain/ohos:ohos_clang_arm64)", + "//third_party/musl:soft_libdl(//build/toolchain/ohos:ohos_clang_arm64)", + "//third_party/musl:soft_libpthread(//build/toolchain/ohos:ohos_clang_arm64)", + "//third_party/musl:soft_libcrypt(//build/toolchain/ohos:ohos_clang_arm64)", + "//third_party/musl:soft_libutil(//build/toolchain/ohos:ohos_clang_arm64)", + "//third_party/musl:soft_libxnet(//build/toolchain/ohos:ohos_clang_arm64)", + "//third_party/musl:soft_libresolv(//build/toolchain/ohos:ohos_clang_arm64)", + "//third_party/musl:soft_librt(//build/toolchain/ohos:ohos_clang_arm64)", +] + +musl_lib_x86_64 = [ + "//third_party/musl:soft_musl_crt_install_action(//build/toolchain/ohos:ohos_clang_x86_64)", + "//third_party/musl:soft_libc_musl_static(//build/toolchain/ohos:ohos_clang_x86_64)", + "//third_party/musl:soft_libm(//build/toolchain/ohos:ohos_clang_x86_64)", + "//third_party/musl:soft_libdl(//build/toolchain/ohos:ohos_clang_x86_64)", + "//third_party/musl:soft_libpthread(//build/toolchain/ohos:ohos_clang_x86_64)", + "//third_party/musl:soft_libcrypt(//build/toolchain/ohos:ohos_clang_x86_64)", + "//third_party/musl:soft_libutil(//build/toolchain/ohos:ohos_clang_x86_64)", + "//third_party/musl:soft_libxnet(//build/toolchain/ohos:ohos_clang_x86_64)", + "//third_party/musl:soft_libresolv(//build/toolchain/ohos:ohos_clang_x86_64)", + "//third_party/musl:soft_librt(//build/toolchain/ohos:ohos_clang_x86_64)", +] + +## arm-linux-ohos asm directory +ohos_ndk_copy("musl_arm_uapi_arm32") { + dest_dir = "$ndk_os_irrelevant_out_dir/sysroot/usr/include/arm-linux-ohos" + + sources = + [ "//kernel/linux/patches/linux-5.10/prebuilts/usr/include/asm-arm/asm" ] + args = [ "--ignore-stale" ] +} + +## arm-linux-ohos bits directory +ohos_copy("musl_arm_bits_arm32") { + deps = musl_libs_arm32 + sources = [] + sources_temp = [ + "alltypes.h", + "syscall.h", + ] + sources_temp += musl_inc_bits_files + sources_orig = get_path_info(sources_temp, "file") + # print("${sources_orig}") - - foreach(s, sources_orig) { - sources += [ get_label_info(deps[0], "target_out_dir") + - "/usr/include/arm-linux-ohos/bits/${s}" ] - } - outputs = [ "$ndk_os_irrelevant_out_dir/sysroot/usr/include/arm-linux-ohos/bits/{{source_file_part}}" ] -} - -## aarch64-linux-ohos bits directory -ohos_copy("musl_bits_aarch64") { - deps = musl_libs_aarch64 - sources = [] - sources_temp = [ - "alltypes.h", - "syscall.h", - ] - sources_temp += musl_inc_bits_files - sources_orig = get_path_info(sources_temp, "file") - + + foreach(s, sources_orig) { + sources += [ get_label_info(deps[0], "target_out_dir") + + "/usr/include/arm-linux-ohos/bits/${s}" ] + } + outputs = [ "$ndk_os_irrelevant_out_dir/sysroot/usr/include/arm-linux-ohos/bits/{{source_file_part}}" ] +} + +## aarch64-linux-ohos bits directory +ohos_copy("musl_bits_aarch64") { + deps = musl_libs_aarch64 + sources = [] + sources_temp = [ + "alltypes.h", + "syscall.h", + ] + sources_temp += musl_inc_bits_files + sources_orig = get_path_info(sources_temp, "file") + # print("${sources_orig}") - - foreach(s, sources_orig) { - sources += [ get_label_info(deps[0], "target_out_dir") + - "/usr/include/aarch64-linux-ohos/bits/${s}" ] - } - outputs = [ "$ndk_os_irrelevant_out_dir/sysroot/usr/include/aarch64-linux-ohos/bits/{{source_file_part}}" ] -} - -## x86_64-linux-ohos bits directory -ohos_copy("musl_bits_x86_64") { - deps = musl_libs_x86_64 - sources = [] - sources_temp = [ - "alltypes.h", - "syscall.h", - ] - sources_temp += musl_inc_bits_files - sources_orig = get_path_info(sources_temp, "file") - + + foreach(s, sources_orig) { + sources += [ get_label_info(deps[0], "target_out_dir") + + "/usr/include/aarch64-linux-ohos/bits/${s}" ] + } + outputs = [ "$ndk_os_irrelevant_out_dir/sysroot/usr/include/aarch64-linux-ohos/bits/{{source_file_part}}" ] +} + +## x86_64-linux-ohos bits directory +ohos_copy("musl_bits_x86_64") { + deps = musl_libs_x86_64 + sources = [] + sources_temp = [ + "alltypes.h", + "syscall.h", + ] + sources_temp += musl_inc_bits_files + sources_orig = get_path_info(sources_temp, "file") + # print("${sources_orig}") - - foreach(s, sources_orig) { - sources += [ get_label_info(deps[0], "target_out_dir") + - "/usr/include/x86_64-linux-ohos/bits/${s}" ] - } - outputs = [ "$ndk_os_irrelevant_out_dir/sysroot/usr/include/x86_64-linux-ohos/bits/{{source_file_part}}" ] -} - -ohos_copy("musl_ndk_libs_arm32") { - deps = musl_lib_arm32 - crt_dir = "${root_build_dir}/obj/third_party/musl/usr/lib/arm-linux-ohos" - sources = [ - "${crt_dir}/Scrt1.o", - "${crt_dir}/crt1.o", - "${crt_dir}/crti.o", - "${crt_dir}/crtn.o", - "${crt_dir}/rcrt1.o", - ] - sources += [ get_label_info(deps[0], "target_out_dir") + - "/usr/lib/arm-linux-ohos/libm.a" ] - sources += [ get_label_info(deps[0], "target_out_dir") + - "/usr/lib/arm-linux-ohos/libdl.a" ] - sources += [ get_label_info(deps[0], "target_out_dir") + - "/usr/lib/arm-linux-ohos/libc.a" ] - sources += [ get_label_info(deps[0], "target_out_dir") + - "/usr/lib/arm-linux-ohos/libcrypt.a" ] - sources += [ get_label_info(deps[0], "target_out_dir") + - "/usr/lib/arm-linux-ohos/libpthread.a" ] - sources += [ get_label_info(deps[0], "target_out_dir") + - "/usr/lib/arm-linux-ohos/libresolv.a" ] - sources += [ get_label_info(deps[0], "target_out_dir") + - "/usr/lib/arm-linux-ohos/librt.a" ] - sources += [ get_label_info(deps[0], "target_out_dir") + - "/usr/lib/arm-linux-ohos/libutil.a" ] - sources += [ get_label_info(deps[0], "target_out_dir") + - "/usr/lib/arm-linux-ohos/libxnet.a" ] - - outputs = [ "$ndk_os_irrelevant_out_dir/sysroot/usr/lib/arm-linux-ohos/{{source_file_part}}" ] -} - -ohos_copy("musl_ndk_libs_aarch64") { - deps = musl_lib_arm64 - sources = [ get_label_info(deps[0], "target_out_dir") + - "/usr/lib/aarch64-linux-ohos/Scrt1.o" ] - sources += [ get_label_info(deps[0], "target_out_dir") + - "/usr/lib/aarch64-linux-ohos/crt1.o" ] - sources += [ get_label_info(deps[0], "target_out_dir") + - "/usr/lib/aarch64-linux-ohos/crti.o" ] - sources += [ get_label_info(deps[0], "target_out_dir") + - "/usr/lib/aarch64-linux-ohos/crtn.o" ] - sources += [ get_label_info(deps[0], "target_out_dir") + - "/usr/lib/aarch64-linux-ohos/rcrt1.o" ] - sources += [ get_label_info(deps[0], "target_out_dir") + - "/usr/lib/aarch64-linux-ohos/libc.a" ] - sources += [ get_label_info(deps[0], "target_out_dir") + - "/usr/lib/aarch64-linux-ohos/libdl.a" ] - sources += [ get_label_info(deps[0], "target_out_dir") + - "/usr/lib/aarch64-linux-ohos/libm.a" ] - sources += [ get_label_info(deps[0], "target_out_dir") + - "/usr/lib/aarch64-linux-ohos/libcrypt.a" ] - sources += [ get_label_info(deps[0], "target_out_dir") + - "/usr/lib/aarch64-linux-ohos/libpthread.a" ] - sources += [ get_label_info(deps[0], "target_out_dir") + - "/usr/lib/aarch64-linux-ohos/libresolv.a" ] - sources += [ get_label_info(deps[0], "target_out_dir") + - "/usr/lib/aarch64-linux-ohos/librt.a" ] - sources += [ get_label_info(deps[0], "target_out_dir") + - "/usr/lib/aarch64-linux-ohos/libutil.a" ] - sources += [ get_label_info(deps[0], "target_out_dir") + - "/usr/lib/aarch64-linux-ohos/libxnet.a" ] - - outputs = [ "$ndk_os_irrelevant_out_dir/sysroot/usr/lib/aarch64-linux-ohos/{{source_file_part}}" ] -} - -ohos_copy("musl_ndk_libs_x86_64") { - deps = musl_lib_x86_64 - crt_dir = "${root_build_dir}/obj/third_party/musl/usr/lib/x86_64-linux-ohos" - sources = [ - "${crt_dir}/Scrt1.o", - "${crt_dir}/crt1.o", - "${crt_dir}/crti.o", - "${crt_dir}/crtn.o", - "${crt_dir}/rcrt1.o", - ] - sources += [ get_label_info(deps[0], "target_out_dir") + - "/usr/lib/x86_64-linux-ohos/libc.a" ] - sources += [ get_label_info(deps[0], "target_out_dir") + - "/usr/lib/x86_64-linux-ohos/libdl.a" ] - sources += [ get_label_info(deps[0], "target_out_dir") + - "/usr/lib/x86_64-linux-ohos/libm.a" ] - sources += [ get_label_info(deps[0], "target_out_dir") + - "/usr/lib/x86_64-linux-ohos/libcrypt.a" ] - sources += [ get_label_info(deps[0], "target_out_dir") + - "/usr/lib/x86_64-linux-ohos/libpthread.a" ] - sources += [ get_label_info(deps[0], "target_out_dir") + - "/usr/lib/x86_64-linux-ohos/libresolv.a" ] - sources += [ get_label_info(deps[0], "target_out_dir") + - "/usr/lib/x86_64-linux-ohos/librt.a" ] - sources += [ get_label_info(deps[0], "target_out_dir") + - "/usr/lib/x86_64-linux-ohos/libutil.a" ] - sources += [ get_label_info(deps[0], "target_out_dir") + - "/usr/lib/x86_64-linux-ohos/libxnet.a" ] - - outputs = [ "$ndk_os_irrelevant_out_dir/sysroot/usr/lib/x86_64-linux-ohos/{{source_file_part}}" ] -} + + foreach(s, sources_orig) { + sources += [ get_label_info(deps[0], "target_out_dir") + + "/usr/include/x86_64-linux-ohos/bits/${s}" ] + } + outputs = [ "$ndk_os_irrelevant_out_dir/sysroot/usr/include/x86_64-linux-ohos/bits/{{source_file_part}}" ] +} + +ohos_copy("musl_ndk_libs_arm32") { + deps = musl_lib_arm32 + crt_dir = "${root_build_dir}/obj/third_party/musl/usr/lib/arm-linux-ohos" + sources = [ + "${crt_dir}/Scrt1.o", + "${crt_dir}/crt1.o", + "${crt_dir}/crti.o", + "${crt_dir}/crtn.o", + "${crt_dir}/rcrt1.o", + ] + sources += [ get_label_info(deps[0], "target_out_dir") + + "/usr/lib/arm-linux-ohos/libm.a" ] + sources += [ get_label_info(deps[0], "target_out_dir") + + "/usr/lib/arm-linux-ohos/libdl.a" ] + sources += [ get_label_info(deps[0], "target_out_dir") + + "/usr/lib/arm-linux-ohos/libc.a" ] + sources += [ get_label_info(deps[0], "target_out_dir") + + "/usr/lib/arm-linux-ohos/libcrypt.a" ] + sources += [ get_label_info(deps[0], "target_out_dir") + + "/usr/lib/arm-linux-ohos/libpthread.a" ] + sources += [ get_label_info(deps[0], "target_out_dir") + + "/usr/lib/arm-linux-ohos/libresolv.a" ] + sources += [ get_label_info(deps[0], "target_out_dir") + + "/usr/lib/arm-linux-ohos/librt.a" ] + sources += [ get_label_info(deps[0], "target_out_dir") + + "/usr/lib/arm-linux-ohos/libutil.a" ] + sources += [ get_label_info(deps[0], "target_out_dir") + + "/usr/lib/arm-linux-ohos/libxnet.a" ] + + outputs = [ "$ndk_os_irrelevant_out_dir/sysroot/usr/lib/arm-linux-ohos/{{source_file_part}}" ] +} + +ohos_copy("musl_ndk_libs_aarch64") { + deps = musl_lib_arm64 + sources = [ get_label_info(deps[0], "target_out_dir") + + "/usr/lib/aarch64-linux-ohos/Scrt1.o" ] + sources += [ get_label_info(deps[0], "target_out_dir") + + "/usr/lib/aarch64-linux-ohos/crt1.o" ] + sources += [ get_label_info(deps[0], "target_out_dir") + + "/usr/lib/aarch64-linux-ohos/crti.o" ] + sources += [ get_label_info(deps[0], "target_out_dir") + + "/usr/lib/aarch64-linux-ohos/crtn.o" ] + sources += [ get_label_info(deps[0], "target_out_dir") + + "/usr/lib/aarch64-linux-ohos/rcrt1.o" ] + sources += [ get_label_info(deps[0], "target_out_dir") + + "/usr/lib/aarch64-linux-ohos/libc.a" ] + sources += [ get_label_info(deps[0], "target_out_dir") + + "/usr/lib/aarch64-linux-ohos/libdl.a" ] + sources += [ get_label_info(deps[0], "target_out_dir") + + "/usr/lib/aarch64-linux-ohos/libm.a" ] + sources += [ get_label_info(deps[0], "target_out_dir") + + "/usr/lib/aarch64-linux-ohos/libcrypt.a" ] + sources += [ get_label_info(deps[0], "target_out_dir") + + "/usr/lib/aarch64-linux-ohos/libpthread.a" ] + sources += [ get_label_info(deps[0], "target_out_dir") + + "/usr/lib/aarch64-linux-ohos/libresolv.a" ] + sources += [ get_label_info(deps[0], "target_out_dir") + + "/usr/lib/aarch64-linux-ohos/librt.a" ] + sources += [ get_label_info(deps[0], "target_out_dir") + + "/usr/lib/aarch64-linux-ohos/libutil.a" ] + sources += [ get_label_info(deps[0], "target_out_dir") + + "/usr/lib/aarch64-linux-ohos/libxnet.a" ] + + outputs = [ "$ndk_os_irrelevant_out_dir/sysroot/usr/lib/aarch64-linux-ohos/{{source_file_part}}" ] +} + +ohos_copy("musl_ndk_libs_x86_64") { + deps = musl_lib_x86_64 + crt_dir = "${root_build_dir}/obj/third_party/musl/usr/lib/x86_64-linux-ohos" + sources = [ + "${crt_dir}/Scrt1.o", + "${crt_dir}/crt1.o", + "${crt_dir}/crti.o", + "${crt_dir}/crtn.o", + "${crt_dir}/rcrt1.o", + ] + sources += [ get_label_info(deps[0], "target_out_dir") + + "/usr/lib/x86_64-linux-ohos/libc.a" ] + sources += [ get_label_info(deps[0], "target_out_dir") + + "/usr/lib/x86_64-linux-ohos/libdl.a" ] + sources += [ get_label_info(deps[0], "target_out_dir") + + "/usr/lib/x86_64-linux-ohos/libm.a" ] + sources += [ get_label_info(deps[0], "target_out_dir") + + "/usr/lib/x86_64-linux-ohos/libcrypt.a" ] + sources += [ get_label_info(deps[0], "target_out_dir") + + "/usr/lib/x86_64-linux-ohos/libpthread.a" ] + sources += [ get_label_info(deps[0], "target_out_dir") + + "/usr/lib/x86_64-linux-ohos/libresolv.a" ] + sources += [ get_label_info(deps[0], "target_out_dir") + + "/usr/lib/x86_64-linux-ohos/librt.a" ] + sources += [ get_label_info(deps[0], "target_out_dir") + + "/usr/lib/x86_64-linux-ohos/libutil.a" ] + sources += [ get_label_info(deps[0], "target_out_dir") + + "/usr/lib/x86_64-linux-ohos/libxnet.a" ] + + outputs = [ "$ndk_os_irrelevant_out_dir/sysroot/usr/lib/x86_64-linux-ohos/{{source_file_part}}" ] +} diff --git a/third_party/musl/ndk_script/adapter/libc.ndk.json b/third_party/musl/ndk_script/adapter/libc.ndk.json index 7294302425..e72f5997b3 100644 --- a/third_party/musl/ndk_script/adapter/libc.ndk.json +++ b/third_party/musl/ndk_script/adapter/libc.ndk.json @@ -111,6 +111,9 @@ { "name": "aligned_alloc" }, { "name": "alphasort" }, { "name": "alphasort64" }, + { "name": "arc4random" }, + { "name": "arc4random_uniform" }, + { "name": "arc4random_buf" }, { "name": "asctime" }, { "name": "asctime_r" }, { "name": "asin" }, @@ -134,6 +137,9 @@ { "name": "atoi" }, { "name": "atol" }, { "name": "atoll" }, + { "name": "backtrace" }, + { "name": "backtrace_symbols" }, + { "name": "backtrace_symbols_fd" }, { "name": "basename" }, { "name": "bcmp" }, { "name": "bind" }, @@ -224,6 +230,7 @@ { "name": "cnd_signal" }, { "name": "cnd_timedwait" }, { "name": "cnd_wait" }, + { "name": "confstr" }, { "name": "conj" }, { "name": "conjf" }, { "name": "conjl" }, @@ -1151,6 +1158,8 @@ { "name": "shmctl" }, { "name": "shmdt" }, { "name": "shmget" }, + { "name": "shm_open" }, + { "name": "shm_unlink" }, { "name": "shutdown" }, { "name": "sigaction" }, { "name": "sigaddset" }, @@ -1444,6 +1453,8 @@ { "name": "wmemcpy" }, { "name": "wmemmove" }, { "name": "wmemset" }, + { "name": "wordexp" }, + { "name": "wordfree" }, { "name": "wprintf" }, { "name": "write" }, { "name": "writev" }, -- Gitee