Sign Up
Log In
Log In
or
Sign Up
Places
All Projects
Status Monitor
Collapse sidebar
home:Ledest:erlang:19
erlang
otp_src_19.2-erts-symbols.patch
Overview
Repositories
Revisions
Requests
Users
Attributes
Meta
File otp_src_19.2-erts-symbols.patch of Package erlang
diff -Ndurp otp_src_19.2/erts/emulator/beam/erl_async.c otp_src_19.2-erts-symbols/erts/emulator/beam/erl_async.c --- otp_src_19.2/erts/emulator/beam/erl_async.c 2016-12-09 12:45:24.000000000 +0200 +++ otp_src_19.2-erts-symbols/erts/emulator/beam/erl_async.c 2017-01-01 23:26:54.489659371 +0200 @@ -625,7 +625,7 @@ int erts_async_ready_clean(void *varq, v ** The port data gives a fair distribution grom port pointer ** to unsigned integer - to be used in key for driver_async below. */ -unsigned int driver_async_port_key(ErlDrvPort port) +unsigned int __attribute__((externally_visible)) driver_async_port_key(ErlDrvPort port) { ErlDrvTermData td = driver_mk_port(port); if (td == (ErlDrvTermData) NIL) { @@ -648,9 +648,8 @@ unsigned int driver_async_port_key(ErlDr ** async_data data to pass to invoke function ** async_free function for relase async_data in case of failure */ -long driver_async(ErlDrvPort ix, unsigned int* key, - void (*async_invoke)(void*), void* async_data, - void (*async_free)(void*)) +long __attribute__((externally_visible)) +driver_async(ErlDrvPort ix, unsigned int* key, void (*async_invoke)(void*), void* async_data, void (*async_free)(void*)) { ErtsAsync* a; Port* prt; diff -Ndurp otp_src_19.2/erts/emulator/beam/erl_drv_thread.c otp_src_19.2-erts-symbols/erts/emulator/beam/erl_drv_thread.c --- otp_src_19.2/erts/emulator/beam/erl_drv_thread.c 2016-12-09 12:45:24.000000000 +0200 +++ otp_src_19.2-erts-symbols/erts/emulator/beam/erl_drv_thread.c 2017-01-01 23:26:54.490659344 +0200 @@ -149,7 +149,7 @@ void erl_drv_thr_init(void) * either the erl_threads.h, the erl_smp.h or the ethread.h interface. */ -ErlDrvMutex * +ErlDrvMutex * __attribute__((externally_visible)) erl_drv_mutex_create(char *name) { #ifdef USE_THREADS @@ -176,7 +176,7 @@ erl_drv_mutex_create(char *name) #endif } -void +void __attribute__((externally_visible)) erl_drv_mutex_destroy(ErlDrvMutex *dmtx) { #ifdef USE_THREADS @@ -188,7 +188,7 @@ erl_drv_mutex_destroy(ErlDrvMutex *dmtx) } -char * +char * __attribute__((externally_visible)) erl_drv_mutex_name(ErlDrvMutex *dmtx) { #ifdef USE_THREADS @@ -198,7 +198,7 @@ erl_drv_mutex_name(ErlDrvMutex *dmtx) #endif } -int +int __attribute__((externally_visible)) erl_drv_mutex_trylock(ErlDrvMutex *dmtx) { #ifdef USE_THREADS @@ -210,7 +210,7 @@ erl_drv_mutex_trylock(ErlDrvMutex *dmtx) #endif } -void +void __attribute__((externally_visible)) erl_drv_mutex_lock(ErlDrvMutex *dmtx) { #ifdef USE_THREADS @@ -220,7 +220,7 @@ erl_drv_mutex_lock(ErlDrvMutex *dmtx) #endif } -void +void __attribute__((externally_visible)) erl_drv_mutex_unlock(ErlDrvMutex *dmtx) { #ifdef USE_THREADS @@ -230,7 +230,7 @@ erl_drv_mutex_unlock(ErlDrvMutex *dmtx) #endif } -ErlDrvCond * +ErlDrvCond * __attribute__((externally_visible)) erl_drv_cond_create(char *name) { #ifdef USE_THREADS @@ -257,7 +257,7 @@ erl_drv_cond_create(char *name) #endif } -void +void __attribute__((externally_visible)) erl_drv_cond_destroy(ErlDrvCond *dcnd) { #ifdef USE_THREADS @@ -268,7 +268,7 @@ erl_drv_cond_destroy(ErlDrvCond *dcnd) #endif } -char * +char * __attribute__((externally_visible)) erl_drv_cond_name(ErlDrvCond *dcnd) { #ifdef USE_THREADS @@ -278,7 +278,7 @@ erl_drv_cond_name(ErlDrvCond *dcnd) #endif } -void +void __attribute__((externally_visible)) erl_drv_cond_signal(ErlDrvCond *dcnd) { #ifdef USE_THREADS @@ -288,7 +288,7 @@ erl_drv_cond_signal(ErlDrvCond *dcnd) #endif } -void +void __attribute__((externally_visible)) erl_drv_cond_broadcast(ErlDrvCond *dcnd) { #ifdef USE_THREADS @@ -299,7 +299,7 @@ erl_drv_cond_broadcast(ErlDrvCond *dcnd) } -void +void __attribute__((externally_visible)) erl_drv_cond_wait(ErlDrvCond *dcnd, ErlDrvMutex *dmtx) { #ifdef USE_THREADS @@ -314,7 +314,7 @@ erl_drv_cond_wait(ErlDrvCond *dcnd, ErlD #endif } -ErlDrvRWLock * +ErlDrvRWLock * __attribute__((externally_visible)) erl_drv_rwlock_create(char *name) { #ifdef USE_THREADS @@ -339,7 +339,7 @@ erl_drv_rwlock_create(char *name) #endif } -void +void __attribute__((externally_visible)) erl_drv_rwlock_destroy(ErlDrvRWLock *drwlck) { #ifdef USE_THREADS @@ -350,7 +350,7 @@ erl_drv_rwlock_destroy(ErlDrvRWLock *drw #endif } -char * +char * __attribute__((externally_visible)) erl_drv_rwlock_name(ErlDrvRWLock *drwlck) { #ifdef USE_THREADS @@ -360,7 +360,7 @@ erl_drv_rwlock_name(ErlDrvRWLock *drwlck #endif } -int +int __attribute__((externally_visible)) erl_drv_rwlock_tryrlock(ErlDrvRWLock *drwlck) { #ifdef USE_THREADS @@ -372,7 +372,7 @@ erl_drv_rwlock_tryrlock(ErlDrvRWLock *dr #endif } -void +void __attribute__((externally_visible)) erl_drv_rwlock_rlock(ErlDrvRWLock *drwlck) { #ifdef USE_THREADS @@ -382,7 +382,7 @@ erl_drv_rwlock_rlock(ErlDrvRWLock *drwlc #endif } -void +void __attribute__((externally_visible)) erl_drv_rwlock_runlock(ErlDrvRWLock *drwlck) { #ifdef USE_THREADS @@ -392,7 +392,7 @@ erl_drv_rwlock_runlock(ErlDrvRWLock *drw #endif } -int +int __attribute__((externally_visible)) erl_drv_rwlock_tryrwlock(ErlDrvRWLock *drwlck) { #ifdef USE_THREADS @@ -404,7 +404,7 @@ erl_drv_rwlock_tryrwlock(ErlDrvRWLock *d #endif } -void +void __attribute__((externally_visible)) erl_drv_rwlock_rwlock(ErlDrvRWLock *drwlck) { #ifdef USE_THREADS @@ -414,7 +414,7 @@ erl_drv_rwlock_rwlock(ErlDrvRWLock *drwl #endif } -void +void __attribute__((externally_visible)) erl_drv_rwlock_rwunlock(ErlDrvRWLock *drwlck) { #ifdef USE_THREADS @@ -424,7 +424,7 @@ erl_drv_rwlock_rwunlock(ErlDrvRWLock *dr #endif } -int +int __attribute__((externally_visible)) erl_drv_tsd_key_create(char *name, ErlDrvTSDKey *key) { char *name_copy; @@ -496,7 +496,7 @@ erl_drv_tsd_key_create(char *name, ErlDr return res; } -void +void __attribute__((externally_visible)) erl_drv_tsd_key_destroy(ErlDrvTSDKey key) { erts_mtx_lock(&tsd_mtx); @@ -523,7 +523,7 @@ erl_drv_tsd_key_destroy(ErlDrvTSDKey key #define ERL_DRV_TSD_LEN__ (tsd_len) #endif -void +void __attribute__((externally_visible)) erl_drv_tsd_set(ErlDrvTSDKey key, void *data) { #ifdef USE_THREADS @@ -553,7 +553,7 @@ erl_drv_tsd_set(ErlDrvTSDKey key, void * ERL_DRV_TSD__[key] = data; } -void * +void * __attribute__((externally_visible)) erl_drv_tsd_get(ErlDrvTSDKey key) { #ifdef USE_THREADS @@ -573,7 +573,7 @@ erl_drv_tsd_get(ErlDrvTSDKey key) #undef ERL_DRV_TSD_LEN__ #undef ERL_DRV_TSD__ -ErlDrvThreadOpts * +ErlDrvThreadOpts * __attribute__((externally_visible)) erl_drv_thread_opts_create(char *name) { ErlDrvThreadOpts *opts = erts_alloc_fnf(ERTS_ALC_T_DRV_THR_OPTS, @@ -584,7 +584,7 @@ erl_drv_thread_opts_create(char *name) return opts; } -void +void __attribute__((externally_visible)) erl_drv_thread_opts_destroy(ErlDrvThreadOpts *opts) { if (!opts) @@ -592,7 +592,7 @@ erl_drv_thread_opts_destroy(ErlDrvThread erts_free(ERTS_ALC_T_DRV_THR_OPTS, opts); } -int +int __attribute__((externally_visible)) erl_drv_thread_create(char *name, ErlDrvTid *tid, void* (*func)(void*), @@ -646,7 +646,7 @@ erl_drv_thread_create(char *name, #endif } -char * +char * __attribute__((externally_visible)) erl_drv_thread_name(ErlDrvTid tid) { #ifdef USE_THREADS @@ -658,7 +658,7 @@ erl_drv_thread_name(ErlDrvTid tid) } -ErlDrvTid +ErlDrvTid __attribute__((externally_visible)) erl_drv_thread_self(void) { #ifdef USE_THREADS @@ -685,7 +685,7 @@ erl_drv_thread_self(void) #endif } -int +int __attribute__((externally_visible)) erl_drv_equal_tids(ErlDrvTid tid1, ErlDrvTid tid2) { #ifdef USE_THREADS @@ -707,7 +707,7 @@ erl_drv_equal_tids(ErlDrvTid tid1, ErlDr #endif } -void +void __attribute__((externally_visible)) erl_drv_thread_exit(void *res) { #ifdef USE_THREADS @@ -720,7 +720,7 @@ erl_drv_thread_exit(void *res) fatal_error(EACCES, "erl_drv_thread_exit()"); } -int +int __attribute__((externally_visible)) erl_drv_thread_join(ErlDrvTid tid, void **respp) { #ifdef USE_THREADS diff -Ndurp otp_src_19.2/erts/emulator/beam/erl_init.c otp_src_19.2-erts-symbols/erts/emulator/beam/erl_init.c --- otp_src_19.2/erts/emulator/beam/erl_init.c 2016-12-09 12:45:24.000000000 +0200 +++ otp_src_19.2-erts-symbols/erts/emulator/beam/erl_init.c 2017-01-01 23:28:03.796747343 +0200 @@ -2411,7 +2411,7 @@ __decl_noreturn void __noreturn erts_exi } /* Exit without flushing async threads */ -__decl_noreturn void __noreturn erts_exit(int n, char *fmt, ...) +__decl_noreturn void __attribute__((externally_visible)) __noreturn erts_exit(int n, char *fmt, ...) { va_list args1, args2; va_start(args1, fmt); diff -Ndurp otp_src_19.2/erts/emulator/beam/erl_nif.c otp_src_19.2-erts-symbols/erts/emulator/beam/erl_nif.c --- otp_src_19.2/erts/emulator/beam/erl_nif.c 2016-12-09 12:45:24.000000000 +0200 +++ otp_src_19.2-erts-symbols/erts/emulator/beam/erl_nif.c 2017-01-01 23:26:54.492659289 +0200 @@ -425,22 +425,22 @@ static void cache_env(ErlNifEnv* env) env->hp_end = env->heap_frag->mem + env->heap_frag->alloc_size; } } -void* enif_priv_data(ErlNifEnv* env) +void* __attribute__((externally_visible)) enif_priv_data(ErlNifEnv* env) { return env->mod_nif->priv_data; } -void* enif_alloc(size_t size) +void* __attribute__((externally_visible)) enif_alloc(size_t size) { return erts_alloc_fnf(ERTS_ALC_T_NIF, (Uint) size); } -void* enif_realloc(void* ptr, size_t size) +void* __attribute__((externally_visible)) enif_realloc(void* ptr, size_t size) { return erts_realloc_fnf(ERTS_ALC_T_NIF, ptr, size); } -void enif_free(void* ptr) +void __attribute__((externally_visible)) enif_free(void* ptr) { erts_free(ERTS_ALC_T_NIF, ptr); } @@ -479,14 +479,14 @@ setup_nif_env(struct enif_msg_environmen msg_env->env.tracee = tracee; } -ErlNifEnv* enif_alloc_env(void) +ErlNifEnv* __attribute__((externally_visible)) enif_alloc_env(void) { struct enif_msg_environment_t* msg_env = erts_alloc_fnf(ERTS_ALC_T_NIF, sizeof(struct enif_msg_environment_t)); setup_nif_env(msg_env, NULL, NULL); return &msg_env->env; } -void enif_free_env(ErlNifEnv* env) +void __attribute__((externally_visible)) enif_free_env(ErlNifEnv* env) { enif_clear_env(env); erts_free(ERTS_ALC_T_NIF, env); @@ -512,7 +512,7 @@ static ERTS_INLINE void clear_offheap(Er oh->overhead = 0; } -void enif_clear_env(ErlNifEnv* env) +void __attribute__((externally_visible)) enif_clear_env(ErlNifEnv* env) { struct enif_msg_environment_t* menv = (struct enif_msg_environment_t*)env; Process* p = &menv->phony_proc; @@ -619,8 +619,8 @@ error: #endif -int enif_send(ErlNifEnv* env, const ErlNifPid* to_pid, - ErlNifEnv* msg_env, ERL_NIF_TERM msg) +int __attribute__((externally_visible)) +enif_send(ErlNifEnv* env, const ErlNifPid* to_pid, ErlNifEnv* msg_env, ERL_NIF_TERM msg) { struct enif_msg_environment_t* menv = (struct enif_msg_environment_t*)msg_env; ErtsProcLocks rp_locks = 0; @@ -800,7 +800,7 @@ done: return 1; } -int +int __attribute__((externally_visible)) enif_port_command(ErlNifEnv *env, const ErlNifPort* to_port, ErlNifEnv *msg_env, ERL_NIF_TERM msg) { @@ -845,7 +845,7 @@ enif_port_command(ErlNifEnv *env, const return res; } -ERL_NIF_TERM enif_make_copy(ErlNifEnv* dst_env, ERL_NIF_TERM src_term) +ERL_NIF_TERM __attribute__((externally_visible)) enif_make_copy(ErlNifEnv* dst_env, ERL_NIF_TERM src_term) { Uint sz; Eterm* hp; @@ -866,7 +866,7 @@ static int is_offheap(const ErlOffHeap* } #endif -ErlNifPid* enif_self(ErlNifEnv* caller_env, ErlNifPid* pid) +ErlNifPid* __attribute__((externally_visible)) enif_self(ErlNifEnv* caller_env, ErlNifPid* pid) { if (caller_env->proc->common.id == ERTS_INVALID_PID) return NULL; @@ -874,7 +874,7 @@ ErlNifPid* enif_self(ErlNifEnv* caller_e return pid; } -int enif_get_local_pid(ErlNifEnv* env, ERL_NIF_TERM term, ErlNifPid* pid) +int __attribute__((externally_visible)) enif_get_local_pid(ErlNifEnv* env, ERL_NIF_TERM term, ErlNifPid* pid) { if (is_internal_pid(term)) { pid->pid=term; @@ -883,7 +883,7 @@ int enif_get_local_pid(ErlNifEnv* env, E return 0; } -int enif_get_local_port(ErlNifEnv* env, ERL_NIF_TERM term, ErlNifPort* port) +int __attribute__((externally_visible)) enif_get_local_port(ErlNifEnv* env, ERL_NIF_TERM term, ErlNifPort* port) { if (is_internal_port(term)) { port->port_id=term; @@ -892,57 +892,57 @@ int enif_get_local_port(ErlNifEnv* env, return 0; } -int enif_is_atom(ErlNifEnv* env, ERL_NIF_TERM term) +int __attribute__((externally_visible)) enif_is_atom(ErlNifEnv* env, ERL_NIF_TERM term) { return is_atom(term); } -int enif_is_binary(ErlNifEnv* env, ERL_NIF_TERM term) +int __attribute__((externally_visible)) enif_is_binary(ErlNifEnv* env, ERL_NIF_TERM term) { return is_binary(term) && (binary_bitsize(term) % 8 == 0); } -int enif_is_empty_list(ErlNifEnv* env, ERL_NIF_TERM term) +int __attribute__((externally_visible)) enif_is_empty_list(ErlNifEnv* env, ERL_NIF_TERM term) { return is_nil(term); } -int enif_is_fun(ErlNifEnv* env, ERL_NIF_TERM term) +int __attribute__((externally_visible)) enif_is_fun(ErlNifEnv* env, ERL_NIF_TERM term) { return is_fun(term); } -int enif_is_pid(ErlNifEnv* env, ERL_NIF_TERM term) +int __attribute__((externally_visible)) enif_is_pid(ErlNifEnv* env, ERL_NIF_TERM term) { return is_pid(term); } -int enif_is_port(ErlNifEnv* env, ERL_NIF_TERM term) +int __attribute__((externally_visible)) enif_is_port(ErlNifEnv* env, ERL_NIF_TERM term) { return is_port(term); } -int enif_is_ref(ErlNifEnv* env, ERL_NIF_TERM term) +int __attribute__((externally_visible)) enif_is_ref(ErlNifEnv* env, ERL_NIF_TERM term) { return is_ref(term); } -int enif_is_tuple(ErlNifEnv* env, ERL_NIF_TERM term) +int __attribute__((externally_visible)) enif_is_tuple(ErlNifEnv* env, ERL_NIF_TERM term) { return is_tuple(term); } -int enif_is_list(ErlNifEnv* env, ERL_NIF_TERM term) +int __attribute__((externally_visible)) enif_is_list(ErlNifEnv* env, ERL_NIF_TERM term) { return is_list(term) || is_nil(term); } -int enif_is_exception(ErlNifEnv* env, ERL_NIF_TERM term) +int __attribute__((externally_visible)) enif_is_exception(ErlNifEnv* env, ERL_NIF_TERM term) { return env->exception_thrown && term == THE_NON_VALUE; } -int enif_is_number(ErlNifEnv* env, ERL_NIF_TERM term) +int __attribute__((externally_visible)) enif_is_number(ErlNifEnv* env, ERL_NIF_TERM term) { return is_number(term); } @@ -957,7 +957,7 @@ static void aligned_binary_dtor(struct e erts_free_aligned_binary_bytes_extra((byte*)obj, obj->allocator); } -int enif_inspect_binary(ErlNifEnv* env, Eterm bin_term, ErlNifBinary* bin) +int __attribute__((externally_visible)) enif_inspect_binary(ErlNifEnv* env, Eterm bin_term, ErlNifBinary* bin) { ErtsAlcType_t allocator = is_proc_bound(env) ? ERTS_ALC_T_TMP : ERTS_ALC_T_NIF; union { @@ -1000,7 +1000,7 @@ static void tmp_alloc_dtor(struct enif_t erts_free(obj->allocator, obj); } -int enif_inspect_iolist_as_binary(ErlNifEnv* env, Eterm term, ErlNifBinary* bin) +int __attribute__((externally_visible)) enif_inspect_iolist_as_binary(ErlNifEnv* env, Eterm term, ErlNifBinary* bin) { struct enif_tmp_obj_t* tobj; ErtsAlcType_t allocator; @@ -1035,7 +1035,7 @@ int enif_inspect_iolist_as_binary(ErlNif return 1; } -int enif_alloc_binary(size_t size, ErlNifBinary* bin) +int __attribute__((externally_visible)) enif_alloc_binary(size_t size, ErlNifBinary* bin) { Binary* refbin; @@ -1052,7 +1052,7 @@ int enif_alloc_binary(size_t size, ErlNi return 1; } -int enif_realloc_binary(ErlNifBinary* bin, size_t size) +int __attribute__((externally_visible)) enif_realloc_binary(ErlNifBinary* bin, size_t size) { if (bin->ref_bin != NULL) { Binary* oldbin; @@ -1077,7 +1077,7 @@ int enif_realloc_binary(ErlNifBinary* bi } -void enif_release_binary(ErlNifBinary* bin) +void __attribute__((externally_visible)) enif_release_binary(ErlNifBinary* bin) { if (bin->ref_bin != NULL) { Binary* refbin = bin->ref_bin; @@ -1093,8 +1093,8 @@ void enif_release_binary(ErlNifBinary* b #endif } -unsigned char* enif_make_new_binary(ErlNifEnv* env, size_t size, - ERL_NIF_TERM* termp) +unsigned char* __attribute__((externally_visible)) +enif_make_new_binary(ErlNifEnv* env, size_t size, ERL_NIF_TERM* termp) { flush_env(env); *termp = new_binary(env->proc, NULL, size); @@ -1102,8 +1102,8 @@ unsigned char* enif_make_new_binary(ErlN return binary_bytes(*termp); } -int enif_term_to_binary(ErlNifEnv *dst_env, ERL_NIF_TERM term, - ErlNifBinary *bin) +int __attribute__((externally_visible)) +enif_term_to_binary(ErlNifEnv *dst_env, ERL_NIF_TERM term, ErlNifBinary *bin) { Sint size; byte *bp; @@ -1127,11 +1127,8 @@ int enif_term_to_binary(ErlNifEnv *dst_e return 1; } -size_t enif_binary_to_term(ErlNifEnv *dst_env, - const unsigned char* data, - size_t data_sz, - ERL_NIF_TERM *term, - ErlNifBinaryToTerm opts) +size_t __attribute__((externally_visible)) +enif_binary_to_term(ErlNifEnv *dst_env, const unsigned char* data, size_t data_sz, ERL_NIF_TERM *term, ErlNifBinaryToTerm opts) { Sint size; ErtsHeapFactory factory; @@ -1164,12 +1161,12 @@ size_t enif_binary_to_term(ErlNifEnv *ds return bp - data; } -int enif_is_identical(Eterm lhs, Eterm rhs) +int __attribute__((externally_visible)) enif_is_identical(Eterm lhs, Eterm rhs) { return EQ(lhs,rhs); } -int enif_compare(Eterm lhs, Eterm rhs) +int __attribute__((externally_visible)) enif_compare(Eterm lhs, Eterm rhs) { Sint result = CMP(lhs,rhs); @@ -1182,7 +1179,7 @@ int enif_compare(Eterm lhs, Eterm rhs) return result; } -int enif_get_tuple(ErlNifEnv* env, Eterm tpl, int* arity, const Eterm** array) +int __attribute__((externally_visible)) enif_get_tuple(ErlNifEnv* env, Eterm tpl, int* arity, const Eterm** array) { Eterm* ptr; if (is_not_tuple(tpl)) { @@ -1194,8 +1191,8 @@ int enif_get_tuple(ErlNifEnv* env, Eterm return 1; } -int enif_get_string(ErlNifEnv *env, ERL_NIF_TERM list, char* buf, unsigned len, - ErlNifCharEncoding encoding) +int __attribute__((externally_visible)) +enif_get_string(ErlNifEnv *env, ERL_NIF_TERM list, char* buf, unsigned len, ErlNifCharEncoding encoding) { Eterm* listptr; int n = 0; @@ -1226,7 +1223,7 @@ int enif_get_string(ErlNifEnv *env, ERL_ return n + 1; } -Eterm enif_make_binary(ErlNifEnv* env, ErlNifBinary* bin) +Eterm __attribute__((externally_visible)) enif_make_binary(ErlNifEnv* env, ErlNifBinary* bin) { if (bin->bin_term != THE_NON_VALUE) { return bin->bin_term; @@ -1263,8 +1260,8 @@ Eterm enif_make_binary(ErlNifEnv* env, E } } -Eterm enif_make_sub_binary(ErlNifEnv* env, ERL_NIF_TERM bin_term, - size_t pos, size_t size) +Eterm __attribute__((externally_visible)) +enif_make_sub_binary(ErlNifEnv* env, ERL_NIF_TERM bin_term, size_t pos, size_t size) { ErlSubBin* sb; Eterm orig; @@ -1291,12 +1288,12 @@ Eterm enif_make_sub_binary(ErlNifEnv* en } -Eterm enif_make_badarg(ErlNifEnv* env) +Eterm __attribute__((externally_visible)) enif_make_badarg(ErlNifEnv* env) { return enif_raise_exception(env, am_badarg); } -Eterm enif_raise_exception(ErlNifEnv* env, ERL_NIF_TERM reason) +Eterm __attribute__((externally_visible)) enif_raise_exception(ErlNifEnv* env, ERL_NIF_TERM reason) { Process *c_p; @@ -1307,7 +1304,7 @@ Eterm enif_raise_exception(ErlNifEnv* en BIF_ERROR(c_p, EXC_ERROR); } -int enif_has_pending_exception(ErlNifEnv* env, ERL_NIF_TERM* reason) +int __attribute__((externally_visible)) enif_has_pending_exception(ErlNifEnv* env, ERL_NIF_TERM* reason) { if (env->exception_thrown && reason != NULL) { Process *c_p; @@ -1317,8 +1314,8 @@ int enif_has_pending_exception(ErlNifEnv return env->exception_thrown; } -int enif_get_atom(ErlNifEnv* env, Eterm atom, char* buf, unsigned len, - ErlNifCharEncoding encoding) +int __attribute__((externally_visible)) +enif_get_atom(ErlNifEnv* env, Eterm atom, char* buf, unsigned len, ErlNifCharEncoding encoding) { Atom* ap; ASSERT(encoding == ERL_NIF_LATIN1); @@ -1341,7 +1338,7 @@ int enif_get_atom(ErlNifEnv* env, Eterm return ap->latin1_chars + 1; } -int enif_get_int(ErlNifEnv* env, Eterm term, int* ip) +int __attribute__((externally_visible)) enif_get_int(ErlNifEnv* env, Eterm term, int* ip) { #if SIZEOF_INT == ERTS_SIZEOF_ETERM return term_to_Sint(term, (Sint*)ip); @@ -1358,7 +1355,7 @@ int enif_get_int(ErlNifEnv* env, Eterm t #endif } -int enif_get_uint(ErlNifEnv* env, Eterm term, unsigned* ip) +int __attribute__((externally_visible)) enif_get_uint(ErlNifEnv* env, Eterm term, unsigned* ip) { #if SIZEOF_INT == ERTS_SIZEOF_ETERM return term_to_Uint(term, (Uint*)ip); @@ -1373,7 +1370,7 @@ int enif_get_uint(ErlNifEnv* env, Eterm #endif } -int enif_get_long(ErlNifEnv* env, Eterm term, long* ip) +int __attribute__((externally_visible)) enif_get_long(ErlNifEnv* env, Eterm term, long* ip) { #if SIZEOF_LONG == ERTS_SIZEOF_ETERM return term_to_Sint(term, ip); @@ -1391,7 +1388,7 @@ int enif_get_long(ErlNifEnv* env, Eterm #endif } -int enif_get_ulong(ErlNifEnv* env, Eterm term, unsigned long* ip) +int __attribute__((externally_visible)) enif_get_ulong(ErlNifEnv* env, Eterm term, unsigned long* ip) { #if SIZEOF_LONG == ERTS_SIZEOF_ETERM return term_to_Uint(term, ip); @@ -1411,18 +1408,18 @@ int enif_get_ulong(ErlNifEnv* env, Eterm } #if HAVE_INT64 && SIZEOF_LONG != 8 -int enif_get_int64(ErlNifEnv* env, ERL_NIF_TERM term, ErlNifSInt64* ip) +int __attribute__((externally_visible)) enif_get_int64(ErlNifEnv* env, ERL_NIF_TERM term, ErlNifSInt64* ip) { return term_to_Sint64(term, ip); } -int enif_get_uint64(ErlNifEnv* env, ERL_NIF_TERM term, ErlNifUInt64* ip) +int __attribute__((externally_visible)) enif_get_uint64(ErlNifEnv* env, ERL_NIF_TERM term, ErlNifUInt64* ip) { return term_to_Uint64(term, ip); } #endif /* HAVE_INT64 && SIZEOF_LONG != 8 */ -int enif_get_double(ErlNifEnv* env, ERL_NIF_TERM term, double* dp) +int __attribute__((externally_visible)) enif_get_double(ErlNifEnv* env, ERL_NIF_TERM term, double* dp) { FloatDef f; if (is_not_float(term)) { @@ -1433,8 +1430,8 @@ int enif_get_double(ErlNifEnv* env, ERL_ return 1; } -int enif_get_atom_length(ErlNifEnv* env, Eterm atom, unsigned* len, - ErlNifCharEncoding enc) +int __attribute__((externally_visible)) +enif_get_atom_length(ErlNifEnv* env, Eterm atom, unsigned* len, ErlNifCharEncoding enc) { Atom* ap; ASSERT(enc == ERL_NIF_LATIN1); @@ -1447,7 +1444,7 @@ int enif_get_atom_length(ErlNifEnv* env, return 1; } -int enif_get_list_cell(ErlNifEnv* env, Eterm term, Eterm* head, Eterm* tail) +int __attribute__((externally_visible)) enif_get_list_cell(ErlNifEnv* env, Eterm term, Eterm* head, Eterm* tail) { Eterm* val; if (is_not_list(term)) return 0; @@ -1457,7 +1454,7 @@ int enif_get_list_cell(ErlNifEnv* env, E return 1; } -int enif_get_list_length(ErlNifEnv* env, Eterm term, unsigned* len) +int __attribute__((externally_visible)) enif_get_list_length(ErlNifEnv* env, Eterm term, unsigned* len) { Sint i; Uint u; @@ -1469,7 +1466,7 @@ int enif_get_list_length(ErlNifEnv* env, return 1; } -ERL_NIF_TERM enif_make_int(ErlNifEnv* env, int i) +ERL_NIF_TERM __attribute__((externally_visible)) enif_make_int(ErlNifEnv* env, int i) { #if SIZEOF_INT == ERTS_SIZEOF_ETERM return IS_SSMALL(i) ? make_small(i) : small_to_big(i,alloc_heap(env,2)); @@ -1479,7 +1476,7 @@ ERL_NIF_TERM enif_make_int(ErlNifEnv* en #endif } -ERL_NIF_TERM enif_make_uint(ErlNifEnv* env, unsigned i) +ERL_NIF_TERM __attribute__((externally_visible)) enif_make_uint(ErlNifEnv* env, unsigned i) { #if SIZEOF_INT == ERTS_SIZEOF_ETERM return IS_USMALL(0,i) ? make_small(i) : uint_to_big(i,alloc_heap(env,2)); @@ -1489,7 +1486,7 @@ ERL_NIF_TERM enif_make_uint(ErlNifEnv* e #endif } -ERL_NIF_TERM enif_make_long(ErlNifEnv* env, long i) +ERL_NIF_TERM __attribute__((externally_visible))enif_make_long(ErlNifEnv* env, long i) { if (IS_SSMALL(i)) { return make_small(i); @@ -1504,7 +1501,7 @@ ERL_NIF_TERM enif_make_long(ErlNifEnv* e #endif } -ERL_NIF_TERM enif_make_ulong(ErlNifEnv* env, unsigned long i) +ERL_NIF_TERM __attribute__((externally_visible)) enif_make_ulong(ErlNifEnv* env, unsigned long i) { if (IS_USMALL(0,i)) { return make_small(i); @@ -1520,7 +1517,7 @@ ERL_NIF_TERM enif_make_ulong(ErlNifEnv* } #if HAVE_INT64 && SIZEOF_LONG != 8 -ERL_NIF_TERM enif_make_int64(ErlNifEnv* env, ErlNifSInt64 i) +ERL_NIF_TERM __attribute__((externally_visible)) enif_make_int64(ErlNifEnv* env, ErlNifSInt64 i) { Uint* hp; Uint need = 0; @@ -1529,7 +1526,7 @@ ERL_NIF_TERM enif_make_int64(ErlNifEnv* return erts_bld_sint64(&hp, NULL, i); } -ERL_NIF_TERM enif_make_uint64(ErlNifEnv* env, ErlNifUInt64 i) +ERL_NIF_TERM __attribute__((externally_visible)) enif_make_uint64(ErlNifEnv* env, ErlNifUInt64 i) { Uint* hp; Uint need = 0; @@ -1539,7 +1536,7 @@ ERL_NIF_TERM enif_make_uint64(ErlNifEnv* } #endif /* HAVE_INT64 && SIZEOF_LONG != 8 */ -ERL_NIF_TERM enif_make_double(ErlNifEnv* env, double d) +ERL_NIF_TERM __attribute__((externally_visible)) enif_make_double(ErlNifEnv* env, double d) { Eterm* hp; FloatDef f; @@ -1552,26 +1549,26 @@ ERL_NIF_TERM enif_make_double(ErlNifEnv* return make_float(hp); } -ERL_NIF_TERM enif_make_atom(ErlNifEnv* env, const char* name) +ERL_NIF_TERM __attribute__((externally_visible)) enif_make_atom(ErlNifEnv* env, const char* name) { return enif_make_atom_len(env, name, sys_strlen(name)); } -ERL_NIF_TERM enif_make_atom_len(ErlNifEnv* env, const char* name, size_t len) +ERL_NIF_TERM __attribute__((externally_visible)) enif_make_atom_len(ErlNifEnv* env, const char* name, size_t len) { if (len > MAX_ATOM_CHARACTERS) return enif_make_badarg(env); return erts_atom_put((byte*)name, len, ERTS_ATOM_ENC_LATIN1, 1); } -int enif_make_existing_atom(ErlNifEnv* env, const char* name, ERL_NIF_TERM* atom, - ErlNifCharEncoding enc) +int __attribute__((externally_visible)) +enif_make_existing_atom(ErlNifEnv* env, const char* name, ERL_NIF_TERM* atom, ErlNifCharEncoding enc) { return enif_make_existing_atom_len(env, name, sys_strlen(name), atom, enc); } -int enif_make_existing_atom_len(ErlNifEnv* env, const char* name, size_t len, - ERL_NIF_TERM* atom, ErlNifCharEncoding encoding) +int __attribute__((externally_visible)) +enif_make_existing_atom_len(ErlNifEnv* env, const char* name, size_t len, ERL_NIF_TERM* atom, ErlNifCharEncoding encoding) { ASSERT(encoding == ERL_NIF_LATIN1); if (len > MAX_ATOM_CHARACTERS) @@ -1579,7 +1576,7 @@ int enif_make_existing_atom_len(ErlNifEn return erts_atom_get(name, len, atom, ERTS_ATOM_ENC_LATIN1); } -ERL_NIF_TERM enif_make_tuple(ErlNifEnv* env, unsigned cnt, ...) +ERL_NIF_TERM __attribute__((externally_visible)) enif_make_tuple(ErlNifEnv* env, unsigned cnt, ...) { Eterm* hp = alloc_heap(env,cnt+1); Eterm ret = make_tuple(hp); @@ -1594,7 +1591,8 @@ ERL_NIF_TERM enif_make_tuple(ErlNifEnv* return ret; } -ERL_NIF_TERM enif_make_tuple_from_array(ErlNifEnv* env, const ERL_NIF_TERM arr[], unsigned cnt) +ERL_NIF_TERM __attribute__((externally_visible)) +enif_make_tuple_from_array(ErlNifEnv* env, const ERL_NIF_TERM arr[], unsigned cnt) { Eterm* hp = alloc_heap(env,cnt+1); Eterm ret = make_tuple(hp); @@ -1607,7 +1605,7 @@ ERL_NIF_TERM enif_make_tuple_from_array( return ret; } -ERL_NIF_TERM enif_make_list_cell(ErlNifEnv* env, Eterm car, Eterm cdr) +ERL_NIF_TERM __attribute__((externally_visible)) enif_make_list_cell(ErlNifEnv* env, Eterm car, Eterm cdr) { Eterm* hp = alloc_heap(env,2); Eterm ret = make_list(hp); @@ -1617,7 +1615,7 @@ ERL_NIF_TERM enif_make_list_cell(ErlNifE return ret; } -ERL_NIF_TERM enif_make_list(ErlNifEnv* env, unsigned cnt, ...) +ERL_NIF_TERM __attribute__((externally_visible)) enif_make_list(ErlNifEnv* env, unsigned cnt, ...) { if (cnt == 0) { return NIL; @@ -1641,7 +1639,8 @@ ERL_NIF_TERM enif_make_list(ErlNifEnv* e } } -ERL_NIF_TERM enif_make_list_from_array(ErlNifEnv* env, const ERL_NIF_TERM arr[], unsigned cnt) +ERL_NIF_TERM __attribute__((externally_visible)) +enif_make_list_from_array(ErlNifEnv* env, const ERL_NIF_TERM arr[], unsigned cnt) { Eterm* hp = alloc_heap(env,cnt*2); Eterm ret = make_list(hp); @@ -1658,32 +1657,32 @@ ERL_NIF_TERM enif_make_list_from_array(E return ret; } -ERL_NIF_TERM enif_make_string(ErlNifEnv* env, const char* string, - ErlNifCharEncoding encoding) +ERL_NIF_TERM __attribute__((externally_visible)) +enif_make_string(ErlNifEnv* env, const char* string, ErlNifCharEncoding encoding) { return enif_make_string_len(env, string, sys_strlen(string), encoding); } -ERL_NIF_TERM enif_make_string_len(ErlNifEnv* env, const char* string, - size_t len, ErlNifCharEncoding encoding) +ERL_NIF_TERM __attribute__((externally_visible)) +enif_make_string_len(ErlNifEnv* env, const char* string, size_t len, ErlNifCharEncoding encoding) { Eterm* hp = alloc_heap(env,len*2); ASSERT(encoding == ERL_NIF_LATIN1); return erts_bld_string_n(&hp,NULL,string,len); } -ERL_NIF_TERM enif_make_ref(ErlNifEnv* env) +ERL_NIF_TERM __attribute__((externally_visible)) enif_make_ref(ErlNifEnv* env) { Eterm* hp = alloc_heap(env, REF_THING_SIZE); return erts_make_ref_in_buffer(hp); } -void enif_system_info(ErlNifSysInfo *sip, size_t si_size) +void __attribute__((externally_visible)) enif_system_info(ErlNifSysInfo *sip, size_t si_size) { driver_system_info(sip, si_size); } -int enif_make_reverse_list(ErlNifEnv* env, ERL_NIF_TERM term, ERL_NIF_TERM *list) { +int __attribute__((externally_visible)) enif_make_reverse_list(ErlNifEnv* env, ERL_NIF_TERM term, ERL_NIF_TERM *list) { Eterm *listptr, ret = NIL, *hp; if (is_nil(term)) { @@ -1706,7 +1705,7 @@ int enif_make_reverse_list(ErlNifEnv* en return 1; } -int enif_is_current_process_alive(ErlNifEnv* env) +int __attribute__((externally_visible)) enif_is_current_process_alive(ErlNifEnv* env) { Process *c_p; int scheduler; @@ -1725,7 +1724,7 @@ int enif_is_current_process_alive(ErlNif return !ERTS_PROC_IS_EXITING(c_p); } -int enif_is_process_alive(ErlNifEnv* env, ErlNifPid *proc) +int __attribute__((externally_visible)) enif_is_process_alive(ErlNifEnv* env, ErlNifPid *proc) { int scheduler; @@ -1749,7 +1748,7 @@ int enif_is_process_alive(ErlNifEnv* env } } -int enif_is_port_alive(ErlNifEnv *env, ErlNifPort *port) +int __attribute__((externally_visible)) enif_is_port_alive(ErlNifEnv *env, ErlNifPort *port) { int scheduler; Uint32 iflags = (erts_port_synchronous_ops @@ -1775,7 +1774,7 @@ int enif_is_port_alive(ErlNifEnv *env, E } } -ERL_NIF_TERM +ERL_NIF_TERM __attribute__((externally_visible)) enif_now_time(ErlNifEnv *env) { Uint mega, sec, micro; @@ -1785,7 +1784,7 @@ enif_now_time(ErlNifEnv *env) return TUPLE3(hp, make_small(mega), make_small(sec), make_small(micro)); } -ERL_NIF_TERM +ERL_NIF_TERM __attribute__((externally_visible)) enif_cpu_time(ErlNifEnv *env) { #ifdef HAVE_ERTS_NOW_CPU @@ -1799,7 +1798,7 @@ enif_cpu_time(ErlNifEnv *env) #endif } -ERL_NIF_TERM +ERL_NIF_TERM __attribute__((externally_visible)) enif_make_unique_integer(ErlNifEnv *env, ErlNifUniqueInteger properties) { int monotonic = properties & ERL_NIF_UNIQUE_MONOTONIC; @@ -1821,51 +1820,51 @@ enif_make_unique_integer(ErlNifEnv *env, } } -ErlNifMutex* enif_mutex_create(char *name) { return erl_drv_mutex_create(name); } -void enif_mutex_destroy(ErlNifMutex *mtx) { erl_drv_mutex_destroy(mtx); } -int enif_mutex_trylock(ErlNifMutex *mtx) { return erl_drv_mutex_trylock(mtx); } -void enif_mutex_lock(ErlNifMutex *mtx) { erl_drv_mutex_lock(mtx); } -void enif_mutex_unlock(ErlNifMutex *mtx) { erl_drv_mutex_unlock(mtx); } -ErlNifCond* enif_cond_create(char *name) { return erl_drv_cond_create(name); } -void enif_cond_destroy(ErlNifCond *cnd) { erl_drv_cond_destroy(cnd); } -void enif_cond_signal(ErlNifCond *cnd) { erl_drv_cond_signal(cnd); } -void enif_cond_broadcast(ErlNifCond *cnd) { erl_drv_cond_broadcast(cnd); } -void enif_cond_wait(ErlNifCond *cnd, ErlNifMutex *mtx) { erl_drv_cond_wait(cnd,mtx); } -ErlNifRWLock* enif_rwlock_create(char *name) { return erl_drv_rwlock_create(name); } -void enif_rwlock_destroy(ErlNifRWLock *rwlck) { erl_drv_rwlock_destroy(rwlck); } -int enif_rwlock_tryrlock(ErlNifRWLock *rwlck) { return erl_drv_rwlock_tryrlock(rwlck); } -void enif_rwlock_rlock(ErlNifRWLock *rwlck) { erl_drv_rwlock_rlock(rwlck); } -void enif_rwlock_runlock(ErlNifRWLock *rwlck) { erl_drv_rwlock_runlock(rwlck); } -int enif_rwlock_tryrwlock(ErlNifRWLock *rwlck) { return erl_drv_rwlock_tryrwlock(rwlck); } -void enif_rwlock_rwlock(ErlNifRWLock *rwlck) { erl_drv_rwlock_rwlock(rwlck); } -void enif_rwlock_rwunlock(ErlNifRWLock *rwlck) { erl_drv_rwlock_rwunlock(rwlck); } -int enif_tsd_key_create(char *name, ErlNifTSDKey *key) { return erl_drv_tsd_key_create(name,key); } -void enif_tsd_key_destroy(ErlNifTSDKey key) { erl_drv_tsd_key_destroy(key); } -void enif_tsd_set(ErlNifTSDKey key, void *data) { erl_drv_tsd_set(key,data); } -void* enif_tsd_get(ErlNifTSDKey key) { return erl_drv_tsd_get(key); } -ErlNifThreadOpts* enif_thread_opts_create(char *name) { return (ErlNifThreadOpts*) erl_drv_thread_opts_create(name); } -void enif_thread_opts_destroy(ErlNifThreadOpts *opts) { erl_drv_thread_opts_destroy((ErlDrvThreadOpts*)opts); } -int enif_thread_create(char *name, ErlNifTid *tid, void* (*func)(void *), - void *args, ErlNifThreadOpts *opts) { +ErlNifMutex* __attribute__((externally_visible)) enif_mutex_create(char *name) { return erl_drv_mutex_create(name); } +void __attribute__((externally_visible)) enif_mutex_destroy(ErlNifMutex *mtx) { erl_drv_mutex_destroy(mtx); } +int __attribute__((externally_visible)) enif_mutex_trylock(ErlNifMutex *mtx) { return erl_drv_mutex_trylock(mtx); } +void __attribute__((externally_visible)) enif_mutex_lock(ErlNifMutex *mtx) { erl_drv_mutex_lock(mtx); } +void __attribute__((externally_visible)) enif_mutex_unlock(ErlNifMutex *mtx) { erl_drv_mutex_unlock(mtx); } +ErlNifCond* __attribute__((externally_visible)) enif_cond_create(char *name) { return erl_drv_cond_create(name); } +void __attribute__((externally_visible)) enif_cond_destroy(ErlNifCond *cnd) { erl_drv_cond_destroy(cnd); } +void __attribute__((externally_visible)) enif_cond_signal(ErlNifCond *cnd) { erl_drv_cond_signal(cnd); } +void __attribute__((externally_visible)) enif_cond_broadcast(ErlNifCond *cnd) { erl_drv_cond_broadcast(cnd); } +void __attribute__((externally_visible)) enif_cond_wait(ErlNifCond *cnd, ErlNifMutex *mtx) { erl_drv_cond_wait(cnd,mtx); } +ErlNifRWLock* __attribute__((externally_visible)) enif_rwlock_create(char *name) { return erl_drv_rwlock_create(name); } +void __attribute__((externally_visible)) enif_rwlock_destroy(ErlNifRWLock *rwlck) { erl_drv_rwlock_destroy(rwlck); } +int __attribute__((externally_visible)) enif_rwlock_tryrlock(ErlNifRWLock *rwlck) { return erl_drv_rwlock_tryrlock(rwlck); } +void __attribute__((externally_visible)) enif_rwlock_rlock(ErlNifRWLock *rwlck) { erl_drv_rwlock_rlock(rwlck); } +void __attribute__((externally_visible)) enif_rwlock_runlock(ErlNifRWLock *rwlck) { erl_drv_rwlock_runlock(rwlck); } +int __attribute__((externally_visible)) enif_rwlock_tryrwlock(ErlNifRWLock *rwlck) { return erl_drv_rwlock_tryrwlock(rwlck); } +void __attribute__((externally_visible)) enif_rwlock_rwlock(ErlNifRWLock *rwlck) { erl_drv_rwlock_rwlock(rwlck); } +void __attribute__((externally_visible)) enif_rwlock_rwunlock(ErlNifRWLock *rwlck) { erl_drv_rwlock_rwunlock(rwlck); } +int __attribute__((externally_visible)) enif_tsd_key_create(char *name, ErlNifTSDKey *key) { return erl_drv_tsd_key_create(name,key); } +void __attribute__((externally_visible)) enif_tsd_key_destroy(ErlNifTSDKey key) { erl_drv_tsd_key_destroy(key); } +void __attribute__((externally_visible)) enif_tsd_set(ErlNifTSDKey key, void *data) { erl_drv_tsd_set(key,data); } +void* __attribute__((externally_visible)) enif_tsd_get(ErlNifTSDKey key) { return erl_drv_tsd_get(key); } +ErlNifThreadOpts* __attribute__((externally_visible)) enif_thread_opts_create(char *name) { return (ErlNifThreadOpts*) erl_drv_thread_opts_create(name); } +void __attribute__((externally_visible)) enif_thread_opts_destroy(ErlNifThreadOpts *opts) { erl_drv_thread_opts_destroy((ErlDrvThreadOpts*)opts); } +int __attribute__((externally_visible)) +enif_thread_create(char *name, ErlNifTid *tid, void* (*func)(void *), void *args, ErlNifThreadOpts *opts) { return erl_drv_thread_create(name,tid,func,args,(ErlDrvThreadOpts*)opts); } -ErlNifTid enif_thread_self(void) { return erl_drv_thread_self(); } -int enif_equal_tids(ErlNifTid tid1, ErlNifTid tid2) { return erl_drv_equal_tids(tid1,tid2); } -void enif_thread_exit(void *resp) { erl_drv_thread_exit(resp); } -int enif_thread_join(ErlNifTid tid, void **respp) { return erl_drv_thread_join(tid,respp); } -int enif_getenv(const char *key, char *value, size_t *value_size) { return erl_drv_getenv(key, value, value_size); } +ErlNifTid __attribute__((externally_visible)) enif_thread_self(void) { return erl_drv_thread_self(); } +int __attribute__((externally_visible)) enif_equal_tids(ErlNifTid tid1, ErlNifTid tid2) { return erl_drv_equal_tids(tid1,tid2); } +void __attribute__((externally_visible)) enif_thread_exit(void *resp) { erl_drv_thread_exit(resp); } +int __attribute__((externally_visible)) enif_thread_join(ErlNifTid tid, void **respp) { return erl_drv_thread_join(tid,respp); } +int __attribute__((externally_visible)) enif_getenv(const char *key, char *value, size_t *value_size) { return erl_drv_getenv(key, value, value_size); } -ErlNifTime enif_monotonic_time(ErlNifTimeUnit time_unit) +ErlNifTime __attribute__((externally_visible)) enif_monotonic_time(ErlNifTimeUnit time_unit) { return (ErlNifTime) erts_napi_monotonic_time((int) time_unit); } -ErlNifTime enif_time_offset(ErlNifTimeUnit time_unit) +ErlNifTime __attribute__((externally_visible)) enif_time_offset(ErlNifTimeUnit time_unit) { return (ErlNifTime) erts_napi_time_offset((int) time_unit); } -ErlNifTime +ErlNifTime __attribute__((externally_visible)) enif_convert_time_unit(ErlNifTime val, ErlNifTimeUnit from, ErlNifTimeUnit to) @@ -1875,7 +1874,7 @@ enif_convert_time_unit(ErlNifTime val, (int) to); } -int enif_fprintf(void* filep, const char* format, ...) +int __attribute__((externally_visible)) enif_fprintf(void* filep, const char* format, ...) { int ret; va_list arglist; @@ -1885,7 +1884,7 @@ int enif_fprintf(void* filep, const char return ret; } -int enif_snprintf(char *buffer, size_t size, const char* format, ...) +int __attribute__((externally_visible)) enif_snprintf(char *buffer, size_t size, const char* format, ...) { int ret; va_list arglist; @@ -1996,7 +1995,7 @@ struct opened_resource_type }; static struct opened_resource_type* opened_rt_list = NULL; -ErlNifResourceType* +ErlNifResourceType* __attribute__((externally_visible)) enif_open_resource_type(ErlNifEnv* env, const char* module_str, const char* name_str, @@ -2119,7 +2118,7 @@ static void nif_resource_dtor(Binary* bi } } -void* enif_alloc_resource(ErlNifResourceType* type, size_t size) +void* __attribute__((externally_visible)) enif_alloc_resource(ErlNifResourceType* type, size_t size) { Binary* bin = erts_create_magic_binary_x(SIZEOF_ErlNifResource(size), &nif_resource_dtor, @@ -2136,7 +2135,7 @@ void* enif_alloc_resource(ErlNifResource return resource->data; } -void enif_release_resource(void* obj) +void __attribute__((externally_visible)) enif_release_resource(void* obj) { ErlNifResource* resource = DATA_TO_RESOURCE(obj); ErtsBinary* bin = ERTS_MAGIC_BIN_FROM_UNALIGNED_DATA(resource); @@ -2150,7 +2149,7 @@ void enif_release_resource(void* obj) } } -void enif_keep_resource(void* obj) +void __attribute__((externally_visible)) enif_keep_resource(void* obj) { ErlNifResource* resource = DATA_TO_RESOURCE(obj); ErtsBinary* bin = ERTS_MAGIC_BIN_FROM_UNALIGNED_DATA(resource); @@ -2162,7 +2161,7 @@ void enif_keep_resource(void* obj) erts_refc_inc(&bin->binary.refc, 2); } -ERL_NIF_TERM enif_make_resource(ErlNifEnv* env, void* obj) +ERL_NIF_TERM __attribute__((externally_visible)) enif_make_resource(ErlNifEnv* env, void* obj) { ErlNifResource* resource = DATA_TO_RESOURCE(obj); ErtsBinary* bin = ERTS_MAGIC_BIN_FROM_UNALIGNED_DATA(resource); @@ -2170,8 +2169,8 @@ ERL_NIF_TERM enif_make_resource(ErlNifEn return erts_mk_magic_binary_term(&hp, &MSO(env->proc), &bin->binary); } -ERL_NIF_TERM enif_make_resource_binary(ErlNifEnv* env, void* obj, - const void* data, size_t size) +ERL_NIF_TERM __attribute__((externally_visible)) +enif_make_resource_binary(ErlNifEnv* env, void* obj, const void* data, size_t size) { Eterm bin = enif_make_resource(env, obj); ProcBin* pb = (ProcBin*) binary_val(bin); @@ -2180,8 +2179,8 @@ ERL_NIF_TERM enif_make_resource_binary(E return bin; } -int enif_get_resource(ErlNifEnv* env, ERL_NIF_TERM term, ErlNifResourceType* type, - void** objp) +int __attribute__((externally_visible)) +enif_get_resource(ErlNifEnv* env, ERL_NIF_TERM term, ErlNifResourceType* type, void** objp) { ProcBin* pb; Binary* mbin; @@ -2203,7 +2202,7 @@ int enif_get_resource(ErlNifEnv* env, ER return 1; } -size_t enif_sizeof_resource(void* obj) +size_t __attribute__((externally_visible)) enif_sizeof_resource(void* obj) { ErlNifResource* resource = DATA_TO_RESOURCE(obj); Binary* bin = &ERTS_MAGIC_BIN_FROM_UNALIGNED_DATA(resource)->binary; @@ -2211,8 +2210,8 @@ size_t enif_sizeof_resource(void* obj) } -void* enif_dlopen(const char* lib, - void (*err_handler)(void*,const char*), void* err_arg) +void* __attribute__((externally_visible)) +enif_dlopen(const char* lib, void (*err_handler)(void*,const char*), void* err_arg) { ErtsSysDdllError errdesc = ERTS_SYS_DDLL_ERROR_INIT; void* handle; @@ -2232,8 +2231,8 @@ void* enif_dlopen(const char* lib, return handle; } -void* enif_dlsym(void* handle, const char* symbol, - void (*err_handler)(void*,const char*), void* err_arg) +void* __attribute__((externally_visible)) +enif_dlsym(void* handle, const char* symbol, void (*err_handler)(void*,const char*), void* err_arg) { ErtsSysDdllError errdesc = ERTS_SYS_DDLL_ERROR_INIT; void* ret; @@ -2247,7 +2246,7 @@ void* enif_dlsym(void* handle, const cha return ret; } -int enif_consume_timeslice(ErlNifEnv* env, int percent) +int __attribute__((externally_visible)) enif_consume_timeslice(ErlNifEnv* env, int percent) { Process *proc; Sint reds; @@ -2658,7 +2657,7 @@ execute_nif(ErlNifEnv* env, int argc, co return result; } -ERL_NIF_TERM +ERL_NIF_TERM __attribute__((externally_visible)) enif_schedule_nif(ErlNifEnv* env, const char* fun_name, int flags, ERL_NIF_TERM (*fp)(ErlNifEnv*, int, const ERL_NIF_TERM[]), int argc, const ERL_NIF_TERM argv[]) @@ -2716,7 +2715,7 @@ done: return result; } -int +int __attribute__((externally_visible)) enif_thread_type(void) { ErtsSchedulerData *esdp = erts_get_scheduler_data(); @@ -2736,12 +2735,12 @@ enif_thread_type(void) /* Maps */ -int enif_is_map(ErlNifEnv* env, ERL_NIF_TERM term) +int __attribute__((externally_visible)) enif_is_map(ErlNifEnv* env, ERL_NIF_TERM term) { return is_map(term); } -int enif_get_map_size(ErlNifEnv* env, ERL_NIF_TERM term, size_t *size) +int __attribute__((externally_visible)) enif_get_map_size(ErlNifEnv* env, ERL_NIF_TERM term, size_t *size) { if (is_flatmap(term)) { flatmap_t *mp; @@ -2756,7 +2755,7 @@ int enif_get_map_size(ErlNifEnv* env, ER return 0; } -ERL_NIF_TERM enif_make_new_map(ErlNifEnv* env) +ERL_NIF_TERM __attribute__((externally_visible)) enif_make_new_map(ErlNifEnv* env) { Eterm* hp = alloc_heap(env,MAP_HEADER_FLATMAP_SZ+1); Eterm tup; @@ -2772,11 +2771,8 @@ ERL_NIF_TERM enif_make_new_map(ErlNifEnv return make_flatmap(mp); } -int enif_make_map_put(ErlNifEnv* env, - Eterm map_in, - Eterm key, - Eterm value, - Eterm *map_out) +int __attribute__((externally_visible)) +enif_make_map_put(ErlNifEnv* env, Eterm map_in, Eterm key, Eterm value, Eterm *map_out) { if (!is_map(map_in)) { return 0; @@ -2787,10 +2783,7 @@ int enif_make_map_put(ErlNifEnv* env, return 1; } -int enif_get_map_value(ErlNifEnv* env, - Eterm map, - Eterm key, - Eterm *value) +int __attribute__((externally_visible)) enif_get_map_value(ErlNifEnv* env, Eterm map, Eterm key, Eterm *value) { const Eterm *ret; if (!is_map(map)) { @@ -2804,11 +2797,7 @@ int enif_get_map_value(ErlNifEnv* env, return 0; } -int enif_make_map_update(ErlNifEnv* env, - Eterm map_in, - Eterm key, - Eterm value, - Eterm *map_out) +int __attribute__((externally_visible)) enif_make_map_update(ErlNifEnv* env, Eterm map_in, Eterm key, Eterm value, Eterm *map_out) { int res; if (!is_map(map_in)) { @@ -2821,10 +2810,7 @@ int enif_make_map_update(ErlNifEnv* env, return res; } -int enif_make_map_remove(ErlNifEnv* env, - Eterm map_in, - Eterm key, - Eterm *map_out) +int __attribute__((externally_visible)) enif_make_map_remove(ErlNifEnv* env, Eterm map_in, Eterm key, Eterm *map_out) { if (!is_map(map_in)) { return 0; @@ -2835,10 +2821,8 @@ int enif_make_map_remove(ErlNifEnv* env, return 1; } -int enif_map_iterator_create(ErlNifEnv *env, - Eterm map, - ErlNifMapIterator *iter, - ErlNifMapIteratorEntry entry) +int __attribute__((externally_visible)) +enif_map_iterator_create(ErlNifEnv *env, Eterm map, ErlNifMapIterator *iter, ErlNifMapIteratorEntry entry) { if (is_flatmap(map)) { flatmap_t *mp = (flatmap_t*)flatmap_val(map); @@ -2893,7 +2877,7 @@ error: return 0; } -void enif_map_iterator_destroy(ErlNifEnv *env, ErlNifMapIterator *iter) +void __attribute__((externally_visible)) enif_map_iterator_destroy(ErlNifEnv *env, ErlNifMapIterator *iter) { if (is_hashmap(iter->map)) { WSTACK_DESTROY(iter->u.hash.wstack->ws); @@ -2907,7 +2891,7 @@ void enif_map_iterator_destroy(ErlNifEnv #endif } -int enif_map_iterator_is_tail(ErlNifEnv *env, ErlNifMapIterator *iter) +int __attribute__((externally_visible)) enif_map_iterator_is_tail(ErlNifEnv *env, ErlNifMapIterator *iter) { ASSERT(iter); if (is_flatmap(iter->map)) { @@ -2921,7 +2905,7 @@ int enif_map_iterator_is_tail(ErlNifEnv } } -int enif_map_iterator_is_head(ErlNifEnv *env, ErlNifMapIterator *iter) +int __attribute__((externally_visible)) enif_map_iterator_is_head(ErlNifEnv *env, ErlNifMapIterator *iter) { ASSERT(iter); if (is_flatmap(iter->map)) { @@ -2936,7 +2920,7 @@ int enif_map_iterator_is_head(ErlNifEnv } -int enif_map_iterator_next(ErlNifEnv *env, ErlNifMapIterator *iter) +int __attribute__((externally_visible)) enif_map_iterator_next(ErlNifEnv *env, ErlNifMapIterator *iter) { ASSERT(iter); if (is_flatmap(iter->map)) { @@ -2962,7 +2946,7 @@ int enif_map_iterator_next(ErlNifEnv *en } } -int enif_map_iterator_prev(ErlNifEnv *env, ErlNifMapIterator *iter) +int __attribute__((externally_visible)) enif_map_iterator_prev(ErlNifEnv *env, ErlNifMapIterator *iter) { ASSERT(iter); if (is_flatmap(iter->map)) { @@ -2988,10 +2972,7 @@ int enif_map_iterator_prev(ErlNifEnv *en } } -int enif_map_iterator_get_pair(ErlNifEnv *env, - ErlNifMapIterator *iter, - Eterm *key, - Eterm *value) +int __attribute__((externally_visible)) enif_map_iterator_get_pair(ErlNifEnv *env, ErlNifMapIterator *iter, Eterm *key, Eterm *value) { ASSERT(iter); if (is_flatmap(iter->map)) { diff -Ndurp otp_src_19.2/erts/emulator/beam/erl_port_task.c otp_src_19.2-erts-symbols/erts/emulator/beam/erl_port_task.c --- otp_src_19.2/erts/emulator/beam/erl_port_task.c 2016-12-09 12:45:24.000000000 +0200 +++ otp_src_19.2-erts-symbols/erts/emulator/beam/erl_port_task.c 2017-01-01 23:26:54.493659261 +0200 @@ -752,7 +752,7 @@ enqueue_proc2port_data(Port *pp, * as a write-read request. */ -void +void __attribute__((externally_visible)) erl_drv_busy_msgq_limits(ErlDrvPort dport, ErlDrvSizeT *lowp, ErlDrvSizeT *highp) { Port *pp = erts_drvport2port(dport); @@ -1257,7 +1257,7 @@ select_task_for_exec(Port *pp, * Cut time slice */ -int +int __attribute__((externally_visible)) erl_drv_consume_timeslice(ErlDrvPort dprt, int percent) { Port *pp = erts_drvport2port(dprt); diff -Ndurp otp_src_19.2/erts/emulator/beam/erl_posix_str.c otp_src_19.2-erts-symbols/erts/emulator/beam/erl_posix_str.c --- otp_src_19.2/erts/emulator/beam/erl_posix_str.c 2016-12-09 12:45:24.000000000 +0200 +++ otp_src_19.2-erts-symbols/erts/emulator/beam/erl_posix_str.c 2017-01-01 23:26:54.493659261 +0200 @@ -46,7 +46,7 @@ *---------------------------------------------------------------------- */ -char * +char * __attribute__((externally_visible)) erl_errno_id(error) int error; /* Posix error number (as from errno). */ { diff -Ndurp otp_src_19.2/erts/emulator/beam/io.c otp_src_19.2-erts-symbols/erts/emulator/beam/io.c --- otp_src_19.2/erts/emulator/beam/io.c 2016-12-09 12:45:24.000000000 +0200 +++ otp_src_19.2-erts-symbols/erts/emulator/beam/io.c 2017-01-01 23:26:54.497659151 +0200 @@ -70,7 +70,7 @@ static erts_smp_tsd_key_t driver_list_la ErtsPTab erts_port erts_align_attribute(ERTS_CACHE_LINE_SIZE); /* The port table */ -const ErlDrvTermData driver_term_nil = (ErlDrvTermData)NIL; +const ErlDrvTermData __attribute__((externally_visible)) driver_term_nil = (ErlDrvTermData)NIL; const Port erts_invalid_port = {{ERTS_INVALID_PORT}}; @@ -191,7 +191,7 @@ typedef struct line_buf_context { dtrace_proc_str((PID), process_str); \ dtrace_port_str((PORT), port_str); -void +void __attribute__((externally_visible)) dtrace_drvport_str(ErlDrvPort drvport, char *port_buf) { Port *port = erts_drvport2port(drvport); @@ -805,7 +805,7 @@ ERTS_SCHED_PREF_QUICK_ALLOC_IMPL(xports_ * Historical reason: to be used with inet_drv for creating * accept sockets inorder to avoid a global table. */ -ErlDrvPort +ErlDrvPort __attribute__((externally_visible)) driver_create_port(ErlDrvPort creator_port_ix, /* Creating port */ ErlDrvTermData pid, /* Owner/Caller */ char* name, /* Driver name */ @@ -5546,7 +5546,7 @@ print_port_info(Port *p, fmtfn_t to, voi } } -void +void __attribute__((externally_visible)) set_busy_port(ErlDrvPort dprt, int on) { Port *prt; @@ -5656,14 +5656,14 @@ erts_port_resume_procs(Port *prt) } } -void set_port_control_flags(ErlDrvPort port_num, int flags) +void __attribute__((externally_visible)) set_port_control_flags(ErlDrvPort port_num, int flags) { Port *prt = erts_drvport2port(port_num); if (prt != ERTS_INVALID_ERL_DRV_PORT) prt->control_flags = flags; } -int get_port_flags(ErlDrvPort ix) +int __attribute__((externally_visible)) get_port_flags(ErlDrvPort ix) { int flags; Port *prt; @@ -5886,7 +5886,7 @@ erts_free_port_names(ErtsPortNames *pnp) erts_free(ERTS_ALC_T_PORT_NAMES, pnp); } -ErlDrvTermData driver_mk_term_nil(void) +ErlDrvTermData __attribute__((externally_visible)) driver_mk_term_nil(void) { return driver_term_nil; } @@ -6630,7 +6630,8 @@ done: return res; } -int erl_drv_output_term(ErlDrvTermData port_id, ErlDrvTermData* data, int len) +int __attribute__((externally_visible)) +erl_drv_output_term(ErlDrvTermData port_id, ErlDrvTermData* data, int len) { /* May be called from arbitrary thread */ Eterm connected = NIL; /* Shut up faulty warning... */ @@ -6646,7 +6647,7 @@ int erl_drv_output_term(ErlDrvTermData p * removal in OTP-R17. It is replaced by erl_drv_output_term() * above. */ -int +int __attribute__((externally_visible)) driver_output_term(ErlDrvPort drvport, ErlDrvTermData* data, int len) { erts_aint32_t state; @@ -6665,10 +6666,8 @@ driver_output_term(ErlDrvPort drvport, E return driver_deliver_term(prt, ERTS_PORT_GET_CONNECTED(prt), data, len); } -int erl_drv_send_term(ErlDrvTermData port_id, - ErlDrvTermData to, - ErlDrvTermData* data, - int len) +int __attribute__((externally_visible)) +erl_drv_send_term(ErlDrvTermData port_id, ErlDrvTermData to, ErlDrvTermData* data, int len) { /* May be called from arbitrary thread */ Port *prt = NULL; @@ -6682,7 +6681,7 @@ int erl_drv_send_term(ErlDrvTermData por * driver_send_term() is deprecated, and has been scheduled for * removal in OTP-R17. It is replaced by erl_drv_send_term() above. */ -int +int __attribute__((externally_visible)) driver_send_term(ErlDrvPort drvport, ErlDrvTermData to, ErlDrvTermData* data, @@ -6717,8 +6716,9 @@ driver_send_term(ErlDrvPort drvport, * and data is len length of bin starting from offset offs. */ -int driver_output_binary(ErlDrvPort ix, char* hbuf, ErlDrvSizeT hlen, - ErlDrvBinary* bin, ErlDrvSizeT offs, ErlDrvSizeT len) +int __attribute__((externally_visible)) +driver_output_binary(ErlDrvPort ix, char* hbuf, ErlDrvSizeT hlen, + ErlDrvBinary* bin, ErlDrvSizeT offs, ErlDrvSizeT len) { erts_aint32_t state; Port* prt = erts_drvport2port_state(ix, &state); @@ -6756,8 +6756,8 @@ int driver_output_binary(ErlDrvPort ix, ** Example: if hlen = 3 then the port owner will receive the data ** [H1,H2,H3 | T] */ -int driver_output2(ErlDrvPort ix, char* hbuf, ErlDrvSizeT hlen, - char* buf, ErlDrvSizeT len) +int __attribute__((externally_visible)) +driver_output2(ErlDrvPort ix, char* hbuf, ErlDrvSizeT hlen, char* buf, ErlDrvSizeT len) { erts_aint32_t state; Port* prt = erts_drvport2port_state(ix, &state); @@ -6800,14 +6800,14 @@ int driver_output2(ErlDrvPort ix, char* /* Interface functions available to driver writers */ -int driver_output(ErlDrvPort ix, char* buf, ErlDrvSizeT len) +int __attribute__((externally_visible)) driver_output(ErlDrvPort ix, char* buf, ErlDrvSizeT len) { ERTS_SMP_CHK_NO_PROC_LOCKS; return driver_output2(ix, NULL, 0, buf, len); } -int driver_outputv(ErlDrvPort ix, char* hbuf, ErlDrvSizeT hlen, - ErlIOVec* vec, ErlDrvSizeT skip) +int __attribute__((externally_visible)) +driver_outputv(ErlDrvPort ix, char* hbuf, ErlDrvSizeT hlen, ErlIOVec* vec, ErlDrvSizeT skip) { int n; ErlDrvSizeT len; @@ -6868,7 +6868,8 @@ int driver_outputv(ErlDrvPort ix, char* ** input is a vector a buffer and a max length ** return bytes copied */ -ErlDrvSizeT driver_vec_to_buf(ErlIOVec *vec, char *buf, ErlDrvSizeT len) +ErlDrvSizeT __attribute__((externally_visible)) +driver_vec_to_buf(ErlIOVec *vec, char *buf, ErlDrvSizeT len) { SysIOVec* iov = vec->iov; int n = vec->vsize; @@ -6900,21 +6901,21 @@ ErlDrvSizeT driver_vec_to_buf(ErlIOVec * * reference count on driver binaries... */ -ErlDrvSInt +ErlDrvSInt __attribute__((externally_visible)) driver_binary_get_refc(ErlDrvBinary *dbp) { Binary* bp = ErlDrvBinary2Binary(dbp); return (ErlDrvSInt) erts_refc_read(&bp->refc, 1); } -ErlDrvSInt +ErlDrvSInt __attribute__((externally_visible)) driver_binary_inc_refc(ErlDrvBinary *dbp) { Binary* bp = ErlDrvBinary2Binary(dbp); return (ErlDrvSInt) erts_refc_inctest(&bp->refc, 2); } -ErlDrvSInt +ErlDrvSInt __attribute__((externally_visible)) driver_binary_dec_refc(ErlDrvBinary *dbp) { Binary* bp = ErlDrvBinary2Binary(dbp); @@ -6926,7 +6927,7 @@ driver_binary_dec_refc(ErlDrvBinary *dbp ** Allocation/Deallocation of binary objects */ -ErlDrvBinary* +ErlDrvBinary* __attribute__((externally_visible)) driver_alloc_binary(ErlDrvSizeT size) { Binary* bin; @@ -6940,7 +6941,8 @@ driver_alloc_binary(ErlDrvSizeT size) /* Reallocate space hold by binary */ -ErlDrvBinary* driver_realloc_binary(ErlDrvBinary* bin, ErlDrvSizeT size) +ErlDrvBinary* __attribute__((externally_visible)) +driver_realloc_binary(ErlDrvBinary* bin, ErlDrvSizeT size) { Binary* oldbin; Binary* newbin; @@ -6968,7 +6970,7 @@ ErlDrvBinary* driver_realloc_binary(ErlD } -void driver_free_binary(ErlDrvBinary* dbin) +void __attribute__((externally_visible)) driver_free_binary(ErlDrvBinary* dbin) { Binary *bin; if (!dbin) { @@ -6990,17 +6992,17 @@ void driver_free_binary(ErlDrvBinary* db * Allocation/deallocation of memory for drivers */ -void *driver_alloc(ErlDrvSizeT size) +void __attribute__((externally_visible)) *driver_alloc(ErlDrvSizeT size) { return erts_alloc_fnf(ERTS_ALC_T_DRV, (Uint) size); } -void *driver_realloc(void *ptr, ErlDrvSizeT size) +void __attribute__((externally_visible)) *driver_realloc(void *ptr, ErlDrvSizeT size) { return erts_realloc_fnf(ERTS_ALC_T_DRV, ptr, (Uint) size); } -void driver_free(void *ptr) +void __attribute__((externally_visible)) driver_free(void *ptr) { erts_free(ERTS_ALC_T_DRV, ptr); } @@ -7098,7 +7100,7 @@ static void driver_monitor_unlock_pdl(Po * exported driver_pdl_* functions ... */ -ErlDrvPDL +ErlDrvPDL __attribute__((externally_visible)) driver_pdl_create(ErlDrvPort dp) { ErlDrvPDL pdl; @@ -7118,7 +7120,7 @@ driver_pdl_create(ErlDrvPort dp) return pdl; } -void +void __attribute__((externally_visible)) driver_pdl_lock(ErlDrvPDL pdl) { #ifdef HARDDEBUG @@ -7128,7 +7130,7 @@ driver_pdl_lock(ErlDrvPDL pdl) erts_mtx_lock(&pdl->mtx); } -void +void __attribute__((externally_visible)) driver_pdl_unlock(ErlDrvPDL pdl) { ErlDrvSInt refc; @@ -7141,13 +7143,13 @@ driver_pdl_unlock(ErlDrvPDL pdl) pdl_destroy(pdl); } -ErlDrvSInt +ErlDrvSInt __attribute__((externally_visible)) driver_pdl_get_refc(ErlDrvPDL pdl) { return pdl_read_refc(pdl); } -ErlDrvSInt +ErlDrvSInt __attribute__((externally_visible)) driver_pdl_inc_refc(ErlDrvPDL pdl) { ErlDrvSInt refc = pdl_inctest_refc(pdl); @@ -7158,7 +7160,7 @@ driver_pdl_inc_refc(ErlDrvPDL pdl) return refc; } -ErlDrvSInt +ErlDrvSInt __attribute__((externally_visible)) driver_pdl_dec_refc(ErlDrvPDL pdl) { ErlDrvSInt refc = pdl_dectest_refc(pdl); @@ -7260,7 +7262,7 @@ static int expandq(ErlIOQueue* q, int n, /* Put elements from vec at q tail */ -int driver_enqv(ErlDrvPort ix, ErlIOVec* vec, ErlDrvSizeT skip) +int __attribute__((externally_visible)) driver_enqv(ErlDrvPort ix, ErlIOVec* vec, ErlDrvSizeT skip) { int n; size_t len; @@ -7326,7 +7328,7 @@ int driver_enqv(ErlDrvPort ix, ErlIOVec* } /* Put elements from vec at q head */ -int driver_pushqv(ErlDrvPort ix, ErlIOVec* vec, ErlDrvSizeT skip) +int __attribute__((externally_visible)) driver_pushqv(ErlDrvPort ix, ErlIOVec* vec, ErlDrvSizeT skip) { int n; size_t len; @@ -7397,7 +7399,7 @@ int driver_pushqv(ErlDrvPort ix, ErlIOVe ** Remove size bytes from queue head ** Return number of bytes that remain in queue */ -ErlDrvSizeT driver_deq(ErlDrvPort ix, ErlDrvSizeT size) +ErlDrvSizeT __attribute__((externally_visible)) driver_deq(ErlDrvPort ix, ErlDrvSizeT size) { ErlIOQueue* q = drvport2ioq(ix); ErlDrvSizeT len; @@ -7431,7 +7433,8 @@ ErlDrvSizeT driver_deq(ErlDrvPort ix, Er } -ErlDrvSizeT driver_peekqv(ErlDrvPort ix, ErlIOVec *ev) { +ErlDrvSizeT __attribute__((externally_visible)) driver_peekqv(ErlDrvPort ix, ErlIOVec *ev) +{ ErlIOQueue *q = drvport2ioq(ix); ASSERT(ev); @@ -7451,7 +7454,7 @@ ErlDrvSizeT driver_peekqv(ErlDrvPort ix, } } -SysIOVec* driver_peekq(ErlDrvPort ix, int* vlenp) /* length of io-vector */ +SysIOVec* __attribute__((externally_visible)) driver_peekq(ErlDrvPort ix, int* vlenp) /* length of io-vector */ { ErlIOQueue* q = drvport2ioq(ix); @@ -7465,7 +7468,7 @@ SysIOVec* driver_peekq(ErlDrvPort ix, in } -ErlDrvSizeT driver_sizeq(ErlDrvPort ix) +ErlDrvSizeT __attribute__((externally_visible)) driver_sizeq(ErlDrvPort ix) { ErlIOQueue* q = drvport2ioq(ix); @@ -7478,8 +7481,8 @@ ErlDrvSizeT driver_sizeq(ErlDrvPort ix) /* Utils */ /* Enqueue a binary */ -int driver_enq_bin(ErlDrvPort ix, ErlDrvBinary* bin, - ErlDrvSizeT offs, ErlDrvSizeT len) +int __attribute__((externally_visible)) +driver_enq_bin(ErlDrvPort ix, ErlDrvBinary* bin, ErlDrvSizeT offs, ErlDrvSizeT len) { SysIOVec iov; ErlIOVec ev; @@ -7496,7 +7499,7 @@ int driver_enq_bin(ErlDrvPort ix, ErlDrv return driver_enqv(ix, &ev, 0); } -int driver_enq(ErlDrvPort ix, char* buffer, ErlDrvSizeT len) +int __attribute__((externally_visible)) driver_enq(ErlDrvPort ix, char* buffer, ErlDrvSizeT len) { int code; ErlDrvBinary* bin; @@ -7512,8 +7515,8 @@ int driver_enq(ErlDrvPort ix, char* buff return code; } -int driver_pushq_bin(ErlDrvPort ix, ErlDrvBinary* bin, - ErlDrvSizeT offs, ErlDrvSizeT len) +int __attribute__((externally_visible)) +driver_pushq_bin(ErlDrvPort ix, ErlDrvBinary* bin, ErlDrvSizeT offs, ErlDrvSizeT len) { SysIOVec iov; ErlIOVec ev; @@ -7530,7 +7533,7 @@ int driver_pushq_bin(ErlDrvPort ix, ErlD return driver_pushqv(ix, &ev, 0); } -int driver_pushq(ErlDrvPort ix, char* buffer, ErlDrvSizeT len) +int __attribute__((externally_visible)) driver_pushq(ErlDrvPort ix, char* buffer, ErlDrvSizeT len) { int code; ErlDrvBinary* bin; @@ -7547,7 +7550,7 @@ int driver_pushq(ErlDrvPort ix, char* bu return code; } -int driver_set_timer(ErlDrvPort ix, unsigned long t) +int __attribute__((externally_visible)) driver_set_timer(ErlDrvPort ix, unsigned long t) { Port* prt = erts_drvport2port(ix); @@ -7563,7 +7566,7 @@ int driver_set_timer(ErlDrvPort ix, unsi return 0; } -int driver_cancel_timer(ErlDrvPort ix) +int __attribute__((externally_visible)) driver_cancel_timer(ErlDrvPort ix) { Port* prt = erts_drvport2port(ix); if (prt == ERTS_INVALID_ERL_DRV_PORT) @@ -7573,7 +7576,7 @@ int driver_cancel_timer(ErlDrvPort ix) return 0; } -int +int __attribute__((externally_visible)) driver_read_timer(ErlDrvPort ix, unsigned long* t) { Port* prt = erts_drvport2port(ix); @@ -7594,7 +7597,7 @@ driver_read_timer(ErlDrvPort ix, unsigne return 0; } -int +int __attribute__((externally_visible)) driver_get_now(ErlDrvNowData *now_data) { Uint mega,secs,micro; @@ -7673,9 +7676,8 @@ static int do_driver_monitor_process(Por /* * This can be called from a non scheduler thread iff a port_data_lock exists */ -int driver_monitor_process(ErlDrvPort drvport, - ErlDrvTermData process, - ErlDrvMonitor *monitor) +int __attribute__((externally_visible)) +driver_monitor_process(ErlDrvPort drvport, ErlDrvTermData process, ErlDrvMonitor *monitor) { Port *prt; int ret; @@ -7737,8 +7739,8 @@ static int do_driver_demonitor_process(P return 0; } -int driver_demonitor_process(ErlDrvPort drvport, - const ErlDrvMonitor *monitor) +int __attribute__((externally_visible)) +driver_demonitor_process(ErlDrvPort drvport, const ErlDrvMonitor *monitor) { Port *prt; int ret; @@ -7782,9 +7784,8 @@ static ErlDrvTermData do_driver_get_moni return (ErlDrvTermData) to; } - -ErlDrvTermData driver_get_monitored_process(ErlDrvPort drvport, - const ErlDrvMonitor *monitor) +ErlDrvTermData __attribute__((externally_visible)) +driver_get_monitored_process(ErlDrvPort drvport, const ErlDrvMonitor *monitor) { Port *prt; ErlDrvTermData ret; @@ -7809,9 +7810,8 @@ ErlDrvTermData driver_get_monitored_proc return ret; } - -int driver_compare_monitors(const ErlDrvMonitor *monitor1, - const ErlDrvMonitor *monitor2) +int __attribute__((externally_visible)) +driver_compare_monitors(const ErlDrvMonitor *monitor1, const ErlDrvMonitor *monitor2) { return memcmp(monitor1,monitor2,sizeof(ErlDrvMonitor)); } @@ -7903,7 +7903,7 @@ driver_failure_term(ErlDrvPort ix, Eterm ** Do a (soft) exit. unlink the connected process before doing ** driver posix error or (normal) */ -int driver_exit(ErlDrvPort ix, int err) +int __attribute__((externally_visible)) driver_exit(ErlDrvPort ix, int err) { Port* prt = erts_drvport2port(ix); Process* rp; @@ -7947,12 +7947,12 @@ int driver_exit(ErlDrvPort ix, int err) } -int driver_failure(ErlDrvPort ix, int code) +int __attribute__((externally_visible)) driver_failure(ErlDrvPort ix, int code) { return driver_failure_term(ix, make_small(code), code == 0); } -int driver_failure_atom(ErlDrvPort ix, char* string) +int __attribute__((externally_visible)) driver_failure_atom(ErlDrvPort ix, char* string) { return driver_failure_term(ix, erts_atom_put((byte *) string, @@ -7962,19 +7962,19 @@ int driver_failure_atom(ErlDrvPort ix, c 0); } -int driver_failure_posix(ErlDrvPort ix, int err) +int __attribute__((externally_visible)) driver_failure_posix(ErlDrvPort ix, int err) { return driver_failure_atom(ix, erl_errno_id(err)); } -int driver_failure_eof(ErlDrvPort ix) +int __attribute__((externally_visible)) driver_failure_eof(ErlDrvPort ix) { return driver_failure_term(ix, NIL, 1); } -ErlDrvTermData driver_mk_atom(char* string) +ErlDrvTermData __attribute__((externally_visible)) driver_mk_atom(char* string) { Eterm am = erts_atom_put((byte *) string, sys_strlen(string), @@ -7984,7 +7984,7 @@ ErlDrvTermData driver_mk_atom(char* stri return (ErlDrvTermData) am; } -ErlDrvTermData driver_mk_port(ErlDrvPort ix) +ErlDrvTermData __attribute__((externally_visible)) driver_mk_port(ErlDrvPort ix) { Port* prt = erts_drvport2port(ix); if (prt == ERTS_INVALID_ERL_DRV_PORT) @@ -7993,7 +7993,7 @@ ErlDrvTermData driver_mk_port(ErlDrvPort return (ErlDrvTermData) prt->common.id; } -ErlDrvTermData driver_connected(ErlDrvPort ix) +ErlDrvTermData __attribute__((externally_visible)) driver_connected(ErlDrvPort ix) { Port* prt = erts_drvport2port(ix); ERTS_SMP_CHK_NO_PROC_LOCKS; @@ -8003,7 +8003,7 @@ ErlDrvTermData driver_connected(ErlDrvPo return ERTS_PORT_GET_CONNECTED(prt); } -ErlDrvTermData driver_caller(ErlDrvPort ix) +ErlDrvTermData __attribute__((externally_visible)) driver_caller(ErlDrvPort ix) { Port* prt = erts_drvport2port(ix); ERTS_SMP_CHK_NO_PROC_LOCKS; @@ -8013,7 +8013,7 @@ ErlDrvTermData driver_caller(ErlDrvPort return prt->caller; } -int driver_lock_driver(ErlDrvPort ix) +int __attribute__((externally_visible)) driver_lock_driver(ErlDrvPort ix) { Port* prt = erts_drvport2port(ix); DE_Handle* dh; @@ -8068,7 +8068,7 @@ static void maybe_unlock_driver_list(int Writing code using these interfaces spanning several driver callbacks between loading/lookup and error handling may give undesired results... */ -void *driver_dl_open(char * path) +void* __attribute__((externally_visible)) driver_dl_open(char * path) { void *ptr; int res; @@ -8088,7 +8088,7 @@ void *driver_dl_open(char * path) } } -void *driver_dl_sym(void * handle, char *func_name) +void* __attribute__((externally_visible)) driver_dl_sym(void * handle, char *func_name) { void *ptr; int res; @@ -8108,7 +8108,7 @@ void *driver_dl_sym(void * handle, char } } -int driver_dl_close(void *handle) +int __attribute__((externally_visible)) driver_dl_close(void *handle) { int res; int locked = maybe_lock_driver_list(); @@ -8117,7 +8117,7 @@ int driver_dl_close(void *handle) return res; } -char *driver_dl_error(void) +char* __attribute__((externally_visible)) driver_dl_error(void) { char *res; int *last_error_p = erts_smp_tsd_get(driver_list_lock_status_key); @@ -8132,7 +8132,7 @@ char *driver_dl_error(void) (offsetof(ErlDrvSysInfo, LAST_FIELD) \ + sizeof(((ErlDrvSysInfo *) 0)->LAST_FIELD)) -void +void __attribute__((externally_visible)) driver_system_info(ErlDrvSysInfo *sip, size_t si_size) { /* @@ -8357,7 +8357,8 @@ erts_destroy_driver(erts_driver_t *drv) * Exposed in the driver interface, and therefore possibly locking directly. */ -void add_driver_entry(ErlDrvEntry *drv){ +void __attribute__((externally_visible)) add_driver_entry(ErlDrvEntry *drv) +{ void *rec_lock; rec_lock = erts_smp_tsd_get(driver_list_lock_status_key); /* @@ -8408,7 +8409,7 @@ int erts_add_driver_entry(ErlDrvEntry *d } /* Not allowed for dynamic drivers */ -int remove_driver_entry(ErlDrvEntry *drv) +int __attribute__((externally_visible)) remove_driver_entry(ErlDrvEntry *drv) { erts_driver_t *dp; void *rec_lock; @@ -8450,18 +8451,18 @@ int remove_driver_entry(ErlDrvEntry *drv /* very useful function that can be used in entries that are not used * so that not every driver writer must supply a personal version */ -int null_func(void) +int __attribute__((externally_visible)) null_func(void) { return 0; } -int +int __attribute__((externally_visible)) erl_drv_putenv(const char *key, char *value) { return erts_sys_putenv_raw((char*)key, value); } -int +int __attribute__((externally_visible)) erl_drv_getenv(const char *key, char *value, size_t *value_size) { return erts_sys_getenv_raw((char*)key, value, value_size); diff -Ndurp otp_src_19.2/erts/emulator/sys/unix/sys.c otp_src_19.2-erts-symbols/erts/emulator/sys/unix/sys.c --- otp_src_19.2/erts/emulator/sys/unix/sys.c 2016-12-09 12:45:24.000000000 +0200 +++ otp_src_19.2-erts-symbols/erts/emulator/sys/unix/sys.c 2017-01-01 23:26:54.498659124 +0200 @@ -172,13 +172,13 @@ struct { } io_func = {0}; -int +int __attribute__((externally_visible)) driver_select(ErlDrvPort port, ErlDrvEvent event, int mode, int on) { return (*io_func.select)(port, event, mode, on); } -int +int __attribute__((externally_visible)) driver_event(ErlDrvPort port, ErlDrvEvent event, ErlDrvEventData event_data) { return (*io_func.event)(port, event, event_data); diff -Ndurp otp_src_19.2/erts/emulator/sys/unix/sys_float.c otp_src_19.2-erts-symbols/erts/emulator/sys/unix/sys_float.c --- otp_src_19.2/erts/emulator/sys/unix/sys_float.c 2016-12-09 12:45:24.000000000 +0200 +++ otp_src_19.2-erts-symbols/erts/emulator/sys/unix/sys_float.c 2017-01-01 23:26:54.498659124 +0200 @@ -683,7 +683,7 @@ void erts_thread_init_float(void) #endif } -void erts_thread_disable_fpe(void) +void __attribute__((externally_visible)) erts_thread_disable_fpe(void) { #if !defined(NO_FPE_SIGNALS) (void)mask_fpe(); diff -Ndurp otp_src_19.2/erts/lib_src/common/erl_memory_trace_parser.c otp_src_19.2-erts-symbols/erts/lib_src/common/erl_memory_trace_parser.c --- otp_src_19.2/erts/lib_src/common/erl_memory_trace_parser.c 2016-12-09 12:45:24.000000000 +0200 +++ otp_src_19.2-erts-symbols/erts/lib_src/common/erl_memory_trace_parser.c 2017-01-01 23:26:54.499659096 +0200 @@ -160,7 +160,7 @@ struct emtp_state_ { static char unknown_allocator[] = "unknown_allocator"; static char unknown_block_type[] = "unknown_block_type"; -const char * +const char * __attribute__((externally_visible)) emtp_error_string(int res) { switch (res) { @@ -202,7 +202,7 @@ emtp_error_string(int res) } -int +int __attribute__((externally_visible)) emtp_get_info(emtp_info *infop, size_t *info_szp, emtp_state *statep) { if (!infop || !info_szp || *info_szp < sizeof(emtp_info)) @@ -254,7 +254,7 @@ emtp_get_info(emtp_info *infop, size_t * return 1; } -emtp_state * +emtp_state * __attribute__((externally_visible)) emtp_state_new(void * (*alloc)(size_t), void * (*realloc)(void *, size_t), void (*free)(void *)) @@ -307,7 +307,7 @@ emtp_state_new(void * (*alloc)(size_t), return statep; } -void +void __attribute__((externally_visible)) emtp_state_destroy(emtp_state *statep) { void (*freep)(void *); @@ -1653,7 +1653,7 @@ parse_header(emtp_state *statep, } -int +int __attribute__((externally_visible)) emtp_parse(emtp_state *statep, usgnd_int_8 **tracepp, size_t *trace_lenp, emtp_operation *op_start, size_t op_size, size_t *op_lenp)
Locations
Projects
Search
Status Monitor
Help
OpenBuildService.org
Documentation
API Documentation
Code of Conduct
Contact
Support
@OBShq
Terms
openSUSE Build Service is sponsored by
The Open Build Service is an
openSUSE project
.
Sign Up
Log In
Places
Places
All Projects
Status Monitor
