From 859559268de562323ab0adac1016d822b02eef37 Mon Sep 17 00:00:00 2001 From: WenHan Gu Date: Wed, 2 Apr 2014 17:18:27 +0800 Subject: [PATCH] Implement libportable for unknown arch 64bit. Change-Id: I1e1fd8714b907bfccd5fa8df12a94697886e59cb --- ndk/sources/android/libportable/Android.mk | 60 +--- .../android/libportable/arch-arm64/vfs.c | 18 ++ .../android/libportable/arch-mips64/fenv.c | 160 +++++++++++ .../android/libportable/arch-mips64/socket.c | 261 ++++++++++++++++++ .../android/libportable/arch-mips64/stat.c | 65 +++++ .../libportable/arch-mips64/va_funcs.c | 50 ++++ .../android/libportable/arch-mips64/vfs.c | 18 ++ .../android/libportable/arch-x86_64/fenv.c | 182 ++++++++++++ .../android/libportable/arch-x86_64/stat.c | 65 +++++ .../libportable/arch-x86_64/va_funcs.c | 50 ++++ .../android/libportable/arch-x86_64/vfs.c | 18 ++ .../common/include/fenv_portable.h | 7 + .../libportable/common/include/portability.h | 3 +- .../common/include/stat_portable.h | 55 ++++ .../common/include/stdarg_portable.h | 30 ++ .../libportable/common/include/vfs_portable.h | 96 +++++++ 16 files changed, 1082 insertions(+), 56 deletions(-) create mode 100644 ndk/sources/android/libportable/arch-arm64/vfs.c create mode 100644 ndk/sources/android/libportable/arch-mips64/fenv.c create mode 100644 ndk/sources/android/libportable/arch-mips64/socket.c create mode 100644 ndk/sources/android/libportable/arch-mips64/stat.c create mode 100644 ndk/sources/android/libportable/arch-mips64/va_funcs.c create mode 100644 ndk/sources/android/libportable/arch-mips64/vfs.c create mode 100644 ndk/sources/android/libportable/arch-x86_64/fenv.c create mode 100644 ndk/sources/android/libportable/arch-x86_64/stat.c create mode 100644 ndk/sources/android/libportable/arch-x86_64/va_funcs.c create mode 100644 ndk/sources/android/libportable/arch-x86_64/vfs.c create mode 100644 ndk/sources/android/libportable/common/include/stdarg_portable.h create mode 100644 ndk/sources/android/libportable/common/include/vfs_portable.h diff --git a/ndk/sources/android/libportable/Android.mk b/ndk/sources/android/libportable/Android.mk index dde8e1961..dc851bd15 100644 --- a/ndk/sources/android/libportable/Android.mk +++ b/ndk/sources/android/libportable/Android.mk @@ -31,63 +31,13 @@ LOCAL_C_INCLUDES := $(LOCAL_PATH)/common/include # Uncomment the next line to easily enable Lib-Portable logging during development. # LOCAL_CFLAGS += -DLOG_NDEBUG=0 -ifeq ($(TARGET_ARCH),mips) -libportable_arch_src_files += \ - arch-mips/clone.c \ - arch-mips/epoll.c \ - arch-mips/errno.c \ - arch-mips/eventfd.c \ - arch-mips/fcntl.c \ - arch-mips/filefd.c \ - arch-mips/flags.c \ - arch-mips/inotify.c \ - arch-mips/ioctl.c \ - arch-mips/mmap.c \ - arch-mips/open.c \ - arch-mips/poll.c \ - arch-mips/pipe.c \ - arch-mips/pthread.c \ - arch-mips/resource.c \ - arch-mips/signal.c \ - arch-mips/socket.c \ - arch-mips/sockopt.c \ - arch-mips/stat.c \ - arch-mips/statfs.c \ - arch-mips/syscall.c \ - arch-mips/timer.c \ - arch-mips/timerfd.c \ - arch-mips/waitpid.c \ - arch-mips/fenv.c \ - arch-mips/md_swap.c - -libportable_arch_src_files += \ - arch-mips/_setjmp.S \ - arch-mips/setjmp.S \ - arch-mips/sigsetjmp.S - -endif - -ifeq ($(TARGET_ARCH),arm) -libportable_arch_src_files += \ - arch-arm/unwind.c \ - arch-arm/fenv.c \ - arch-arm/md_swap.c -endif - -ifeq ($(TARGET_ARCH),x86) -libportable_arch_src_files += \ - arch-x86/epoll.c \ - arch-x86/fcntl.c \ - arch-x86/ioctl.c \ - arch-x86/open.c \ - arch-x86/stat.c \ - arch-x86/fenv.c \ - arch-x86/md_swap.c -endif +libportable_src_files = \ + $(patsubst $(LOCAL_PATH)/%,%,$(wildcard $(LOCAL_PATH)/arch-$(TARGET_ARCH)/*.c)) \ + $(patsubst $(LOCAL_PATH)/%,%,$(wildcard $(LOCAL_PATH)/arch-$(TARGET_ARCH)/*.S)) +$(info $(libportable_src_files)) LOCAL_SRC_FILES := \ - $(libportable_common_src_files) \ - $(libportable_arch_src_files) + $(libportable_src_files) LOCAL_WHOLE_STATIC_LIBRARIES += cpufeatures diff --git a/ndk/sources/android/libportable/arch-arm64/vfs.c b/ndk/sources/android/libportable/arch-arm64/vfs.c new file mode 100644 index 000000000..94d6793b3 --- /dev/null +++ b/ndk/sources/android/libportable/arch-arm64/vfs.c @@ -0,0 +1,18 @@ +/* + * Copyright 2012, 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. + */ + +#include +#include diff --git a/ndk/sources/android/libportable/arch-mips64/fenv.c b/ndk/sources/android/libportable/arch-mips64/fenv.c new file mode 100644 index 000000000..0721c6243 --- /dev/null +++ b/ndk/sources/android/libportable/arch-mips64/fenv.c @@ -0,0 +1,160 @@ +/* + * Copyright 2013, 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. + */ + +#include +#include +#include +#include + +static inline int mips64_change_except(int flags) { + int mips64flags = 0; + int exception = flags & FE_ALL_EXCEPT_PORTABLE; + + // exception flags + if (exception & FE_INVALID_PORTABLE) + mips64flags |= FE_INVALID; + if (exception & FE_DIVBYZERO_PORTABLE) + mips64flags |= FE_DIVBYZERO; + if (exception & FE_OVERFLOW_PORTABLE) + mips64flags |= FE_OVERFLOW; + if (exception & FE_UNDERFLOW_PORTABLE) + mips64flags |= FE_UNDERFLOW; + if (exception & FE_INEXACT_PORTABLE) + mips64flags |= FE_INEXACT; + + return mips64flags; +} + +static inline int mips64_change_rounding(int flags) { + int mips64flags = 0; + int rounding = flags & 0x03; + + // rounding flags + switch(rounding) + { + case FE_TONEAREST_PORTABLE: + mips64flags = FE_TONEAREST; + break; + case FE_DOWNWARD_PORTABLE: + mips64flags = FE_DOWNWARD; + break; + case FE_UPWARD_PORTABLE: + mips64flags = FE_UPWARD; + break; + case FE_TOWARDZERO_PORTABLE: + mips64flags = FE_TOWARDZERO; + break; + } + return mips64flags; +} + +static inline int mips64_get_except(int mips64flags) { + int flags = 0; + int exception = mips64flags & FE_ALL_EXCEPT; + + // exception flags + if (exception & FE_INVALID) + flags |= FE_INVALID_PORTABLE; + if (exception & FE_DIVBYZERO) + flags |= FE_DIVBYZERO_PORTABLE; + if (exception & FE_OVERFLOW) + flags |= FE_OVERFLOW_PORTABLE; + if (exception & FE_UNDERFLOW) + flags |= FE_UNDERFLOW_PORTABLE; + if (exception & FE_INEXACT) + flags |= FE_INEXACT_PORTABLE; + return flags; +} + +static inline int mips64_get_rounding(int mips64flags) { + int flags = 0; + int rounding = mips64flags & _FCSR_RMASK; + + // rounding flags + switch(rounding) + { + case FE_TONEAREST: + flags = FE_TONEAREST_PORTABLE; + break; + case FE_DOWNWARD: + flags = FE_DOWNWARD_PORTABLE; + break; + case FE_UPWARD: + flags = FE_UPWARD_PORTABLE; + break; + case FE_TOWARDZERO: + flags = FE_TOWARDZERO_PORTABLE; + break; + } + return flags; +} + + +int WRAP(feclearexcept)(int flag) { + return REAL(feclearexcept)(mips64_change_except(flag)); +} + +int WRAP(fegetexceptflag)(fexcept_t_portable *obj, int flag) { + int ret = REAL(fegetexceptflag)((fexcept_t*)obj, mips64_change_except(flag)); + *obj = (fexcept_t_portable) mips64_get_except(*obj); + return ret; +} + +int WRAP(feraiseexcept)(int flag) { + return REAL(feraiseexcept)(mips64_change_except(flag)); +} + +int WRAP(fesetexceptflag)(const fexcept_t_portable *obj, int flag) { + const fexcept_t mips64obj = mips64_change_except(*obj); + int mips64flag = mips64_change_except(flag); + return REAL(fesetexceptflag)(&mips64obj, mips64flag); +} + +int WRAP(fetestexcept)(int flag) { + int ret = REAL(fetestexcept)(mips64_change_except(flag)); + return mips64_get_except(ret); +} + +int WRAP(fegetround)(void) { + int round = REAL(fegetround)(); + return mips64_get_rounding(round); +} + +int WRAP(fesetround)(int round) { + return REAL(fesetround)(mips64_change_rounding(round)); +} + +int WRAP(fegetenv)(fenv_t_portable *obj) { + return REAL(fegetenv)((fenv_t*)obj); +} + +int WRAP(feholdexcept)(fenv_t_portable *obj) { + return REAL(feholdexcept)((fenv_t*)obj); +} + +int WRAP(fesetenv)(const fenv_t_portable *obj) { + return REAL(fesetenv)((const fenv_t*)obj); +} + +int WRAP(feupdateenv)(const fenv_t_portable *obj) { + return REAL(feupdateenv)((const fenv_t*)obj); +} + +int WRAP(fegetexcept)(void) { + int flag = REAL(fegetexcept)(); + return mips64_get_except(flag); +} + diff --git a/ndk/sources/android/libportable/arch-mips64/socket.c b/ndk/sources/android/libportable/arch-mips64/socket.c new file mode 100644 index 000000000..be2c7e6ed --- /dev/null +++ b/ndk/sources/android/libportable/arch-mips64/socket.c @@ -0,0 +1,261 @@ +/* + * Copyright 2012, 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. + */ + +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#define PORTABLE_TAG "socket_portable" +#include + + +#if SOCK_STREAM==SOCK_STREAM_PORTABLE +#error Bad build environment +#endif + +/* LTP defaults to using O_NONBLOCK if SOCK_NONBLOCK is not defined. */ +#ifndef SOCK_NONBLOCK_PORTABLE +# define SOCK_NONBLOCK_PORTABLE O_NONBLOCK_PORTABLE +#endif +#ifndef SOCK_NONBLOCK +# define SOCK_NONBLOCK O_NONBLOCK +#endif + +/* Current NDK headers do not define SOCK_CLOEXEC or O_CLOEXEC */ +#if !defined(SOCK_CLOEXEC_PORTABLE) && defined(O_CLOEXEC_PORTABLE) +# define SOCK_CLOEXEC_PORTABLE O_CLOEXEC_PORTABLE +#endif +#if !defined(SOCK_CLOEXEC) && defined(O_CLOEXEC) +# define SOCK_CLOEXEC O_CLOEXEC +#endif + + +/* + * Portable to Native socktype mapper. + */ +static inline int socktype_pton(int portable_type) +{ + int native_type = 0; + + ALOGV("%s(portable_type:0x%x) {", __func__, portable_type); + + if (portable_type & SOCK_NONBLOCK_PORTABLE) { + native_type |= SOCK_NONBLOCK; + portable_type &= ~SOCK_NONBLOCK_PORTABLE; + } + +#if defined(SOCK_CLOEXEC_PORTABLE) && defined(SOCK_CLOEXEC) + if (portable_type & SOCK_CLOEXEC_PORTABLE) { + native_type |= SOCK_CLOEXEC; + portable_type &= ~SOCK_CLOEXEC_PORTABLE; + } +#endif + + switch (portable_type) { + case SOCK_STREAM_PORTABLE: native_type |= SOCK_STREAM; break; + case SOCK_DGRAM_PORTABLE: native_type |= SOCK_DGRAM; break; + case SOCK_RAW_PORTABLE: native_type |= SOCK_RAW; break; + case SOCK_RDM_PORTABLE: native_type |= SOCK_RDM; break; + case SOCK_SEQPACKET_PORTABLE: native_type |= SOCK_SEQPACKET; break; + case SOCK_PACKET_PORTABLE: native_type |= SOCK_PACKET; break; + default: + ALOGE("%s: case default: native_type:0x%x |= portable_type:0x%x:[UNKNOWN!];", __func__, + native_type, portable_type); + + native_type |= portable_type; + break; + } + ALOGV("%s: return(native_type:%d); }", __func__, native_type); + return native_type; +} + + +/* + * Native to Portable socktype mapper. + */ +static inline int socktype_ntop(int native_type) +{ + int portable_type = 0; + + ALOGV("%s(native_type:0x%x) {", __func__, native_type); + + if (native_type & SOCK_NONBLOCK) { + portable_type |= SOCK_NONBLOCK_PORTABLE; + native_type &= ~SOCK_NONBLOCK; + } + +#if defined(SOCK_CLOEXEC_PORTABLE) && defined(SOCK_CLOEXEC) + if (native_type & SOCK_CLOEXEC) { + portable_type |= SOCK_CLOEXEC_PORTABLE; + native_type &= ~SOCK_CLOEXEC; + } +#endif + + switch (native_type) { + case SOCK_STREAM: portable_type |= SOCK_STREAM_PORTABLE; break; + case SOCK_DGRAM: portable_type |= SOCK_DGRAM_PORTABLE; break; + case SOCK_RAW: portable_type |= SOCK_RAW_PORTABLE; break; + case SOCK_RDM: portable_type |= SOCK_RDM_PORTABLE; break; + case SOCK_SEQPACKET: portable_type |= SOCK_SEQPACKET_PORTABLE; break; + case SOCK_PACKET: portable_type |= SOCK_PACKET_PORTABLE; break; + default: + portable_type |= native_type; + ALOGE("%s: case default: portable_type:0x%x |= native_type:0x%x:[UNKNOWN!];", __func__, + portable_type, native_type); + } + ALOGV("%s: return(portable_type:%d); }", __func__, portable_type); + return portable_type; +} + + +extern int REAL(socket)(int, int, int); + +int WRAP(socket)(int domain, int type, int protocol) { + int rv; + + ALOGV(" "); + ALOGV("%s(domain:%d, type:%d, protocol:%d) {", __func__, + domain, type, protocol); + + rv = REAL(socket)(domain, socktype_pton(type), protocol); + + ALOGV("%s: return(rv:%d); }", __func__, rv); + return rv; +} + + +int WRAP(socketpair)(int domain, int type, int protocol, int sv[2]) { + int rv; + + ALOGV(" "); + ALOGV("%s(domain:%d, type:%d, protocol:%d, sv[2]:%p) {", __func__, + domain, type, protocol, sv); + + rv = REAL(socketpair)(domain, socktype_pton(type), protocol, sv); + + if ((rv != 0) || invalid_pointer(sv)) { + ALOGV("%s: return(rv:%d); }", __func__, + rv); + } else { + ALOGV("%s: return(rv:%d); sv[0]:%d; sv[1]:%d;}", __func__, + rv, sv[0], sv[1]); + } + return rv; +} + +#define PRINT_ADDRINFO(p) { \ + ALOGV("%s: p:%p->{ai_flags:%d, ai_family:%d, ai_socktype:%d, ai_protocol:%d, ...", __func__, \ + p, p->ai_flags, p->ai_family, p->ai_socktype, p->ai_protocol); \ + \ + ALOGV("%s: p:%p->{... ai_addrlen:%d, ai_addr:%p, ai_canonname:%p, p->ai_next:%p);", __func__,\ + p, p->ai_addrlen, p->ai_addr, p->ai_canonname, p->ai_next); \ +} + +/* + * Returns a list of portable addrinfo structures that are + * later made free with a call to the portable version of + * freeaddrinfo(); which is written below this function. + */ +int WRAP(getaddrinfo)(const char *node, const char *service, + struct addrinfo_portable *portable_hints, + struct addrinfo_portable **portable_results) +{ + int rv; + struct addrinfo *native_hints; + struct addrinfo **native_results, *rp; + int saved_portable_socktype; + + ALOGV(" "); + ALOGV("%s(node:%p, service:%p, portable_hints:%p, portable_results:%p) {", __func__, + node, service, portable_hints, portable_results); + + PRINT_ADDRINFO(portable_hints); + + /* + * The only part of the addrinfo structure that needs to be modified + * between ARM and MIPS is the socktype; + */ + ASSERT(sizeof(struct addrinfo_portable) == sizeof(struct addrinfo)); + native_hints = ((struct addrinfo *) portable_hints); + if (native_hints != NULL) { + saved_portable_socktype = portable_hints->ai_socktype; + native_hints->ai_socktype = socktype_pton(saved_portable_socktype); + } + ASSERT(portable_results != NULL); + native_results = (struct addrinfo **) portable_results; + + rv = REAL(getaddrinfo)(node, service, native_hints, native_results); + + if (native_hints != NULL) { + portable_hints->ai_socktype = saved_portable_socktype; + } + + + /* + * Map socktypes in the return list of addrinfo structures from native to portable. + * Assuming getaddrinfo() has left structure writeable and the list is generated + * on each call. This seems to be true when looking at the man page and the code + * at: + * ./bionic/libc/netbsd/net/getaddrinfo.c + */ + for (rp = *native_results; rp != NULL; rp = rp->ai_next) { + PRINT_ADDRINFO(rp); + rp->ai_socktype = socktype_ntop(rp->ai_socktype); + } + ALOGV("%s: return(rv:%d); }", __func__, rv); + return rv; +} + + +/* + * Free the results list returned from a previous call + * to the portable version of getaddrinfo(). + */ +void WRAP(freeaddrinfo)(struct addrinfo_portable *portable_results) +{ + struct addrinfo *native_results, *rp; + + ALOGV(" "); + ALOGV("%s(portable_results:%p) {", __func__, portable_results); + + PRINT_ADDRINFO(portable_results); + + /* + * The only part of each addrinfo structure that needs to be modified + * between ARM and MIPS is the socktype; + * + * Map socktypes in the return list of iportable addrinfo structures back to native. + * Again, assuming getaddrinfo() has left structure writeable and the list is generated + * on each call. This seems to be true when looking at the man page and the code. + */ + ASSERT(sizeof(struct addrinfo_portable) == sizeof(struct addrinfo)); + native_results = ((struct addrinfo *) portable_results); + for (rp = native_results; rp != NULL; rp = rp->ai_next) { + PRINT_ADDRINFO(rp); + rp->ai_socktype = socktype_pton(rp->ai_socktype); /* Likely not really necessary */ + } + REAL(freeaddrinfo)(native_results); + + ALOGV("%s: return; }", __func__); + return; +} diff --git a/ndk/sources/android/libportable/arch-mips64/stat.c b/ndk/sources/android/libportable/arch-mips64/stat.c new file mode 100644 index 000000000..0bfd0ba14 --- /dev/null +++ b/ndk/sources/android/libportable/arch-mips64/stat.c @@ -0,0 +1,65 @@ +/* + * Copyright 2014, 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. + */ + +#include +#include +#include + + +int WRAP(fstat)(int fd, struct stat_portable *s) { + struct stat mips64_stat; + int ret = REAL(fstat)(fd, &mips64_stat); + stat_ntop(&mips64_stat, s); + return ret; +} +static inline int WRAP(fstat64)(int fd, struct stat64_portable *s) { + return WRAP(fstat)(fd, (struct stat_portable*)s); +} + + +int WRAP(fstatat)(int dirfd, const char *path, struct stat_portable *s, int flags) { + struct stat mips64_stat; + int ret = REAL(fstatat)(dirfd, path, &mips64_stat, flags); + stat_ntop(&mips64_stat, s); + return ret; +} +static inline int WRAP(fstatat64)(int dirfd, const char *path, + struct stat64_portable *s, int flags) { + return WRAP(fstatat)(dirfd, path, (struct stat_portable*)s, flags); +} + + +int WRAP(lstat)(const char *path, struct stat_portable *s) { + struct stat mips64_stat; + int ret = REAL(lstat)(path, &mips64_stat); + stat_ntop(&mips64_stat, s); + return ret; +} +static inline int WRAP(lstat64)(const char *path, struct stat64_portable *s) { + return WRAP(lstat)(path, (struct stat_portable*)s); +} + + +int WRAP(stat)(const char* path, struct stat_portable* s) { + struct stat mips64_stat; + int ret = REAL(stat)(path, &mips64_stat); + stat_ntop(&mips64_stat, s); + return ret; +} +static inline int WRAP(stat64)(const char* path, struct stat64_portable *s) { + return WRAP(stat)(path, (struct stat_portable*)s); +} + diff --git a/ndk/sources/android/libportable/arch-mips64/va_funcs.c b/ndk/sources/android/libportable/arch-mips64/va_funcs.c new file mode 100644 index 000000000..d27aaa007 --- /dev/null +++ b/ndk/sources/android/libportable/arch-mips64/va_funcs.c @@ -0,0 +1,50 @@ +/* + * Copyright 2014, 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. + */ + +#include +#include +#include + +#include + +int WRAP(vfprintf)(FILE *stream, const char *format, va_list_portable *arg) { + return REAL(vfprintf)(stream, format, arg); +} + +int WRAP(vfscanf)(FILE *stream, const char *format, va_list_portable *arg) { + return REAL(vfscanf)(stream, format, arg); +} + +int WRAP(vprintf)(const char *format, va_list_portable *arg) { + return REAL(vprintf)(format, arg); +} + +int WRAP(vscanf)(const char *format, va_list_portable *arg) { + return REAL(vscanf)(format, arg); +} + +int WRAP(vsnprintf)(char *s, size_t n, const char *format, va_list_portable *arg) { + return REAL(vsnprintf)(s, n, format, arg); +} + +int WRAP(vsprintf)(char *s, const char *format, va_list_portable *arg) { + return REAL(vsprintf)(s, format, arg); +} + +int WRAP(vsscanf)(const char *s, const char *format, va_list_portable *arg) { + return REAL(vsscanf)(s, format, arg); +} + diff --git a/ndk/sources/android/libportable/arch-mips64/vfs.c b/ndk/sources/android/libportable/arch-mips64/vfs.c new file mode 100644 index 000000000..94d6793b3 --- /dev/null +++ b/ndk/sources/android/libportable/arch-mips64/vfs.c @@ -0,0 +1,18 @@ +/* + * Copyright 2012, 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. + */ + +#include +#include diff --git a/ndk/sources/android/libportable/arch-x86_64/fenv.c b/ndk/sources/android/libportable/arch-x86_64/fenv.c new file mode 100644 index 000000000..f1a55da42 --- /dev/null +++ b/ndk/sources/android/libportable/arch-x86_64/fenv.c @@ -0,0 +1,182 @@ +/* + * Copyright 2014, 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. + */ + + +#include + +#include +#include +#include +#include + +#ifndef _ROUND_MASK +#define FE_TONEAREST 0x0000 +#define FE_DOWNWARD 0x0400 +#define FE_UPWARD 0x0800 +#define FE_TOWARDZERO 0x0c00 +#define _ROUND_MASK (FE_TONEAREST | FE_DOWNWARD | \ + FE_UPWARD | FE_TOWARDZERO) +#endif + +static inline int x86_64_change_except(int flag) { + int x86_64flag = 0; + int exception = flag & FE_ALL_EXCEPT_PORTABLE; + + if (exception & FE_INVALID_PORTABLE) + x86_64flag |= FE_INVALID; + if (exception & FE_DIVBYZERO_PORTABLE) + x86_64flag |= FE_DIVBYZERO; + if (exception & FE_OVERFLOW_PORTABLE) + x86_64flag |= FE_OVERFLOW; + if (exception & FE_UNDERFLOW_PORTABLE) + x86_64flag |= FE_UNDERFLOW; + if (exception & FE_INEXACT_PORTABLE) + x86_64flag |= FE_INEXACT; + + return x86_64flag; +} + +static inline int x86_64_change_rounding(int flag) { + int x86_64flag = 0; + int rounding = flag & 0x03; + + switch(rounding) { + case FE_TONEAREST_PORTABLE: { + x86_64flag = FE_TONEAREST; + break; + } + case FE_DOWNWARD_PORTABLE: { + x86_64flag = FE_DOWNWARD; + break; + } + case FE_UPWARD_PORTABLE: { + x86_64flag = FE_UPWARD; + break; + } + case FE_TOWARDZERO_PORTABLE: { + x86_64flag = FE_TOWARDZERO; + break; + } + } + + return x86_64flag; +} + +static inline int x86_64_get_except(int x86_64flag) { + int flag = 0; + int exception = x86_64flag & FE_ALL_EXCEPT; + + if (exception & FE_INVALID) + flag |= FE_INVALID_PORTABLE; + if (exception & FE_DIVBYZERO) + flag |= FE_DIVBYZERO_PORTABLE; + if (exception & FE_OVERFLOW) + flag |= FE_OVERFLOW_PORTABLE; + if (exception & FE_UNDERFLOW) + flag |= FE_UNDERFLOW_PORTABLE; + if (exception & FE_INEXACT) + flag |= FE_INEXACT_PORTABLE; + + return flag; +} + +static inline int x86_64_get_rounding(int x86_64flag) { + int flag = 0; + int rounding = x86_64flag & _ROUND_MASK; + + switch(rounding) { + case FE_TONEAREST: { + flag = FE_TONEAREST_PORTABLE; + break; + } + case FE_DOWNWARD: { + flag = FE_DOWNWARD_PORTABLE; + break; + } + case FE_UPWARD: { + flag = FE_UPWARD_PORTABLE; + break; + } + case FE_TOWARDZERO: { + flag = FE_TOWARDZERO_PORTABLE; + break; + } + } + + return flag; +} + + +int WRAP(feclearexcept)(int flag) { + return REAL(feclearexcept)(x86_64_change_except(flag)); +} + +#ifdef __LP64__ +int WRAP(fegetexceptflag)(fexcept_t_portable *obj, int flag) { + int ret = REAL(fegetexceptflag)((fexcept_t*)obj, x86_64_change_except(flag)); + *obj = (fexcept_t_portable) x86_64_get_except(*obj); + return ret; +} + +int WRAP(fesetexceptflag)(const fexcept_t_portable *obj, int flag) { + const fexcept_t x86_64obj = x86_64_change_except(*obj); + int x86_64flag = x86_64_change_except(flag); + return REAL(fesetexceptflag)(&x86_64obj, x86_64flag); +} +#endif + +int WRAP(feraiseexcept)(int flag) { + return REAL(feraiseexcept)(x86_64_change_except(flag)); +} + + +int WRAP(fetestexcept)(int flag) { + int ret = REAL(fetestexcept)(x86_64_change_except(flag)); + return x86_64_get_except(ret); +} + +int WRAP(fegetround)(void) { + int round = REAL(fegetround)(); + return x86_64_get_rounding(round); +} + +int WRAP(fesetround)(int round) { + return REAL(fesetround)(x86_64_change_rounding(round)); +} + +#ifdef __LP64__ +int WRAP(fegetenv)(fenv_t_portable *obj) { + return REAL(fegetenv)((fenv_t*)obj); +} + +int WRAP(feholdexcept)(fenv_t_portable *obj) { + return REAL(feholdexcept)((fenv_t*)obj); +} + +int WRAP(fesetenv)(const fenv_t_portable *obj) { + return REAL(fesetenv)((const fenv_t*)obj); +} + +int WRAP(feupdateenv)(const fenv_t_portable *obj) { + return REAL(feupdateenv)((const fenv_t*)obj); +} +#endif + +int WRAP(fegetexcept)(void) { + int flag = REAL(fegetexcept)(); + return x86_64_get_except(flag); +} + diff --git a/ndk/sources/android/libportable/arch-x86_64/stat.c b/ndk/sources/android/libportable/arch-x86_64/stat.c new file mode 100644 index 000000000..dd128bce9 --- /dev/null +++ b/ndk/sources/android/libportable/arch-x86_64/stat.c @@ -0,0 +1,65 @@ +/* + * Copyright 2014, 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. + */ + +#include +#include +#include + + +int WRAP(fstat)(int fd, struct stat_portable *s) { + struct stat x86_64_stat; + int ret = REAL(fstat)(fd, &x86_64_stat); + stat_ntop(&x86_64_stat, s); + return ret; +} +static inline int WRAP(fstat64)(int fd, struct stat64_portable *s) { + return WRAP(fstat)(fd, (struct stat_portable*)s); +} + + +int WRAP(fstatat)(int dirfd, const char *path, struct stat_portable *s, int flags) { + struct stat x86_64_stat; + int ret = REAL(fstatat)(dirfd, path, &x86_64_stat, flags); + stat_ntop(&x86_64_stat, s); + return ret; +} +static inline int WRAP(fstatat64)(int dirfd, const char *path, + struct stat64_portable *s, int flags) { + return WRAP(fstatat)(dirfd, path, (struct stat_portable*)s, flags); +} + + +int WRAP(lstat)(const char *path, struct stat_portable *s) { + struct stat x86_64_stat; + int ret = REAL(lstat)(path, &x86_64_stat); + stat_ntop(&x86_64_stat, s); + return ret; +} +static inline int WRAP(lstat64)(const char *path, struct stat64_portable *s) { + return WRAP(lstat)(path, (struct stat_portable*)s); +} + + +int WRAP(stat)(const char* path, struct stat_portable* s) { + struct stat x86_64_stat; + int ret = REAL(stat)(path, &x86_64_stat); + stat_ntop(&x86_64_stat, s); + return ret; +} +static inline int WRAP(stat64)(const char* path, struct stat64_portable *s) { + return WRAP(stat)(path, (struct stat_portable*)s); +} + diff --git a/ndk/sources/android/libportable/arch-x86_64/va_funcs.c b/ndk/sources/android/libportable/arch-x86_64/va_funcs.c new file mode 100644 index 000000000..d27aaa007 --- /dev/null +++ b/ndk/sources/android/libportable/arch-x86_64/va_funcs.c @@ -0,0 +1,50 @@ +/* + * Copyright 2014, 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. + */ + +#include +#include +#include + +#include + +int WRAP(vfprintf)(FILE *stream, const char *format, va_list_portable *arg) { + return REAL(vfprintf)(stream, format, arg); +} + +int WRAP(vfscanf)(FILE *stream, const char *format, va_list_portable *arg) { + return REAL(vfscanf)(stream, format, arg); +} + +int WRAP(vprintf)(const char *format, va_list_portable *arg) { + return REAL(vprintf)(format, arg); +} + +int WRAP(vscanf)(const char *format, va_list_portable *arg) { + return REAL(vscanf)(format, arg); +} + +int WRAP(vsnprintf)(char *s, size_t n, const char *format, va_list_portable *arg) { + return REAL(vsnprintf)(s, n, format, arg); +} + +int WRAP(vsprintf)(char *s, const char *format, va_list_portable *arg) { + return REAL(vsprintf)(s, format, arg); +} + +int WRAP(vsscanf)(const char *s, const char *format, va_list_portable *arg) { + return REAL(vsscanf)(s, format, arg); +} + diff --git a/ndk/sources/android/libportable/arch-x86_64/vfs.c b/ndk/sources/android/libportable/arch-x86_64/vfs.c new file mode 100644 index 000000000..94d6793b3 --- /dev/null +++ b/ndk/sources/android/libportable/arch-x86_64/vfs.c @@ -0,0 +1,18 @@ +/* + * Copyright 2012, 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. + */ + +#include +#include diff --git a/ndk/sources/android/libportable/common/include/fenv_portable.h b/ndk/sources/android/libportable/common/include/fenv_portable.h index 902c141ae..1d1e500eb 100644 --- a/ndk/sources/android/libportable/common/include/fenv_portable.h +++ b/ndk/sources/android/libportable/common/include/fenv_portable.h @@ -19,6 +19,13 @@ #include +#ifdef __LP64__ +typedef struct { + unsigned char a[28]; // x86_64 largest size +} fenv_t_portable; +typedef __uint32_t fexcept_t_portable; +#endif + /* Exception flags. */ #define FE_INVALID_PORTABLE 0x01 #define FE_DIVBYZERO_PORTABLE 0x02 diff --git a/ndk/sources/android/libportable/common/include/portability.h b/ndk/sources/android/libportable/common/include/portability.h index 54f140618..b15764571 100644 --- a/ndk/sources/android/libportable/common/include/portability.h +++ b/ndk/sources/android/libportable/common/include/portability.h @@ -17,6 +17,7 @@ #ifndef _PORTABILITY_H_ #define _PORTABILITY_H_ +#include #include "asm-generic/portability.h" /* * Common portability helper routines @@ -35,7 +36,7 @@ inline static int invalid_pointer(void *p) return p == 0 || p == (void *)-1 #ifdef __mips__ - || (int)p < 0 + || (intptr_t)p < 0 #endif ; } diff --git a/ndk/sources/android/libportable/common/include/stat_portable.h b/ndk/sources/android/libportable/common/include/stat_portable.h index d50291d03..fb9671de8 100644 --- a/ndk/sources/android/libportable/common/include/stat_portable.h +++ b/ndk/sources/android/libportable/common/include/stat_portable.h @@ -20,6 +20,59 @@ #include #include +#ifdef __LP64__ + +#define __STAT64_BODY_PORTABLE \ + unsigned long st_dev; \ + unsigned long st_ino; \ + unsigned int st_mode; \ + unsigned int st_nlink; \ + uid_t st_uid; \ + gid_t st_gid; \ + unsigned long st_rdev; \ + unsigned long __pad1; \ + long st_size; \ + int st_blksize; \ + int __pad2; \ + long st_blocks; \ + long st_atime; \ + unsigned long st_atime_nsec; \ + long st_mtime; \ + unsigned long st_mtime_nsec; \ + long st_ctime; \ + unsigned long st_ctime_nsec; \ + unsigned int __unused4; \ + unsigned int __unused5; \ + unsigned long __unused_for_largest_size; \ + + +struct stat_portable { __STAT64_BODY_PORTABLE }; +struct stat64_portable { __STAT64_BODY_PORTABLE }; + +static inline +void stat_ntop(struct stat *n_stat, struct stat_portable *p_stat) +{ + memset(p_stat, '\0', sizeof(struct stat_portable)); + p_stat->st_dev = n_stat->st_dev; + p_stat->st_ino = n_stat->st_ino; + p_stat->st_mode = n_stat->st_mode; + p_stat->st_nlink = n_stat->st_nlink; + p_stat->st_uid = n_stat->st_uid; + p_stat->st_gid = n_stat->st_gid; + p_stat->st_rdev = n_stat->st_rdev; + p_stat->st_size = n_stat->st_size; + p_stat->st_blksize = n_stat->st_blksize; + p_stat->st_blocks = n_stat->st_blocks; + p_stat->st_atime = n_stat->st_atime; + p_stat->st_atime_nsec = n_stat->st_atime_nsec; + p_stat->st_mtime = n_stat->st_mtime; + p_stat->st_mtime_nsec = n_stat->st_mtime_nsec; + p_stat->st_ctime = n_stat->st_ctime; + p_stat->st_ctime_nsec = n_stat->st_ctime_nsec; +} + +#else // ! __LP64__ + /* It's easy to change kernel to support stat */ struct stat_portable { unsigned long long st_dev; @@ -148,4 +201,6 @@ static inline void stat_ntop(struct stat *n_stat, struct stat_portable *p_stat) p_stat->st_ino = n_stat->st_ino; } +#endif // __LP64__ + #endif /* _STAT_PORTABLE_H */ diff --git a/ndk/sources/android/libportable/common/include/stdarg_portable.h b/ndk/sources/android/libportable/common/include/stdarg_portable.h new file mode 100644 index 000000000..726ed1150 --- /dev/null +++ b/ndk/sources/android/libportable/common/include/stdarg_portable.h @@ -0,0 +1,30 @@ +/* + * Copyright 2014, 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. + */ + +#ifndef _STDARG_PORTABLE_H_ +#define _STDARG_PORTABLE_H_ + +// The elements are not important. This struct should be interpreted +// differently by all targets. +typedef struct va_list_portable { + void *ptr1; + void *ptr2; + void *ptr3; + int offset1; + int offset2; +} va_list_portable; + +#endif /* _STDARG_PORTABLE_H_ */ diff --git a/ndk/sources/android/libportable/common/include/vfs_portable.h b/ndk/sources/android/libportable/common/include/vfs_portable.h new file mode 100644 index 000000000..762ce0c85 --- /dev/null +++ b/ndk/sources/android/libportable/common/include/vfs_portable.h @@ -0,0 +1,96 @@ +/* + * Copyright 2014, 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. + */ + +#ifndef _VFS_PORTABLE_H +#define _VFS_PORTABLE_H + +#include +#include + +/* The kernel's __kernel_fsid_t has a 'val' member but glibc uses '__val'. */ +typedef struct { int __val[2]; } __fsid_t_portable; +typedef __fsid_t_portable fsid_t_portable; + +#define __STATFS64_BODY_PORTABLE \ + uint64_t f_type; \ + uint64_t f_bsize; \ + uint64_t f_blocks; \ + uint64_t f_bfree; \ + uint64_t f_bavail; \ + uint64_t f_files; \ + uint64_t f_ffree; \ + fsid_t_portable f_fsid; \ + uint64_t f_namelen; \ + uint64_t f_frsize; \ + uint64_t f_flags; \ + uint64_t f_spare[5]; \ + + +struct statfs_portable { __STATFS64_BODY_PORTABLE }; +struct statfs64_portable { __STATFS64_BODY_PORTABLE }; + +static inline +void statfs_ntop(struct statfs *n_statfs, struct statfs_portable *p_statfs) { + memset(p_statfs, 0, sizeof(struct statfs_portable)); + p_statfs->f_type = n_statfs->f_type; + p_statfs->f_bsize = n_statfs->f_bsize; + p_statfs->f_blocks = n_statfs->f_blocks; + p_statfs->f_bfree = n_statfs->f_bfree; + p_statfs->f_bavail = n_statfs->f_bavail; + p_statfs->f_files = n_statfs->f_files; + p_statfs->f_ffree = n_statfs->f_ffree; + memcpy(&p_statfs->f_fsid, &n_statfs->f_fsid, sizeof(int)*2); + p_statfs->f_namelen = n_statfs->f_namelen; + p_statfs->f_frsize = n_statfs->f_frsize; + p_statfs->f_flags = n_statfs->f_flags; +#ifdef __mips__ + memcpy(&p_statfs->f_spare, &n_statfs->f_spare, 4); +#else + memcpy(&p_statfs->f_spare, &n_statfs->f_spare, 5); +#endif +} + + +static inline +int WRAP(statfs)(const char* path, struct statfs_portable* stat) { + struct statfs native_stat; + + int ret = REAL(statfs)(path, &native_stat); + statfs_ntop(&native_stat, stat); + return ret; +} + +static inline +int WRAP(statfs64)(const char* path, struct statfs64_portable* stat) { + return WRAP(statfs)(path, (struct statfs_portable*)stat); +} + + +static inline +int WRAP(fstatfs)(int fd, struct statfs_portable* stat) { + struct statfs native_stat; + + int ret = REAL(fstatfs)(fd, &native_stat); + statfs_ntop(&native_stat, stat); + return ret; +} + +static inline +int WRAP(fstatfs64)(int fd, struct statfs64_portable* stat) { + return WRAP(fstatfs)(fd, (struct statfs_portable*)stat); +} + +#endif