LineageOS/android_development
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge "Implement libportable for unknown arch 64bit."

Browse Source
This commit is contained in:
Andrew Hsieh
2014-04-10 02:42:31 +00:00
committed by Gerrit Code Review
parent 6c56e9e104 859559268d
commit 2d2e407f1f
16 changed files with 1082 additions and 56 deletions
Download Patch File Download Diff File Expand all files Collapse all files

60
ndk/sources/android/libportable/Android.mk
View File

@@ -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

18
ndk/sources/android/libportable/arch-arm64/vfs.c Normal file
View File

@@ -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 <portability.h>
#include <vfs_portable.h>

160
ndk/sources/android/libportable/arch-mips64/fenv.c Normal file
View File

@@ -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 <portability.h>
#include <sys/types.h>
#include <fenv.h>
#include <fenv_portable.h>
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);
}

261
ndk/sources/android/libportable/arch-mips64/socket.c Normal file
View File

@@ -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 <portability.h>
#include <unistd.h>
#include <sys/socket.h>
#include <fcntl.h>
#include <netdb.h>
#include <socket_portable.h>
#include <fcntl_portable.h>
#include <netdb_portable.h>
#include <portability.h>
#define PORTABLE_TAG "socket_portable"
#include <log_portable.h>
#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;
}

65
ndk/sources/android/libportable/arch-mips64/stat.c Normal file
View File

@@ -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 <portability.h>
#include <stat_portable.h>
#include <sys/stat.h>
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);
}

50
ndk/sources/android/libportable/arch-mips64/va_funcs.c Normal file
View File

@@ -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 <portability.h>
#include <stdarg.h>
#include <stdarg_portable.h>
#include <stdio.h>
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);
}

18
ndk/sources/android/libportable/arch-mips64/vfs.c Normal file
View File

@@ -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 <portability.h>
#include <vfs_portable.h>

182
ndk/sources/android/libportable/arch-x86_64/fenv.c Normal file
View File

@@ -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 <portability.h>
#include <sys/cdefs.h>
#include <sys/types.h>
#include <fenv.h>
#include <fenv_portable.h>
#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);
}

65
ndk/sources/android/libportable/arch-x86_64/stat.c Normal file
View File

@@ -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 <portability.h>
#include <stat_portable.h>
#include <sys/stat.h>
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);
}

50
ndk/sources/android/libportable/arch-x86_64/va_funcs.c Normal file
View File

@@ -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 <portability.h>
#include <stdarg.h>
#include <stdarg_portable.h>
#include <stdio.h>
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);
}

18
ndk/sources/android/libportable/arch-x86_64/vfs.c Normal file
View File

@@ -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 <portability.h>
#include <vfs_portable.h>

7
ndk/sources/android/libportable/common/include/fenv_portable.h
View File

@@ -19,6 +19,13 @@
#include <sys/types.h>
#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

3
ndk/sources/android/libportable/common/include/portability.h
View File

@@ -17,6 +17,7 @@
#ifndef _PORTABILITY_H_
#define _PORTABILITY_H_
#include <stdint.h>
#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
;
}

55
ndk/sources/android/libportable/common/include/stat_portable.h
View File

@@ -20,6 +20,59 @@
#include <sys/stat.h>
#include <string.h>
#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 */

30
ndk/sources/android/libportable/common/include/stdarg_portable.h Normal file
View File

@@ -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_ */

96
ndk/sources/android/libportable/common/include/vfs_portable.h Normal file
View File

@@ -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 <stdlib.h>
#include <sys/vfs.h>
/* 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