File otp_src_24.3.4.13-erts-symbols.patch of Package erlang

Overview Repositories Revisions Requests Users Attributes Meta

File otp_src_24.3.4.13-erts-symbols.patch of Package erlang (Revision 9440da27151d64996ef430f593e940c0)

Currently displaying revision 9440da27151d64996ef430f593e940c0 , Show latest

diff -Ndurp otp_src_24.3.4.13/erts/emulator/beam/erl_async.c otp_src_24.3.4.13-erts-symbols/erts/emulator/beam/erl_async.c
--- otp_src_24.3.4.13/erts/emulator/beam/erl_async.c	2023-06-28 13:00:52.000000000 +0300
+++ otp_src_24.3.4.13-erts-symbols/erts/emulator/beam/erl_async.c	2023-08-29 22:27:20.748446876 +0300
@@ -525,6 +525,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.
 */
+__attribute__((externally_visible))
 unsigned int driver_async_port_key(ErlDrvPort port)
 {
     ErlDrvTermData td = driver_mk_port(port);
@@ -548,6 +549,7 @@ 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
 */
+__attribute__((externally_visible))
 long driver_async(ErlDrvPort ix, unsigned int* key,
 		  void (*async_invoke)(void*), void* async_data,
 		  void (*async_free)(void*))
diff -Ndurp otp_src_24.3.4.13/erts/emulator/beam/erl_drv_thread.c otp_src_24.3.4.13-erts-symbols/erts/emulator/beam/erl_drv_thread.c
--- otp_src_24.3.4.13/erts/emulator/beam/erl_drv_thread.c	2023-06-28 13:00:52.000000000 +0300
+++ otp_src_24.3.4.13-erts-symbols/erts/emulator/beam/erl_drv_thread.c	2023-08-29 22:27:20.748446876 +0300
@@ -148,6 +148,7 @@ void erl_drv_thr_init(void)
  * either the erl_threads.h or the ethread.h interface.
  */
 
+__attribute__((externally_visible))
 ErlDrvMutex *
 erl_drv_mutex_create(char *name)
 {
@@ -178,6 +179,7 @@ erl_drv_mutex_create(char *name)
     return dmtx;
 }
 
+__attribute__((externally_visible))
 void
 erl_drv_mutex_destroy(ErlDrvMutex *dmtx)
 {
@@ -192,12 +194,14 @@ erl_drv_mutex_destroy(ErlDrvMutex *dmtx)
 }
 
 
+__attribute__((externally_visible))
 char *
 erl_drv_mutex_name(ErlDrvMutex *dmtx)
 {
     return dmtx ? dmtx->name : NULL;
 }
 
+__attribute__((externally_visible))
 int
 erl_drv_mutex_trylock(ErlDrvMutex *dmtx)
 {
@@ -214,6 +218,7 @@ erl_drv_mutex_trylock(ErlDrvMutex *dmtx)
     return res;
 }
 
+__attribute__((externally_visible))
 void
 erl_drv_mutex_lock(ErlDrvMutex *dmtx)
 {
@@ -231,6 +236,7 @@ erl_drv_mutex_lock(ErlDrvMutex *dmtx)
 #endif
 }
 
+__attribute__((externally_visible))
 void
 erl_drv_mutex_unlock(ErlDrvMutex *dmtx)
 {
@@ -245,6 +251,7 @@ erl_drv_mutex_unlock(ErlDrvMutex *dmtx)
     ethr_mutex_unlock(&dmtx->mtx);
 }
 
+__attribute__((externally_visible))
 ErlDrvCond *
 erl_drv_cond_create(char *name)
 {
@@ -268,6 +275,7 @@ erl_drv_cond_create(char *name)
     return dcnd;
 }
 
+__attribute__((externally_visible))
 void
 erl_drv_cond_destroy(ErlDrvCond *dcnd)
 {
@@ -277,12 +285,14 @@ erl_drv_cond_destroy(ErlDrvCond *dcnd)
     erts_free(ERTS_ALC_T_DRV_CND, (void *) dcnd);
 }
 
+__attribute__((externally_visible))
 char *
 erl_drv_cond_name(ErlDrvCond *dcnd)
 {
     return dcnd ? dcnd->name : NULL;
 }
 
+__attribute__((externally_visible))
 void
 erl_drv_cond_signal(ErlDrvCond *dcnd)
 {
@@ -291,6 +301,7 @@ erl_drv_cond_signal(ErlDrvCond *dcnd)
     ethr_cond_signal(&dcnd->cnd);
 }
 
+__attribute__((externally_visible))
 void
 erl_drv_cond_broadcast(ErlDrvCond *dcnd)
 {
@@ -300,6 +311,7 @@ erl_drv_cond_broadcast(ErlDrvCond *dcnd)
 }
 
 
+__attribute__((externally_visible))
 void
 erl_drv_cond_wait(ErlDrvCond *dcnd, ErlDrvMutex *dmtx)
 {
@@ -321,6 +333,7 @@ erl_drv_cond_wait(ErlDrvCond *dcnd, ErlD
     }
 }
 
+__attribute__((externally_visible))
 ErlDrvRWLock *
 erl_drv_rwlock_create(char *name)
 {
@@ -346,6 +359,7 @@ erl_drv_rwlock_create(char *name)
     return drwlck;
 }
 
+__attribute__((externally_visible))
 void
 erl_drv_rwlock_destroy(ErlDrvRWLock *drwlck)
 {
@@ -359,12 +373,14 @@ erl_drv_rwlock_destroy(ErlDrvRWLock *drw
     erts_free(ERTS_ALC_T_DRV_RWLCK, (void *) drwlck);
 }
 
+__attribute__((externally_visible))
 char *
 erl_drv_rwlock_name(ErlDrvRWLock *drwlck)
 {
     return drwlck ? drwlck->name : NULL;
 }
 
+__attribute__((externally_visible))
 int
 erl_drv_rwlock_tryrlock(ErlDrvRWLock *drwlck)
 {
@@ -378,6 +394,7 @@ erl_drv_rwlock_tryrlock(ErlDrvRWLock *dr
     return res;
 }
 
+__attribute__((externally_visible))
 void
 erl_drv_rwlock_rlock(ErlDrvRWLock *drwlck)
 {
@@ -392,6 +409,7 @@ erl_drv_rwlock_rlock(ErlDrvRWLock *drwlc
 #endif
 }
 
+__attribute__((externally_visible))
 void
 erl_drv_rwlock_runlock(ErlDrvRWLock *drwlck)
 {
@@ -403,6 +421,7 @@ erl_drv_rwlock_runlock(ErlDrvRWLock *drw
     ethr_rwmutex_runlock(&drwlck->rwmtx);
 }
 
+__attribute__((externally_visible))
 int
 erl_drv_rwlock_tryrwlock(ErlDrvRWLock *drwlck)
 {
@@ -416,6 +435,7 @@ erl_drv_rwlock_tryrwlock(ErlDrvRWLock *d
     return res;
 }
 
+__attribute__((externally_visible))
 void
 erl_drv_rwlock_rwlock(ErlDrvRWLock *drwlck)
 {
@@ -430,6 +450,7 @@ erl_drv_rwlock_rwlock(ErlDrvRWLock *drwl
 #endif
 }
 
+__attribute__((externally_visible))
 void
 erl_drv_rwlock_rwunlock(ErlDrvRWLock *drwlck)
 {
@@ -441,6 +462,7 @@ erl_drv_rwlock_rwunlock(ErlDrvRWLock *dr
     ethr_rwmutex_rwunlock(&drwlck->rwmtx);
 }
 
+__attribute__((externally_visible))
 int
 erl_drv_tsd_key_create(char *name, ErlDrvTSDKey *key)
 {
@@ -513,6 +535,7 @@ erl_drv_tsd_key_create(char *name, ErlDr
     return res;
 }
 
+__attribute__((externally_visible))
 void
 erl_drv_tsd_key_destroy(ErlDrvTSDKey key)
 {
@@ -535,6 +558,7 @@ erl_drv_tsd_key_destroy(ErlDrvTSDKey key
 #define ERL_DRV_TSD__ (dtid->tsd)
 #define ERL_DRV_TSD_LEN__ (dtid->tsd_len)
 
+__attribute__((externally_visible))
 void
 erl_drv_tsd_set(ErlDrvTSDKey key, void *data)
 {
@@ -563,6 +587,7 @@ erl_drv_tsd_set(ErlDrvTSDKey key, void *
     ERL_DRV_TSD__[key] = data;
 }
 
+__attribute__((externally_visible))
 void *
 erl_drv_tsd_get(ErlDrvTSDKey key)
 {
@@ -579,6 +604,7 @@ erl_drv_tsd_get(ErlDrvTSDKey key)
 #undef ERL_DRV_TSD_LEN__
 #undef ERL_DRV_TSD__
 
+__attribute__((externally_visible))
 ErlDrvThreadOpts *
 erl_drv_thread_opts_create(char *name)
 {
@@ -590,6 +616,7 @@ erl_drv_thread_opts_create(char *name)
     return opts;
 }
 
+__attribute__((externally_visible))
 void
 erl_drv_thread_opts_destroy(ErlDrvThreadOpts *opts)
 {
@@ -598,6 +625,7 @@ erl_drv_thread_opts_destroy(ErlDrvThread
     erts_free(ERTS_ALC_T_DRV_THR_OPTS, opts);
 }
 
+__attribute__((externally_visible))
 int
 erl_drv_thread_create(char *name,
 		      ErlDrvTid *tid,
@@ -648,6 +676,7 @@ erl_drv_thread_create(char *name,
     return 0;
 }
 
+__attribute__((externally_visible))
 char *
 erl_drv_thread_name(ErlDrvTid tid)
 {
@@ -656,6 +685,7 @@ erl_drv_thread_name(ErlDrvTid tid)
 }
 
 
+__attribute__((externally_visible))
 ErlDrvTid
 erl_drv_thread_self(void)
 {
@@ -679,6 +709,7 @@ erl_drv_thread_self(void)
     return (ErlDrvTid) dtid;
 }
 
+__attribute__((externally_visible))
 int
 erl_drv_equal_tids(ErlDrvTid tid1, ErlDrvTid tid2)
 {   
@@ -697,6 +728,7 @@ erl_drv_equal_tids(ErlDrvTid tid1, ErlDr
     return res;
 }
 
+__attribute__((externally_visible))
 void
 erl_drv_thread_exit(void *res)
 {
@@ -708,6 +740,7 @@ erl_drv_thread_exit(void *res)
     fatal_error(EACCES, "erl_drv_thread_exit()");
 }
 
+__attribute__((externally_visible))
 int
 erl_drv_thread_join(ErlDrvTid tid, void **respp)
 {
diff -Ndurp otp_src_24.3.4.13/erts/emulator/beam/erl_init.c otp_src_24.3.4.13-erts-symbols/erts/emulator/beam/erl_init.c
--- otp_src_24.3.4.13/erts/emulator/beam/erl_init.c	2023-06-28 13:00:52.000000000 +0300
+++ otp_src_24.3.4.13-erts-symbols/erts/emulator/beam/erl_init.c	2023-08-29 22:27:20.748446876 +0300
@@ -2584,6 +2584,7 @@ __decl_noreturn void __noreturn erts_exi
 }
 
 /* Exit without flushing async threads */
+__attribute__((externally_visible))
 __decl_noreturn void __noreturn erts_exit(int n, const char *fmt, ...)
 {
     va_list args1, args2;
@@ -2595,6 +2596,7 @@ __decl_noreturn void __noreturn erts_exi
 }
 
 /* Exit after flushing async threads */
+__attribute__((externally_visible))
 __decl_noreturn void __noreturn erts_flush_async_exit(int n, char *fmt, ...)
 {
     va_list args1, args2;
diff -Ndurp otp_src_24.3.4.13/erts/emulator/beam/erl_nif.c otp_src_24.3.4.13-erts-symbols/erts/emulator/beam/erl_nif.c
--- otp_src_24.3.4.13/erts/emulator/beam/erl_nif.c	2023-06-28 13:00:52.000000000 +0300
+++ otp_src_24.3.4.13-erts-symbols/erts/emulator/beam/erl_nif.c	2023-08-29 22:28:46.478651881 +0300
@@ -526,21 +526,25 @@ static void cache_env(ErlNifEnv* env)
     }
 }
 
+__attribute__((externally_visible))
 void* enif_priv_data(ErlNifEnv* env)
 {
     return env->mod_nif->priv_data;
 }
 
+__attribute__((externally_visible))
 void* enif_alloc(size_t size)
 {
     return erts_alloc_fnf(ERTS_ALC_T_NIF, (Uint) size);
 }
 
+__attribute__((externally_visible))
 void* enif_realloc(void* ptr, size_t size)
 {
     return erts_realloc_fnf(ERTS_ALC_T_NIF, ptr, size);
 }
 
+__attribute__((externally_visible))
 void enif_free(void* ptr)
 {
     erts_free(ERTS_ALC_T_NIF, ptr);
@@ -593,6 +597,7 @@ setup_nif_env(struct enif_msg_environmen
 #endif
 }
 
+__attribute__((externally_visible))
 ErlNifEnv* enif_alloc_env(void)
 {
     struct enif_msg_environment_t* msg_env =
@@ -600,6 +605,7 @@ ErlNifEnv* enif_alloc_env(void)
     setup_nif_env(msg_env, NULL, NULL);
     return &msg_env->env;
 }
+__attribute__((externally_visible))
 void enif_free_env(ErlNifEnv* env)
 {
     enif_clear_env(env);
@@ -624,6 +630,7 @@ static ERTS_INLINE void clear_offheap(Er
     oh->overhead = 0;
 }
 
+__attribute__((externally_visible))
 void enif_clear_env(ErlNifEnv* env)
 {
     struct enif_msg_environment_t* menv = (struct enif_msg_environment_t*)env;
@@ -776,6 +783,7 @@ static ERTS_INLINE ERL_NIF_TERM make_cop
     return copy_struct(src_term, sz, &hp, &MSO(dst_env->proc));
 }
 
+__attribute__((externally_visible))
 int enif_send(ErlNifEnv* env, const ErlNifPid* to_pid,
 	      ErlNifEnv* msg_env, ERL_NIF_TERM msg)
 {
@@ -1005,6 +1013,7 @@ done:
     return 1;
 }
 
+__attribute__((externally_visible))
 int
 enif_port_command(ErlNifEnv *env, const ErlNifPort* to_port,
                   ErlNifEnv *msg_env, ERL_NIF_TERM msg)
@@ -1079,6 +1088,7 @@ static Eterm call_whereis(ErlNifEnv *env
     return res;
 }
 
+__attribute__((externally_visible))
 int enif_whereis_pid(ErlNifEnv *env, ERL_NIF_TERM name, ErlNifPid *pid)
 {
     Eterm res;
@@ -1091,6 +1101,7 @@ int enif_whereis_pid(ErlNifEnv *env, ERL
     return enif_get_local_pid(env, res, pid);
 }
 
+__attribute__((externally_visible))
 int enif_whereis_port(ErlNifEnv *env, ERL_NIF_TERM name, ErlNifPort *port)
 {
     Eterm res;
@@ -1103,6 +1114,7 @@ int enif_whereis_port(ErlNifEnv *env, ER
     return enif_get_local_port(env, res, port);
 }
 
+__attribute__((externally_visible))
 ERL_NIF_TERM enif_make_copy(ErlNifEnv* dst_env, ERL_NIF_TERM src_term)
 {
     return make_copy(dst_env, src_term, NULL);
@@ -1115,6 +1127,7 @@ static int is_offheap(const ErlOffHeap*
 }
 #endif
 
+__attribute__((externally_visible))
 ErlNifPid* enif_self(ErlNifEnv* caller_env, ErlNifPid* pid)
 {
     if (caller_env->proc->common.id == ERTS_INVALID_PID)
@@ -1123,6 +1136,7 @@ ErlNifPid* enif_self(ErlNifEnv* caller_e
     return pid;
 }
 
+__attribute__((externally_visible))
 int enif_get_local_pid(ErlNifEnv* env, ERL_NIF_TERM term, ErlNifPid* pid)
 {
     if (is_internal_pid(term)) {
@@ -1132,17 +1146,20 @@ int enif_get_local_pid(ErlNifEnv* env, E
     return 0;
 }
 
+__attribute__((externally_visible))
 void enif_set_pid_undefined(ErlNifPid* pid)
 {
     pid->pid = am_undefined;
 }
 
+__attribute__((externally_visible))
 int enif_is_pid_undefined(const ErlNifPid* pid)
 {
     ASSERT(pid->pid == am_undefined || is_internal_pid(pid->pid));
     return pid->pid == am_undefined;
 }
 
+__attribute__((externally_visible))
 int enif_get_local_port(ErlNifEnv* env, ERL_NIF_TERM term, ErlNifPort* port)
 {
     if (is_internal_port(term)) {
@@ -1152,61 +1169,73 @@ int enif_get_local_port(ErlNifEnv* env,
     return 0;
 }
 
+__attribute__((externally_visible))
 int enif_is_atom(ErlNifEnv* env, ERL_NIF_TERM term)
 {
     return is_atom(term);
 }
 
+__attribute__((externally_visible))
 int enif_is_binary(ErlNifEnv* env, ERL_NIF_TERM term)
 {
     return is_binary(term) && (binary_bitsize(term) % 8 == 0);
 }
 
+__attribute__((externally_visible))
 int enif_is_empty_list(ErlNifEnv* env, ERL_NIF_TERM term)
 {
     return is_nil(term);
 }
 
+__attribute__((externally_visible))
 int enif_is_fun(ErlNifEnv* env, ERL_NIF_TERM term)
 {
     return is_fun(term);
 }
 
+__attribute__((externally_visible))
 int enif_is_pid(ErlNifEnv* env, ERL_NIF_TERM term)
 {
     return is_pid(term);
 }
 
+__attribute__((externally_visible))
 int enif_is_port(ErlNifEnv* env, ERL_NIF_TERM term)
 {
     return is_port(term);
 }
 
+__attribute__((externally_visible))
 int enif_is_ref(ErlNifEnv* env, ERL_NIF_TERM term)
 {
     return is_ref(term);
 }
 
+__attribute__((externally_visible))
 int enif_is_tuple(ErlNifEnv* env, ERL_NIF_TERM term)
 {
     return is_tuple(term);
 }
 
+__attribute__((externally_visible))
 int enif_is_list(ErlNifEnv* env, ERL_NIF_TERM term)
 {
     return is_list(term) || is_nil(term);
 }
 
+__attribute__((externally_visible))
 int enif_is_exception(ErlNifEnv* env, ERL_NIF_TERM term)
 {
     return env->exception_thrown && term == THE_NON_VALUE;
 }
 
+__attribute__((externally_visible))
 int enif_is_number(ErlNifEnv* env, ERL_NIF_TERM term)
 {
     return is_number(term);
 }
 
+__attribute__((externally_visible))
 ErlNifTermType enif_term_type(ErlNifEnv* env, ERL_NIF_TERM term) {
     (void)env;
 
@@ -1253,6 +1282,7 @@ static void aligned_binary_dtor(struct e
     erts_free_aligned_binary_bytes_extra((byte*)obj, obj->allocator);
 }
 
+__attribute__((externally_visible))
 int 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;
@@ -1288,6 +1318,7 @@ int enif_inspect_binary(ErlNifEnv* env,
     return 1;
 }
 
+__attribute__((externally_visible))
 int enif_inspect_iolist_as_binary(ErlNifEnv* env, Eterm term, ErlNifBinary* bin)
 {
     ErlDrvSizeT sz;
@@ -1312,6 +1343,7 @@ int enif_inspect_iolist_as_binary(ErlNif
     return 1;
 }
 
+__attribute__((externally_visible))
 int enif_alloc_binary(size_t size, ErlNifBinary* bin)
 {
     Binary* refbin;
@@ -1327,6 +1359,7 @@ int enif_alloc_binary(size_t size, ErlNi
     return 1;
 }
 
+__attribute__((externally_visible))
 int enif_realloc_binary(ErlNifBinary* bin, size_t size)
 {
     if (bin->ref_bin != NULL) {
@@ -1352,6 +1385,7 @@ int enif_realloc_binary(ErlNifBinary* bi
 }
 
 
+__attribute__((externally_visible))
 void enif_release_binary(ErlNifBinary* bin)
 {
     if (bin->ref_bin != NULL) {
@@ -1364,6 +1398,7 @@ void enif_release_binary(ErlNifBinary* b
 #endif
 }
 
+__attribute__((externally_visible))
 unsigned char* enif_make_new_binary(ErlNifEnv* env, size_t size,
 				    ERL_NIF_TERM* termp)
 {
@@ -1373,6 +1408,7 @@ unsigned char* enif_make_new_binary(ErlN
     return binary_bytes(*termp);
 }
 
+__attribute__((externally_visible))
 int enif_term_to_binary(ErlNifEnv *dst_env, ERL_NIF_TERM term,
                         ErlNifBinary *bin)
 {
@@ -1405,6 +1441,7 @@ int enif_term_to_binary(ErlNifEnv *dst_e
     return 1;
 }
 
+__attribute__((externally_visible))
 size_t enif_binary_to_term(ErlNifEnv *dst_env,
                            const unsigned char* data,
                            size_t data_sz,
@@ -1445,11 +1482,13 @@ size_t enif_binary_to_term(ErlNifEnv *ds
     return bp - data;
 }
 
+__attribute__((externally_visible))
 int enif_is_identical(Eterm lhs, Eterm rhs)
 {
     return EQ(lhs,rhs);
 }
 
+__attribute__((externally_visible))
 int enif_compare(Eterm lhs, Eterm rhs)
 {
     Sint result = CMP(lhs,rhs);
@@ -1463,6 +1502,7 @@ int enif_compare(Eterm lhs, Eterm rhs)
     return result;
 }
 
+__attribute__((externally_visible))
 ErlNifUInt64 enif_hash(ErlNifHash type, Eterm term, ErlNifUInt64 salt)
 {
     switch (type) {
@@ -1479,6 +1519,7 @@ ErlNifUInt64 enif_hash(ErlNifHash type,
     }
 }
 
+__attribute__((externally_visible))
 int enif_get_tuple(ErlNifEnv* env, Eterm tpl, int* arity, const Eterm** array)
 {
     Eterm* ptr;
@@ -1491,6 +1532,7 @@ int enif_get_tuple(ErlNifEnv* env, Eterm
     return 1;
 }
 
+__attribute__((externally_visible))
 int enif_get_string(ErlNifEnv *env, ERL_NIF_TERM list, char* buf, unsigned len,
 		    ErlNifCharEncoding encoding)
 {
@@ -1523,6 +1565,7 @@ int enif_get_string(ErlNifEnv *env, ERL_
     return n + 1;
 }
 
+__attribute__((externally_visible))
 Eterm enif_make_binary(ErlNifEnv* env, ErlNifBinary* bin)
 {
     Eterm bin_term;
@@ -1572,6 +1615,7 @@ Eterm enif_make_binary(ErlNifEnv* env, E
     return bin_term;
 }
 
+__attribute__((externally_visible))
 Eterm enif_make_sub_binary(ErlNifEnv* env, ERL_NIF_TERM bin_term,
 			   size_t pos, size_t size)
 {
@@ -1600,11 +1644,13 @@ Eterm enif_make_sub_binary(ErlNifEnv* en
 }
 
 
+__attribute__((externally_visible))
 Eterm enif_make_badarg(ErlNifEnv* env)
 {
     return enif_raise_exception(env, am_badarg);
 }
 
+__attribute__((externally_visible))
 Eterm enif_raise_exception(ErlNifEnv* env, ERL_NIF_TERM reason)
 {
     env->exception_thrown = 1;
@@ -1612,6 +1658,7 @@ Eterm enif_raise_exception(ErlNifEnv* en
     BIF_ERROR(env->proc, EXC_ERROR);
 }
 
+__attribute__((externally_visible))
 int enif_has_pending_exception(ErlNifEnv* env, ERL_NIF_TERM* reason)
 {
     if (env->exception_thrown && reason != NULL)
@@ -1619,6 +1666,7 @@ int enif_has_pending_exception(ErlNifEnv
     return env->exception_thrown;
 }
 
+__attribute__((externally_visible))
 int enif_get_atom(ErlNifEnv* env, Eterm atom, char* buf, unsigned len,
 		  ErlNifCharEncoding encoding)
 {
@@ -1643,6 +1691,7 @@ int enif_get_atom(ErlNifEnv* env, Eterm
     return ap->latin1_chars + 1;
 }
 
+__attribute__((externally_visible))
 int enif_get_int(ErlNifEnv* env, Eterm term, int* ip)
 {
 #if SIZEOF_INT ==  ERTS_SIZEOF_ETERM
@@ -1660,6 +1709,7 @@ int enif_get_int(ErlNifEnv* env, Eterm t
 #endif     
 }
 
+__attribute__((externally_visible))
 int enif_get_uint(ErlNifEnv* env, Eterm term, unsigned* ip)
 {
 #if SIZEOF_INT == ERTS_SIZEOF_ETERM
@@ -1675,6 +1725,7 @@ int enif_get_uint(ErlNifEnv* env, Eterm
 #endif     
 }
 
+__attribute__((externally_visible))
 int enif_get_long(ErlNifEnv* env, Eterm term, long* ip)
 {
 #if SIZEOF_LONG == ERTS_SIZEOF_ETERM
@@ -1693,6 +1744,7 @@ int enif_get_long(ErlNifEnv* env, Eterm
 #endif     
 }
 
+__attribute__((externally_visible))
 int enif_get_ulong(ErlNifEnv* env, Eterm term, unsigned long* ip)
 {
 #if SIZEOF_LONG == ERTS_SIZEOF_ETERM
@@ -1713,17 +1765,20 @@ int enif_get_ulong(ErlNifEnv* env, Eterm
 }
 
 #if HAVE_INT64 && SIZEOF_LONG != 8
+__attribute__((externally_visible))
 int enif_get_int64(ErlNifEnv* env, ERL_NIF_TERM term, ErlNifSInt64* ip)
 {
     return term_to_Sint64(term, ip);
 }
 
+__attribute__((externally_visible))
 int enif_get_uint64(ErlNifEnv* env, ERL_NIF_TERM term, ErlNifUInt64* ip)
 {
     return term_to_Uint64(term, ip);
 }
 #endif /* HAVE_INT64 && SIZEOF_LONG != 8 */
 
+__attribute__((externally_visible))
 int enif_get_double(ErlNifEnv* env, ERL_NIF_TERM term, double* dp)
 {
     FloatDef f;
@@ -1735,6 +1790,7 @@ int enif_get_double(ErlNifEnv* env, ERL_
     return 1;
 }
 
+__attribute__((externally_visible))
 int enif_get_atom_length(ErlNifEnv* env, Eterm atom, unsigned* len,
 			 ErlNifCharEncoding enc)
 {
@@ -1749,6 +1805,7 @@ int enif_get_atom_length(ErlNifEnv* env,
     return 1;
 }
 
+__attribute__((externally_visible))
 int enif_get_list_cell(ErlNifEnv* env, Eterm term, Eterm* head, Eterm* tail)
 {
     Eterm* val;
@@ -1759,6 +1816,7 @@ int enif_get_list_cell(ErlNifEnv* env, E
     return 1;
 }
 
+__attribute__((externally_visible))
 int enif_get_list_length(ErlNifEnv* env, Eterm term, unsigned* len)
 {
     Sint i;
@@ -1771,6 +1829,7 @@ int enif_get_list_length(ErlNifEnv* env,
     return 1;
 }
 
+__attribute__((externally_visible))
 ERL_NIF_TERM enif_make_int(ErlNifEnv* env, int i)
 {
 #if SIZEOF_INT == ERTS_SIZEOF_ETERM
@@ -1781,6 +1840,7 @@ ERL_NIF_TERM enif_make_int(ErlNifEnv* en
 #endif
 }
 
+__attribute__((externally_visible))
 ERL_NIF_TERM enif_make_uint(ErlNifEnv* env, unsigned i)
 {
 #if SIZEOF_INT == ERTS_SIZEOF_ETERM
@@ -1791,6 +1851,7 @@ ERL_NIF_TERM enif_make_uint(ErlNifEnv* e
 #endif
 }
 
+__attribute__((externally_visible))
 ERL_NIF_TERM enif_make_long(ErlNifEnv* env, long i)
 {
 #if SIZEOF_LONG < ERTS_SIZEOF_ETERM
@@ -1810,6 +1871,7 @@ ERL_NIF_TERM enif_make_long(ErlNifEnv* e
 #endif
 }
 
+__attribute__((externally_visible))
 ERL_NIF_TERM enif_make_ulong(ErlNifEnv* env, unsigned long i)
 {
     if (IS_USMALL(0,i)) {
@@ -1826,6 +1888,7 @@ ERL_NIF_TERM enif_make_ulong(ErlNifEnv*
 }
 
 #if HAVE_INT64 && SIZEOF_LONG != 8
+__attribute__((externally_visible))
 ERL_NIF_TERM enif_make_int64(ErlNifEnv* env, ErlNifSInt64 i)
 {
     Uint* hp;
@@ -1835,6 +1898,7 @@ ERL_NIF_TERM enif_make_int64(ErlNifEnv*
     return erts_bld_sint64(&hp, NULL, i);
 }
 
+__attribute__((externally_visible))
 ERL_NIF_TERM enif_make_uint64(ErlNifEnv* env, ErlNifUInt64 i)
 {
     Uint* hp;
@@ -1845,6 +1909,7 @@ ERL_NIF_TERM enif_make_uint64(ErlNifEnv*
 }
 #endif /* HAVE_INT64 && SIZEOF_LONG != 8 */
 
+__attribute__((externally_visible))
 ERL_NIF_TERM enif_make_double(ErlNifEnv* env, double d)
 {
     Eterm* hp;
@@ -1858,11 +1923,13 @@ ERL_NIF_TERM enif_make_double(ErlNifEnv*
     return make_float(hp);
 }
 
+__attribute__((externally_visible))
 ERL_NIF_TERM enif_make_atom(ErlNifEnv* env, const char* name)
 {
     return enif_make_atom_len(env, name, sys_strlen(name));
 }
 
+__attribute__((externally_visible))
 ERL_NIF_TERM enif_make_atom_len(ErlNifEnv* env, const char* name, size_t len)
 {
     if (len > MAX_ATOM_CHARACTERS)
@@ -1870,12 +1937,14 @@ ERL_NIF_TERM enif_make_atom_len(ErlNifEn
     return erts_atom_put((byte*)name, len, ERTS_ATOM_ENC_LATIN1, 1);
 }
 
+__attribute__((externally_visible))
 int 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);
 }
 
+__attribute__((externally_visible))
 int enif_make_existing_atom_len(ErlNifEnv* env, const char* name, size_t len,
 				ERL_NIF_TERM* atom, ErlNifCharEncoding encoding)
 {
@@ -1885,6 +1954,7 @@ int enif_make_existing_atom_len(ErlNifEn
     return erts_atom_get(name, len, atom, ERTS_ATOM_ENC_LATIN1);
 }
 
+__attribute__((externally_visible))
 ERL_NIF_TERM enif_make_tuple(ErlNifEnv* env, unsigned cnt, ...)
 {
 #ifdef ERTS_NIF_ASSERT_IN_ENV
@@ -1905,6 +1975,7 @@ ERL_NIF_TERM enif_make_tuple(ErlNifEnv*
     return ret;
 }
 
+__attribute__((externally_visible))
 ERL_NIF_TERM enif_make_tuple_from_array(ErlNifEnv* env, const ERL_NIF_TERM arr[], unsigned cnt)
 {
 #ifdef ERTS_NIF_ASSERT_IN_ENV
@@ -1922,6 +1993,7 @@ ERL_NIF_TERM enif_make_tuple_from_array(
     return ret;
 }
 
+__attribute__((externally_visible))
 ERL_NIF_TERM enif_make_list_cell(ErlNifEnv* env, Eterm car, Eterm cdr)
 {
     Eterm* hp = alloc_heap(env,2);
@@ -1934,6 +2006,7 @@ ERL_NIF_TERM enif_make_list_cell(ErlNifE
     return ret;
 }
 
+__attribute__((externally_visible))
 ERL_NIF_TERM enif_make_list(ErlNifEnv* env, unsigned cnt, ...)
 {
     if (cnt == 0) {
@@ -1963,6 +2036,7 @@ ERL_NIF_TERM enif_make_list(ErlNifEnv* e
     }
 }
 
+__attribute__((externally_visible))
 ERL_NIF_TERM enif_make_list_from_array(ErlNifEnv* env, const ERL_NIF_TERM arr[], unsigned cnt)
 {
 #ifdef ERTS_NIF_ASSERT_IN_ENV
@@ -1985,12 +2059,14 @@ ERL_NIF_TERM enif_make_list_from_array(E
     return ret;
 }
 
+__attribute__((externally_visible))
 ERL_NIF_TERM enif_make_string(ErlNifEnv* env, const char* string,
 			      ErlNifCharEncoding encoding)
 {
     return enif_make_string_len(env, string, sys_strlen(string), encoding);
 }
 
+__attribute__((externally_visible))
 ERL_NIF_TERM enif_make_string_len(ErlNifEnv* env, const char* string,
 				  size_t len, ErlNifCharEncoding encoding)
 {
@@ -1999,17 +2075,20 @@ ERL_NIF_TERM enif_make_string_len(ErlNif
     return erts_bld_string_n(&hp,NULL,string,len);
 }
 
+__attribute__((externally_visible))
 ERL_NIF_TERM enif_make_ref(ErlNifEnv* env)
 {
     Eterm* hp = alloc_heap(env, ERTS_REF_THING_SIZE);
     return erts_make_ref_in_buffer(hp);
 }
 
+__attribute__((externally_visible))
 void enif_system_info(ErlNifSysInfo *sip, size_t si_size)
 {
     driver_system_info(sip, si_size);
 }
 
+__attribute__((externally_visible))
 int enif_make_reverse_list(ErlNifEnv* env, ERL_NIF_TERM term, ERL_NIF_TERM *list)
 {
     Eterm *listptr, ret, *hp;
@@ -2029,6 +2108,7 @@ int enif_make_reverse_list(ErlNifEnv* en
     return 1;
 }
 
+__attribute__((externally_visible))
 int enif_is_current_process_alive(ErlNifEnv* env)
 {
     Process *c_p;
@@ -2048,6 +2128,7 @@ int enif_is_current_process_alive(ErlNif
     return !ERTS_PROC_IS_EXITING(c_p);
 }
 
+__attribute__((externally_visible))
 int enif_is_process_alive(ErlNifEnv* env, ErlNifPid *proc)
 {
     int scheduler;
@@ -2065,6 +2146,7 @@ int enif_is_process_alive(ErlNifEnv* env
     }
 }
 
+__attribute__((externally_visible))
 int enif_is_port_alive(ErlNifEnv *env, ErlNifPort *port)
 {
     int scheduler;
@@ -2084,6 +2166,7 @@ int enif_is_port_alive(ErlNifEnv *env, E
     }
 }
 
+__attribute__((externally_visible))
 ERL_NIF_TERM
 enif_now_time(ErlNifEnv *env)
 {
@@ -2094,6 +2177,7 @@ enif_now_time(ErlNifEnv *env)
     return TUPLE3(hp, make_small(mega), make_small(sec), make_small(micro));
 }
 
+__attribute__((externally_visible))
 ERL_NIF_TERM
 enif_cpu_time(ErlNifEnv *env)
 {
@@ -2108,6 +2192,7 @@ enif_cpu_time(ErlNifEnv *env)
 #endif
 }
 
+__attribute__((externally_visible))
 ERL_NIF_TERM
 enif_make_unique_integer(ErlNifEnv *env, ErlNifUniqueInteger properties)
 {
@@ -2130,56 +2215,93 @@ enif_make_unique_integer(ErlNifEnv *env,
     }
 }
 
+__attribute__((externally_visible))
 ErlNifMutex* enif_mutex_create(char *name) { return erl_drv_mutex_create(name); }
+__attribute__((externally_visible))
 void enif_mutex_destroy(ErlNifMutex *mtx) {  erl_drv_mutex_destroy(mtx); }
+__attribute__((externally_visible))
 int enif_mutex_trylock(ErlNifMutex *mtx) { return erl_drv_mutex_trylock(mtx); }
+__attribute__((externally_visible))
 void enif_mutex_lock(ErlNifMutex *mtx) { erl_drv_mutex_lock(mtx); }
+__attribute__((externally_visible))
 void enif_mutex_unlock(ErlNifMutex *mtx) { erl_drv_mutex_unlock(mtx); }
+__attribute__((externally_visible))
 ErlNifCond* enif_cond_create(char *name) { return erl_drv_cond_create(name); }
+__attribute__((externally_visible))
 void enif_cond_destroy(ErlNifCond *cnd) { erl_drv_cond_destroy(cnd); }
+__attribute__((externally_visible))
 void enif_cond_signal(ErlNifCond *cnd) { erl_drv_cond_signal(cnd); }
+__attribute__((externally_visible))
 void enif_cond_broadcast(ErlNifCond *cnd) { erl_drv_cond_broadcast(cnd); }
+__attribute__((externally_visible))
 void enif_cond_wait(ErlNifCond *cnd, ErlNifMutex *mtx) { erl_drv_cond_wait(cnd,mtx); }
+__attribute__((externally_visible))
 ErlNifRWLock* enif_rwlock_create(char *name) { return erl_drv_rwlock_create(name); }
+__attribute__((externally_visible))
 void enif_rwlock_destroy(ErlNifRWLock *rwlck) { erl_drv_rwlock_destroy(rwlck); }
+__attribute__((externally_visible))
 int enif_rwlock_tryrlock(ErlNifRWLock *rwlck) { return erl_drv_rwlock_tryrlock(rwlck); }
+__attribute__((externally_visible))
 void enif_rwlock_rlock(ErlNifRWLock *rwlck) { erl_drv_rwlock_rlock(rwlck); }
+__attribute__((externally_visible))
 void enif_rwlock_runlock(ErlNifRWLock *rwlck) { erl_drv_rwlock_runlock(rwlck); }
+__attribute__((externally_visible))
 int enif_rwlock_tryrwlock(ErlNifRWLock *rwlck) { return erl_drv_rwlock_tryrwlock(rwlck); }
+__attribute__((externally_visible))
 void enif_rwlock_rwlock(ErlNifRWLock *rwlck) { erl_drv_rwlock_rwlock(rwlck); }
+__attribute__((externally_visible))
 void enif_rwlock_rwunlock(ErlNifRWLock *rwlck) { erl_drv_rwlock_rwunlock(rwlck); }
+__attribute__((externally_visible))
 int enif_tsd_key_create(char *name, ErlNifTSDKey *key) { return erl_drv_tsd_key_create(name,key); }
+__attribute__((externally_visible))
 void enif_tsd_key_destroy(ErlNifTSDKey key) { erl_drv_tsd_key_destroy(key); }
+__attribute__((externally_visible))
 void enif_tsd_set(ErlNifTSDKey key, void *data) { erl_drv_tsd_set(key,data); }
+__attribute__((externally_visible))
 void* enif_tsd_get(ErlNifTSDKey key) { return erl_drv_tsd_get(key); }
+__attribute__((externally_visible))
 ErlNifThreadOpts* enif_thread_opts_create(char *name) { return (ErlNifThreadOpts*) erl_drv_thread_opts_create(name); }
+__attribute__((externally_visible))
 void enif_thread_opts_destroy(ErlNifThreadOpts *opts) { erl_drv_thread_opts_destroy((ErlDrvThreadOpts*)opts); }
+__attribute__((externally_visible))
 int 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);
 }
+__attribute__((externally_visible))
 ErlNifTid enif_thread_self(void) { return erl_drv_thread_self(); }
+__attribute__((externally_visible))
 int enif_equal_tids(ErlNifTid tid1, ErlNifTid tid2) { return erl_drv_equal_tids(tid1,tid2); }
+__attribute__((externally_visible))
 void enif_thread_exit(void *resp) { erl_drv_thread_exit(resp); }
+__attribute__((externally_visible))
 int enif_thread_join(ErlNifTid tid, void **respp) { return erl_drv_thread_join(tid,respp); }
 
+__attribute__((externally_visible))
 char* enif_mutex_name(ErlNifMutex *mtx) {return erl_drv_mutex_name(mtx); }
+__attribute__((externally_visible))
 char* enif_cond_name(ErlNifCond *cnd) { return erl_drv_cond_name(cnd); }
+__attribute__((externally_visible))
 char* enif_rwlock_name(ErlNifRWLock* rwlck) { return erl_drv_rwlock_name(rwlck); }
+__attribute__((externally_visible))
 char* enif_thread_name(ErlNifTid tid) { return erl_drv_thread_name(tid); }
 
+__attribute__((externally_visible))
 int enif_getenv(const char *key, char *value, size_t *value_size) { return erl_drv_getenv(key, value, value_size); }
 
+__attribute__((externally_visible))
 ErlNifTime enif_monotonic_time(ErlNifTimeUnit time_unit)
 {
     return (ErlNifTime) erts_napi_monotonic_time((int) time_unit);
 }
 
+__attribute__((externally_visible))
 ErlNifTime enif_time_offset(ErlNifTimeUnit time_unit)
 {
     return (ErlNifTime) erts_napi_time_offset((int) time_unit);
 }
 
+__attribute__((externally_visible))
 ErlNifTime
 enif_convert_time_unit(ErlNifTime val,
 		       ErlNifTimeUnit from,
@@ -2190,6 +2312,7 @@ enif_convert_time_unit(ErlNifTime val,
 						    (int) to);
 }
 
+__attribute__((externally_visible))
 int enif_fprintf(FILE* filep, const char* format, ...)
 { 
     int ret;
@@ -2200,11 +2323,13 @@ int enif_fprintf(FILE* filep, const char
     return ret;
 }    
 
+__attribute__((externally_visible))
 int enif_vfprintf(FILE* filep, const char *format, va_list ap)
 {
     return erts_vfprintf(filep, format, ap);
 }
 
+__attribute__((externally_visible))
 int enif_snprintf(char *buffer, size_t size, const char* format, ...) 
 { 
     int ret;
@@ -2215,6 +2340,7 @@ int enif_snprintf(char *buffer, size_t s
     return ret;
 }
 
+__attribute__((externally_visible))
 int enif_vsnprintf(char* buffer, size_t size, const char *format, va_list ap)
 {
     return erts_vsnprintf(buffer, size, format, ap);
@@ -2432,6 +2558,7 @@ ErlNifResourceType* open_resource_type(E
     return type;
 }
 
+__attribute__((externally_visible))
 ErlNifResourceType*
 enif_open_resource_type(ErlNifEnv* env,
                         const char* module_str,
@@ -2445,6 +2572,7 @@ enif_open_resource_type(ErlNifEnv* env,
     return open_resource_type(env, name_str, &init, flags, tried, 1);
 }
 
+__attribute__((externally_visible))
 ErlNifResourceType*
 enif_open_resource_type_x(ErlNifEnv* env,
                           const char* name_str,
@@ -2455,6 +2583,7 @@ enif_open_resource_type_x(ErlNifEnv* env
     return open_resource_type(env, name_str, init, flags, tried, 3);
 }
 
+__attribute__((externally_visible))
 ErlNifResourceType*
 enif_init_resource_type(ErlNifEnv* env,
                         const char* name_str,
@@ -2776,6 +2905,7 @@ void erts_fire_nif_monitor(ErtsMonitor *
     }
 }
 
+__attribute__((externally_visible))
 void* enif_alloc_resource(ErlNifResourceType* type, size_t data_sz)
 {
     size_t magic_sz = offsetof(ErtsResource,data);
@@ -2819,6 +2949,7 @@ void* enif_alloc_resource(ErlNifResource
     return resource->data;
 }
 
+__attribute__((externally_visible))
 void enif_release_resource(void* obj)
 {
     ErtsResource* resource = DATA_TO_RESOURCE(obj);
@@ -2832,6 +2963,7 @@ void enif_release_resource(void* obj)
     erts_bin_release(&bin->binary);
 }
 
+__attribute__((externally_visible))
 void enif_keep_resource(void* obj)
 {
     ErtsResource* resource = DATA_TO_RESOURCE(obj);
@@ -2852,6 +2984,7 @@ Eterm erts_bld_resource_ref(Eterm** hpp,
     return erts_mk_magic_ref(hpp, oh, &bin->binary);
 }
 
+__attribute__((externally_visible))
 ERL_NIF_TERM enif_make_resource(ErlNifEnv* env, void* obj)
 {
     ErtsResource* resource = DATA_TO_RESOURCE(obj);
@@ -2861,6 +2994,7 @@ ERL_NIF_TERM enif_make_resource(ErlNifEn
     return erts_mk_magic_ref(&hp, &MSO(env->proc), &bin->binary);
 }
 
+__attribute__((externally_visible))
 ERL_NIF_TERM enif_make_resource_binary(ErlNifEnv* env, void* obj,
 				       const void* data, size_t size)
 {
@@ -2884,6 +3018,7 @@ ERL_NIF_TERM enif_make_resource_binary(E
     return make_binary(hp);
 }
 
+__attribute__((externally_visible))
 int enif_get_resource(ErlNifEnv* env, ERL_NIF_TERM term, ErlNifResourceType* type,
 		      void** objp)
 {
@@ -2916,6 +3051,7 @@ int enif_get_resource(ErlNifEnv* env, ER
     return 1;
 }
 
+__attribute__((externally_visible))
 size_t enif_sizeof_resource(void* obj)
 {
     ErtsResource* resource = DATA_TO_RESOURCE(obj);
@@ -2928,6 +3064,7 @@ size_t enif_sizeof_resource(void* obj)
     }
 }
 
+__attribute__((externally_visible))
 int enif_dynamic_resource_call(ErlNifEnv* caller_env,
                                ERL_NIF_TERM rt_module_atom,
                                ERL_NIF_TERM rt_name_atom,
@@ -2957,6 +3094,7 @@ int enif_dynamic_resource_call(ErlNifEnv
 }
 
 
+__attribute__((externally_visible))
 void* enif_dlopen(const char* lib,
 		  void (*err_handler)(void*,const char*), void* err_arg)
 {
@@ -2978,6 +3116,7 @@ void* enif_dlopen(const char* lib,
     return handle;
 }
 
+__attribute__((externally_visible))
 void* enif_dlsym(void* handle, const char* symbol,
 		 void (*err_handler)(void*,const char*), void* err_arg)
 {
@@ -2993,6 +3132,7 @@ void* enif_dlsym(void* handle, const cha
     return ret;
 }
 
+__attribute__((externally_visible))
 int enif_consume_timeslice(ErlNifEnv* env, int percent)
 {
     Process *proc;
@@ -3191,6 +3331,7 @@ execute_nif(ErlNifEnv* env, int argc, co
     return result;
 }
 
+__attribute__((externally_visible))
 ERL_NIF_TERM
 enif_schedule_nif(ErlNifEnv* env, const char* fun_name, int flags,
 		  ERL_NIF_TERM (*fp)(ErlNifEnv*, int, const ERL_NIF_TERM[]),
@@ -3237,6 +3378,7 @@ enif_schedule_nif(ErlNifEnv* env, const
     return result;
 }
 
+__attribute__((externally_visible))
 int
 enif_thread_type(void)
 {
@@ -3260,11 +3402,13 @@ enif_thread_type(void)
 
 /* Maps */
 
+__attribute__((externally_visible))
 int enif_is_map(ErlNifEnv* env, ERL_NIF_TERM term)
 {
     return is_map(term);
 }
 
+__attribute__((externally_visible))
 int enif_get_map_size(ErlNifEnv* env, ERL_NIF_TERM term, size_t *size)
 {
     if (is_flatmap(term)) {
@@ -3280,6 +3424,7 @@ int enif_get_map_size(ErlNifEnv* env, ER
     return 0;
 }
 
+__attribute__((externally_visible))
 ERL_NIF_TERM enif_make_new_map(ErlNifEnv* env)
 {
     Eterm* hp = alloc_heap(env,MAP_HEADER_FLATMAP_SZ+1);
@@ -3296,6 +3441,7 @@ ERL_NIF_TERM enif_make_new_map(ErlNifEnv
     return make_flatmap(mp);
 }
 
+__attribute__((externally_visible))
 int enif_make_map_from_arrays(ErlNifEnv *env,
                               ERL_NIF_TERM keys[],
                               ERL_NIF_TERM values[],
@@ -3334,6 +3480,7 @@ int enif_make_map_from_arrays(ErlNifEnv
     return succeeded;
 }
 
+__attribute__((externally_visible))
 int enif_make_map_put(ErlNifEnv* env,
 	              Eterm map_in,
 		      Eterm key,
@@ -3353,6 +3500,7 @@ int enif_make_map_put(ErlNifEnv* env,
     return 1;
 }
 
+__attribute__((externally_visible))
 int enif_get_map_value(ErlNifEnv* env,
 	               Eterm map,
 		       Eterm key,
@@ -3370,6 +3518,7 @@ int enif_get_map_value(ErlNifEnv* env,
     return 0;
 }
 
+__attribute__((externally_visible))
 int enif_make_map_update(ErlNifEnv* env,
 	                 Eterm map_in,
 			 Eterm key,
@@ -3391,6 +3540,7 @@ int enif_make_map_update(ErlNifEnv* env,
     return res;
 }
 
+__attribute__((externally_visible))
 int enif_make_map_remove(ErlNifEnv* env,
 	                 Eterm map_in,
 			 Eterm key,
@@ -3405,6 +3555,7 @@ int enif_make_map_remove(ErlNifEnv* env,
     return 1;
 }
 
+__attribute__((externally_visible))
 int enif_map_iterator_create(ErlNifEnv *env,
 	                     Eterm map,
 			     ErlNifMapIterator *iter,
@@ -3463,6 +3614,7 @@ error:
     return 0;
 }
 
+__attribute__((externally_visible))
 void enif_map_iterator_destroy(ErlNifEnv *env, ErlNifMapIterator *iter)
 {
     if (is_hashmap(iter->map)) {
@@ -3477,6 +3629,7 @@ void enif_map_iterator_destroy(ErlNifEnv
 #endif
 }
 
+__attribute__((externally_visible))
 int enif_map_iterator_is_tail(ErlNifEnv *env, ErlNifMapIterator *iter)
 {
     ASSERT(iter);
@@ -3491,6 +3644,7 @@ int enif_map_iterator_is_tail(ErlNifEnv
     }
 }
 
+__attribute__((externally_visible))
 int enif_map_iterator_is_head(ErlNifEnv *env, ErlNifMapIterator *iter)
 {
     ASSERT(iter);
@@ -3506,6 +3660,7 @@ int enif_map_iterator_is_head(ErlNifEnv
 }
 
 
+__attribute__((externally_visible))
 int enif_map_iterator_next(ErlNifEnv *env, ErlNifMapIterator *iter)
 {
     ASSERT(iter);
@@ -3532,6 +3687,7 @@ int enif_map_iterator_next(ErlNifEnv *en
     }
 }
 
+__attribute__((externally_visible))
 int enif_map_iterator_prev(ErlNifEnv *env, ErlNifMapIterator *iter)
 {
     ASSERT(iter);
@@ -3558,6 +3714,7 @@ int enif_map_iterator_prev(ErlNifEnv *en
     }
 }
 
+__attribute__((externally_visible))
 int enif_map_iterator_get_pair(ErlNifEnv *env,
 			       ErlNifMapIterator *iter,
 			       Eterm *key,
@@ -3586,6 +3743,7 @@ int enif_map_iterator_get_pair(ErlNifEnv
     return 0;
 }
 
+__attribute__((externally_visible))
 int enif_monitor_process(ErlNifEnv* env, void* obj, const ErlNifPid* target_pid,
                          ErlNifMonitor* monitor)
 {
@@ -3644,12 +3802,14 @@ int enif_monitor_process(ErlNifEnv* env,
     return 0;
 }
 
+__attribute__((externally_visible))
 ERL_NIF_TERM enif_make_monitor_term(ErlNifEnv* env, const ErlNifMonitor* monitor)
 {
     Eterm* hp = alloc_heap(env, ERTS_REF_THING_SIZE);
     return erts_driver_monitor_to_ref(hp, monitor);
 }
 
+__attribute__((externally_visible))
 int enif_demonitor_process(ErlNifEnv* env, void* obj, const ErlNifMonitor* monitor)
 {
     ErtsResource* rsrc = DATA_TO_RESOURCE(obj);
@@ -3685,6 +3845,7 @@ int enif_demonitor_process(ErlNifEnv* en
     return 0;
 }
 
+__attribute__((externally_visible))
 int enif_compare_monitors(const ErlNifMonitor *monitor1,
                           const ErlNifMonitor *monitor2)
 {
@@ -3692,6 +3853,7 @@ int enif_compare_monitors(const ErlNifMo
                       ERTS_REF_THING_SIZE*sizeof(Eterm));
 }
 
+__attribute__((externally_visible))
 ErlNifIOQueue *enif_ioq_create(ErlNifIOQueueOpts opts)
 {
     ErlNifIOQueue *q;
@@ -3706,6 +3868,7 @@ ErlNifIOQueue *enif_ioq_create(ErlNifIOQ
     return q;
 }
 
+__attribute__((externally_visible))
 void enif_ioq_destroy(ErlNifIOQueue *q)
 {
     erts_ioq_clear(q);
@@ -3716,6 +3879,7 @@ void enif_ioq_destroy(ErlNifIOQueue *q)
  * such to perform a proper free. */
 #define ERL_NIF_IOVEC_FLAGS_PREALLOC (1 << 0)
 
+__attribute__((externally_visible))
 void enif_free_iovec(ErlNifIOVec *iov)
 {
     int i;
@@ -4005,6 +4169,7 @@ static int create_iovec_from_slice(ErlNi
     return 1;
 }
 
+__attribute__((externally_visible))
 int enif_inspect_iovec(ErlNifEnv *env, size_t max_elements,
                        ERL_NIF_TERM list, ERL_NIF_TERM *tail,
                        ErlNifIOVec **iov) {
@@ -4022,6 +4187,7 @@ int enif_inspect_iovec(ErlNifEnv *env, s
 }
 
 /* */
+__attribute__((externally_visible))
 int enif_ioq_enqv(ErlNifIOQueue *q, ErlNifIOVec *iov, size_t skip)
 {
     if(skip <= iov->size) {
@@ -4031,6 +4197,7 @@ int enif_ioq_enqv(ErlNifIOQueue *q, ErlN
     return 0;
 }
 
+__attribute__((externally_visible))
 int enif_ioq_enq_binary(ErlNifIOQueue *q, ErlNifBinary *bin, size_t skip)
 {
     ErlNifIOVec vec = {1, bin->size, NULL, NULL, ERL_NIF_IOVEC_FLAGS_PREALLOC };
@@ -4047,11 +4214,13 @@ int enif_ioq_enq_binary(ErlNifIOQueue *q
     return res;
 }
 
+__attribute__((externally_visible))
 size_t enif_ioq_size(ErlNifIOQueue *q)
 {
     return erts_ioq_size(q);
 }
 
+__attribute__((externally_visible))
 int enif_ioq_deq(ErlNifIOQueue *q, size_t elems, size_t *size)
 {
     if (erts_ioq_deq(q, elems) == -1)
@@ -4061,6 +4230,7 @@ int enif_ioq_deq(ErlNifIOQueue *q, size_
     return 1;
 }
 
+__attribute__((externally_visible))
 int enif_ioq_peek_head(ErlNifEnv *env, ErlNifIOQueue *q, size_t *size, ERL_NIF_TERM *bin_term) {
     SysIOVec *iov_entry;
     Binary *ref_bin;
@@ -4110,6 +4280,7 @@ int enif_ioq_peek_head(ErlNifEnv *env, E
     return 1;
 }
 
+__attribute__((externally_visible))
 SysIOVec *enif_ioq_peek(ErlNifIOQueue *q, int *iovlen)
 {
     return erts_ioq_peekq(q, iovlen);
diff -Ndurp otp_src_24.3.4.13/erts/emulator/beam/erl_port_task.c otp_src_24.3.4.13-erts-symbols/erts/emulator/beam/erl_port_task.c
--- otp_src_24.3.4.13/erts/emulator/beam/erl_port_task.c	2023-06-28 13:00:52.000000000 +0300
+++ otp_src_24.3.4.13-erts-symbols/erts/emulator/beam/erl_port_task.c	2023-08-29 22:27:20.752446791 +0300
@@ -761,6 +761,7 @@ enqueue_proc2port_data(Port *pp,
  * as a write-read request.
  */
 
+__attribute__((externally_visible))
 void
 erl_drv_busy_msgq_limits(ErlDrvPort dport, ErlDrvSizeT *lowp, ErlDrvSizeT *highp)
 {
@@ -1269,6 +1270,7 @@ select_task_for_exec(Port *pp,
  * Cut time slice
  */
 
+__attribute__((externally_visible))
 int
 erl_drv_consume_timeslice(ErlDrvPort dprt, int percent)
 {
diff -Ndurp otp_src_24.3.4.13/erts/emulator/beam/erl_posix_str.c otp_src_24.3.4.13-erts-symbols/erts/emulator/beam/erl_posix_str.c
--- otp_src_24.3.4.13/erts/emulator/beam/erl_posix_str.c	2023-06-28 13:00:52.000000000 +0300
+++ otp_src_24.3.4.13-erts-symbols/erts/emulator/beam/erl_posix_str.c	2023-08-29 22:27:20.752446791 +0300
@@ -46,6 +46,7 @@
  *----------------------------------------------------------------------
  */
 
+__attribute__((externally_visible))
 char *
 erl_errno_id(error)
     int error;			/* Posix error number (as from errno). */
diff -Ndurp otp_src_24.3.4.13/erts/emulator/beam/io.c otp_src_24.3.4.13-erts-symbols/erts/emulator/beam/io.c
--- otp_src_24.3.4.13/erts/emulator/beam/io.c	2023-06-28 13:00:52.000000000 +0300
+++ otp_src_24.3.4.13-erts-symbols/erts/emulator/beam/io.c	2023-08-29 22:27:20.756446709 +0300
@@ -72,6 +72,7 @@ static erts_tsd_key_t driver_list_last_e
 
 ErtsPTab erts_port erts_align_attribute(ERTS_CACHE_LINE_SIZE); /* The port table */
 
+__attribute__((externally_visible))
 const ErlDrvTermData driver_term_nil = (ErlDrvTermData)NIL;
 
 const Port erts_invalid_port = {{ERTS_INVALID_PORT}};
@@ -187,6 +188,7 @@ typedef struct line_buf_context {
     dtrace_proc_str((PID), process_str);                     \
     dtrace_port_str((PORT), port_str);
 
+__attribute__((externally_visible))
 void
 dtrace_drvport_str(ErlDrvPort drvport, char *port_buf)
 {
@@ -753,6 +755,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.
  */
+__attribute__((externally_visible))
 ErlDrvPort
 driver_create_port(ErlDrvPort creator_port_ix, /* Creating port */
 		   ErlDrvTermData pid,    /* Owner/Caller */
@@ -5150,6 +5153,7 @@ print_port_info(Port *p, fmtfn_t to, voi
     }
 }
 
+__attribute__((externally_visible))
 void
 set_busy_port(ErlDrvPort dprt, int on)
 {
@@ -5260,6 +5264,7 @@ erts_port_resume_procs(Port *prt)
     }
 }
 
+__attribute__((externally_visible))
 void set_port_control_flags(ErlDrvPort port_num, int flags)
 {
     Port *prt = erts_drvport2port(port_num);
@@ -5267,6 +5272,7 @@ void set_port_control_flags(ErlDrvPort p
 	prt->control_flags = flags;
 }
 
+__attribute__((externally_visible))
 int get_port_flags(ErlDrvPort ix)
 {
     int flags;
@@ -5467,6 +5473,7 @@ erts_free_port_names(ErtsPortNames *pnp)
     erts_free(ERTS_ALC_T_PORT_NAMES, pnp);
 }
 
+__attribute__((externally_visible))
 ErlDrvTermData driver_mk_term_nil(void)
 {
     return driver_term_nil;
@@ -6192,6 +6199,7 @@ done:
     return res;
 }
 
+__attribute__((externally_visible))
 int erl_drv_output_term(ErlDrvTermData port_id, ErlDrvTermData* data, int len)
 {
     /* May be called from arbitrary thread */
@@ -6208,6 +6216,7 @@ int erl_drv_output_term(ErlDrvTermData p
  * removal in OTP-R17. It is replaced by erl_drv_output_term()
  * above.
  */
+__attribute__((externally_visible))
 int 
 driver_output_term(ErlDrvPort drvport, ErlDrvTermData* data, int len)
 {
@@ -6227,6 +6236,7 @@ driver_output_term(ErlDrvPort drvport, E
     return driver_deliver_term(prt, ERTS_PORT_GET_CONNECTED(prt), data, len);
 }
 
+__attribute__((externally_visible))
 int erl_drv_send_term(ErlDrvTermData port_id,
 		      ErlDrvTermData to,
 		      ErlDrvTermData* data,
@@ -6244,6 +6254,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.
  */
+__attribute__((externally_visible))
 int
 driver_send_term(ErlDrvPort drvport,
 		 ErlDrvTermData to,
@@ -6277,6 +6288,7 @@ driver_send_term(ErlDrvPort drvport,
  * and data is len length of bin starting from offset offs.
  */
 
+__attribute__((externally_visible))
 int driver_output_binary(ErlDrvPort ix, char* hbuf, ErlDrvSizeT hlen,
 			 ErlDrvBinary* bin, ErlDrvSizeT offs, ErlDrvSizeT len)
 {
@@ -6321,6 +6333,7 @@ int driver_output_binary(ErlDrvPort ix,
 ** Example: if hlen = 3 then the port owner will receive the data
 ** [H1,H2,H3 | T]
 */
+__attribute__((externally_visible))
 int driver_output2(ErlDrvPort ix, char* hbuf, ErlDrvSizeT hlen,
 		   char* buf, ErlDrvSizeT len)
 {
@@ -6372,12 +6385,14 @@ int driver_output2(ErlDrvPort ix, char*
 
 /* Interface functions available to driver writers */
 
+__attribute__((externally_visible))
 int driver_output(ErlDrvPort ix, char* buf, ErlDrvSizeT len)
 {
     ERTS_CHK_NO_PROC_LOCKS;
     return driver_output2(ix, NULL, 0, buf, len);
 }
 
+__attribute__((externally_visible))
 int driver_outputv(ErlDrvPort ix, char* hbuf, ErlDrvSizeT hlen,
 		   ErlIOVec* vec, ErlDrvSizeT skip)
 {
@@ -6440,6 +6455,7 @@ int driver_outputv(ErlDrvPort ix, char*
 ** input is a vector a buffer and a max length
 ** return bytes copied
 */
+__attribute__((externally_visible))
 ErlDrvSizeT driver_vec_to_buf(ErlIOVec *vec, char *buf, ErlDrvSizeT len)
 {
     SysIOVec* iov = vec->iov;
@@ -6466,6 +6482,7 @@ ErlDrvSizeT driver_vec_to_buf(ErlIOVec *
  * reference count on driver binaries...
  */
 
+__attribute__((externally_visible))
 ErlDrvSInt
 driver_binary_get_refc(ErlDrvBinary *dbp)
 {
@@ -6473,6 +6490,7 @@ driver_binary_get_refc(ErlDrvBinary *dbp
     return (ErlDrvSInt) erts_refc_read(&bp->intern.refc, 1);
 }
 
+__attribute__((externally_visible))
 ErlDrvSInt
 driver_binary_inc_refc(ErlDrvBinary *dbp)
 {
@@ -6480,6 +6498,7 @@ driver_binary_inc_refc(ErlDrvBinary *dbp
     return (ErlDrvSInt) erts_refc_inctest(&bp->intern.refc, 2);
 }
 
+__attribute__((externally_visible))
 ErlDrvSInt
 driver_binary_dec_refc(ErlDrvBinary *dbp)
 {
@@ -6492,6 +6511,7 @@ driver_binary_dec_refc(ErlDrvBinary *dbp
 ** Allocation/Deallocation of binary objects 
 */
 
+__attribute__((externally_visible))
 ErlDrvBinary*
 driver_alloc_binary(ErlDrvSizeT size)
 {
@@ -6505,6 +6525,7 @@ driver_alloc_binary(ErlDrvSizeT size)
 
 /* Reallocate space held by binary */
 
+__attribute__((externally_visible))
 ErlDrvBinary* driver_realloc_binary(ErlDrvBinary* bin, ErlDrvSizeT size)
 {
     Binary* oldbin;
@@ -6522,6 +6543,7 @@ ErlDrvBinary* driver_realloc_binary(ErlD
 }
 
 
+__attribute__((externally_visible))
 void driver_free_binary(ErlDrvBinary* dbin)
 {
     Binary *bin;
@@ -6537,16 +6559,19 @@ void driver_free_binary(ErlDrvBinary* db
  * Allocation/deallocation of memory for drivers 
  */
 
+__attribute__((externally_visible))
 void *driver_alloc(ErlDrvSizeT size)
 {
     return erts_alloc_fnf(ERTS_ALC_T_DRV, (Uint) size);
 }
 
+__attribute__((externally_visible))
 void *driver_realloc(void *ptr, ErlDrvSizeT size)
 {
     return erts_realloc_fnf(ERTS_ALC_T_DRV, ptr, (Uint) size);
 }
 
+__attribute__((externally_visible))
 void driver_free(void *ptr)
 {
     erts_free(ERTS_ALC_T_DRV, ptr);
@@ -6643,6 +6668,7 @@ static void driver_monitor_unlock_pdl(Po
  * exported driver_pdl_* functions ...
  */
 
+__attribute__((externally_visible))
 ErlDrvPDL
 driver_pdl_create(ErlDrvPort dp)
 {
@@ -6663,6 +6689,7 @@ driver_pdl_create(ErlDrvPort dp)
     return pdl;
 }
 
+__attribute__((externally_visible))
 void
 driver_pdl_lock(ErlDrvPDL pdl)
 {
@@ -6673,6 +6700,7 @@ driver_pdl_lock(ErlDrvPDL pdl)
     erts_mtx_lock(&pdl->mtx);
 }
 
+__attribute__((externally_visible))
 void
 driver_pdl_unlock(ErlDrvPDL pdl)
 {
@@ -6686,12 +6714,14 @@ driver_pdl_unlock(ErlDrvPDL pdl)
 	pdl_destroy(pdl);
 }
 
+__attribute__((externally_visible))
 ErlDrvSInt
 driver_pdl_get_refc(ErlDrvPDL pdl)
 {
     return pdl_read_refc(pdl);
 }
 
+__attribute__((externally_visible))
 ErlDrvSInt
 driver_pdl_inc_refc(ErlDrvPDL pdl)
 {
@@ -6703,6 +6733,7 @@ driver_pdl_inc_refc(ErlDrvPDL pdl)
     return refc;
 }
 
+__attribute__((externally_visible))
 ErlDrvSInt
 driver_pdl_dec_refc(ErlDrvPDL pdl)
 {
@@ -6717,6 +6748,7 @@ driver_pdl_dec_refc(ErlDrvPDL pdl)
 }
 
 /* Put elements from vec at q tail */
+__attribute__((externally_visible))
 int driver_enqv(ErlDrvPort ix, ErlIOVec* vec, ErlDrvSizeT skip)
 {
     ASSERT(vec->size >= skip);
@@ -6724,6 +6756,7 @@ int driver_enqv(ErlDrvPort ix, ErlIOVec*
 }
 
 /* Put elements from vec at q head */
+__attribute__((externally_visible))
 int driver_pushqv(ErlDrvPort ix, ErlIOVec* vec, ErlDrvSizeT skip)
 {
     ASSERT(vec->size >= skip);
@@ -6734,6 +6767,7 @@ int driver_pushqv(ErlDrvPort ix, ErlIOVe
 ** Remove size bytes from queue head
 ** Return number of bytes that remain in queue
 */
+__attribute__((externally_visible))
 ErlDrvSizeT driver_deq(ErlDrvPort ix, ErlDrvSizeT size)
 {
     ErlPortIOQueue *q = drvport2ioq(ix);
@@ -6743,17 +6777,20 @@ ErlDrvSizeT driver_deq(ErlDrvPort ix, Er
 }
 
 
+__attribute__((externally_visible))
 ErlDrvSizeT driver_peekqv(ErlDrvPort ix, ErlIOVec *ev)
 {
     return erts_ioq_peekqv(drvport2ioq(ix), (ErtsIOVec*)ev);
 }
 
+__attribute__((externally_visible))
 SysIOVec* driver_peekq(ErlDrvPort ix, int* vlenp)  /* length of io-vector */
 {
     return erts_ioq_peekq(drvport2ioq(ix), vlenp);
 }
 
 
+__attribute__((externally_visible))
 ErlDrvSizeT driver_sizeq(ErlDrvPort ix)
 {
     ErlPortIOQueue *q = drvport2ioq(ix);
@@ -6767,6 +6804,7 @@ ErlDrvSizeT driver_sizeq(ErlDrvPort ix)
 /* Utils */
 
 /* Enqueue a binary */
+__attribute__((externally_visible))
 int driver_enq_bin(ErlDrvPort ix, ErlDrvBinary* bin,
 		   ErlDrvSizeT offs, ErlDrvSizeT len)
 {
@@ -6785,6 +6823,7 @@ int driver_enq_bin(ErlDrvPort ix, ErlDrv
     return driver_enqv(ix, &ev, 0);
 }
 
+__attribute__((externally_visible))
 int driver_enq(ErlDrvPort ix, char* buffer, ErlDrvSizeT len)
 {
     int code;
@@ -6801,6 +6840,7 @@ int driver_enq(ErlDrvPort ix, char* buff
     return code;
 }
 
+__attribute__((externally_visible))
 int driver_pushq_bin(ErlDrvPort ix, ErlDrvBinary* bin,
 		     ErlDrvSizeT offs, ErlDrvSizeT len)
 {
@@ -6819,6 +6859,7 @@ int driver_pushq_bin(ErlDrvPort ix, ErlD
     return driver_pushqv(ix, &ev, 0);
 }
 
+__attribute__((externally_visible))
 int driver_pushq(ErlDrvPort ix, char* buffer, ErlDrvSizeT len)
 {
     int code;
@@ -6836,6 +6877,7 @@ int driver_pushq(ErlDrvPort ix, char* bu
     return code;
 }
 
+__attribute__((externally_visible))
 int driver_set_timer(ErlDrvPort ix, unsigned long t)
 {
     Port* prt = erts_drvport2port(ix);
@@ -6852,6 +6894,7 @@ int driver_set_timer(ErlDrvPort ix, unsi
     return 0;
 }
 
+__attribute__((externally_visible))
 int driver_cancel_timer(ErlDrvPort ix)
 {
     Port* prt = erts_drvport2port(ix);
@@ -6862,6 +6905,7 @@ int driver_cancel_timer(ErlDrvPort ix)
     return 0;
 }
 
+__attribute__((externally_visible))
 int
 driver_read_timer(ErlDrvPort ix, unsigned long* t)
 {
@@ -6883,6 +6927,7 @@ driver_read_timer(ErlDrvPort ix, unsigne
     return 0;
 }
 
+__attribute__((externally_visible))
 int 
 driver_get_now(ErlDrvNowData *now_data)
 {
@@ -6969,6 +7014,7 @@ static int do_driver_monitor_process(Por
 /*
  * This can be called from a non scheduler thread iff a port_data_lock exists
  */
+__attribute__((externally_visible))
 int driver_monitor_process(ErlDrvPort drvport,
 			   ErlDrvTermData process,
 			   ErlDrvMonitor *monitor)
@@ -7008,6 +7054,7 @@ static int do_driver_demonitor_process(P
     return 0;
 }
 
+__attribute__((externally_visible))
 int driver_demonitor_process(ErlDrvPort drvport,
 			     const ErlDrvMonitor *monitor)
 {
@@ -7046,6 +7093,7 @@ static ErlDrvTermData do_driver_get_moni
 }
 
 
+__attribute__((externally_visible))
 ErlDrvTermData driver_get_monitored_process(ErlDrvPort drvport,
 					    const ErlDrvMonitor *monitor)
 {
@@ -7067,6 +7115,7 @@ ErlDrvTermData driver_get_monitored_proc
     return ret;
 }
 
+__attribute__((externally_visible))
 int driver_compare_monitors(const ErlDrvMonitor *monitor1,
 			    const ErlDrvMonitor *monitor2)
 {
@@ -7159,6 +7208,7 @@ driver_failure_term(ErlDrvPort ix, Eterm
 ** Do a (soft) exit. unlink the connected process before doing
 ** driver posix error or (normal)
 */
+__attribute__((externally_visible))
 int driver_exit(ErlDrvPort ix, int err)
 {
     Port* prt = erts_drvport2port(ix);
@@ -7183,11 +7233,13 @@ int driver_exit(ErlDrvPort ix, int err)
 }
 
 
+__attribute__((externally_visible))
 int driver_failure(ErlDrvPort ix, int code)
 {
     return driver_failure_term(ix, make_small(code), code == 0);
 }
 
+__attribute__((externally_visible))
 int driver_failure_atom(ErlDrvPort ix, char* string)
 {
     return driver_failure_term(ix,
@@ -7198,11 +7250,13 @@ int driver_failure_atom(ErlDrvPort ix, c
 			       0);
 }
 
+__attribute__((externally_visible))
 int driver_failure_posix(ErlDrvPort ix, int err)
 {
     return driver_failure_atom(ix, erl_errno_id(err));
 }
 
+__attribute__((externally_visible))
 int driver_failure_eof(ErlDrvPort ix)
 {
     return driver_failure_term(ix, NIL, 1);
@@ -7210,6 +7264,7 @@ int driver_failure_eof(ErlDrvPort ix)
 
 
 
+__attribute__((externally_visible))
 ErlDrvTermData driver_mk_atom(char* string)
 {
     Eterm am = erts_atom_put((byte *) string,
@@ -7220,6 +7275,7 @@ ErlDrvTermData driver_mk_atom(char* stri
     return (ErlDrvTermData) am;
 }
 
+__attribute__((externally_visible))
 ErlDrvTermData driver_mk_port(ErlDrvPort ix)
 {
     Port* prt = erts_drvport2port(ix);
@@ -7229,6 +7285,7 @@ ErlDrvTermData driver_mk_port(ErlDrvPort
     return (ErlDrvTermData) prt->common.id;
 }
 
+__attribute__((externally_visible))
 ErlDrvTermData driver_connected(ErlDrvPort ix)
 {
     Port* prt = erts_drvport2port(ix);
@@ -7239,6 +7296,7 @@ ErlDrvTermData driver_connected(ErlDrvPo
     return ERTS_PORT_GET_CONNECTED(prt);
 }
 
+__attribute__((externally_visible))
 ErlDrvTermData driver_caller(ErlDrvPort ix)
 {
     Port* prt = erts_drvport2port(ix);
@@ -7249,6 +7307,7 @@ ErlDrvTermData driver_caller(ErlDrvPort
     return prt->caller;
 }
 
+__attribute__((externally_visible))
 int driver_lock_driver(ErlDrvPort ix)
 {
     Port* prt = erts_drvport2port(ix);
@@ -7304,6 +7363,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...
 */
+__attribute__((externally_visible))
 void *driver_dl_open(char * path)
 {
     void *ptr;
@@ -7324,6 +7384,7 @@ void *driver_dl_open(char * path)
     }
 }
 
+__attribute__((externally_visible))
 void *driver_dl_sym(void * handle, char *func_name)
 {
     void *ptr;
@@ -7344,6 +7405,7 @@ void *driver_dl_sym(void * handle, char
     }
 }
     
+__attribute__((externally_visible))
 int driver_dl_close(void *handle)
 {
     int res;
@@ -7353,6 +7415,7 @@ int driver_dl_close(void *handle)
     return res;
 }
 
+__attribute__((externally_visible))
 char *driver_dl_error(void) 
 {
     char *res;
@@ -7368,6 +7431,7 @@ char *driver_dl_error(void)
   (offsetof(ErlDrvSysInfo, LAST_FIELD) \
    + sizeof(((ErlDrvSysInfo *) 0)->LAST_FIELD))
 
+__attribute__((externally_visible))
 void
 driver_system_info(ErlDrvSysInfo *sip, size_t si_size)
 {
@@ -7557,6 +7621,7 @@ erts_destroy_driver(erts_driver_t *drv)
  * Exposed in the driver interface, and therefore possibly locking directly.
  */
 
+__attribute__((externally_visible))
 void add_driver_entry(ErlDrvEntry *drv){
     void *rec_lock;
     rec_lock = erts_tsd_get(driver_list_lock_status_key);
@@ -7615,6 +7680,7 @@ int erts_add_driver_entry(ErlDrvEntry *d
 }
 
 /* Not allowed for dynamic drivers */
+__attribute__((externally_visible))
 int remove_driver_entry(ErlDrvEntry *drv)
 {
     erts_driver_t *dp;
@@ -7657,11 +7723,13 @@ 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
  */
+__attribute__((externally_visible))
 int null_func(void)
 {
     return 0;
 }
 
+__attribute__((externally_visible))
 int
 erl_drv_putenv(const char *key, char *value)
 {
@@ -7675,6 +7743,7 @@ erl_drv_putenv(const char *key, char *va
     }
 }
 
+__attribute__((externally_visible))
 int
 erl_drv_getenv(const char *key, char *value, size_t *value_size)
 {
diff -Ndurp otp_src_24.3.4.13/erts/emulator/sys/common/erl_check_io.c otp_src_24.3.4.13-erts-symbols/erts/emulator/sys/common/erl_check_io.c
--- otp_src_24.3.4.13/erts/emulator/sys/common/erl_check_io.c	2023-06-28 13:00:52.000000000 +0300
+++ otp_src_24.3.4.13-erts-symbols/erts/emulator/sys/common/erl_check_io.c	2023-08-29 22:27:20.756446709 +0300
@@ -792,6 +792,7 @@ check_fd_cleanup(ErtsDrvEventState *stat
 # define MUST_DEFER(MAY_SLEEP) (MAY_SLEEP)
 #endif
 
+__attribute__((externally_visible))
 int
 driver_select(ErlDrvPort ix, ErlDrvEvent e, int mode, int on)
 {
diff -Ndurp otp_src_24.3.4.13/erts/lib_src/common/erl_memory_trace_parser.c otp_src_24.3.4.13-erts-symbols/erts/lib_src/common/erl_memory_trace_parser.c
--- otp_src_24.3.4.13/erts/lib_src/common/erl_memory_trace_parser.c	2023-06-28 13:00:52.000000000 +0300
+++ otp_src_24.3.4.13-erts-symbols/erts/lib_src/common/erl_memory_trace_parser.c	2023-08-29 22:34:56.294927026 +0300
@@ -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)

Places

File otp_src_24.3.4.13-erts-symbols.patch of Package erlang (Revision 9440da27151d64996ef430f593e940c0)

Places