static Eterm pd_hash_get_keys(Process *p, Eterm value)
{
Eterm *hp;
Eterm res = NIL;
ProcDict *pd = p->dictionary;
unsigned int i, num;
Eterm tmp, tmp2;
if (pd == NULL) {
return res;
}
num = HASH_RANGE(pd);
for (i = 0; i < num; ++i) {
tmp = ARRAY_GET(pd, i);
if (is_boxed(tmp)) {
ASSERT(is_tuple(tmp));
if (EQ(tuple_val(tmp)[2], value)) {
hp = HAlloc(p, 2);
res = CONS(hp, tuple_val(tmp)[1], res);
}
} else if (is_list(tmp)) {
while (tmp != NIL) {
tmp2 = TCAR(tmp);
if (EQ(tuple_val(tmp2)[2], value)) {
hp = HAlloc(p, 2);
res = CONS(hp, tuple_val(tmp2)[1], res);
}
tmp = TCDR(tmp);
}
}
}
return res;
}
static void pd_check(ProcDict *pd)
{
unsigned int i;
Uint num;
if (pd == NULL)
return;
ASSERT(pd->size >= pd->used);
ASSERT(HASH_RANGE(pd) <= MAX_HASH);
for (i = 0, num = 0; i < pd->used; ++i) {
Eterm t = pd->data[i];
if (is_nil(t)) {
continue;
} else if (is_tuple(t)) {
++num;
ASSERT(arityval(*tuple_val(t)) == 2);
continue;
} else if (is_list(t)) {
while (t != NIL) {
++num;
ASSERT(is_tuple(TCAR(t)));
ASSERT(arityval(*(tuple_val(TCAR(t)))) == 2);
t = TCDR(t);
}
continue;
} else {
erl_exit(1,
"Found tag 0x%08x in process dictionary at position %d",
(unsigned long) t, (int) i);
}
}
ASSERT(num == pd->numElements);
ASSERT(pd->splitPosition <= pd->homeSize);
}
Eterm erts_pd_hash_get(Process *p, Eterm id)
{
unsigned int hval;
Eterm tmp;
ProcDict *pd = p->dictionary;
if (pd == NULL)
return am_undefined;
hval = pd_hash_value(pd, id);
tmp = ARRAY_GET(pd, hval);
if (is_boxed(tmp)) { /* Tuple */
ASSERT(is_tuple(tmp));
if (EQ(tuple_val(tmp)[1], id)) {
return tuple_val(tmp)[2];
}
} else if (is_list(tmp)) {
for (; tmp != NIL && !EQ(tuple_val(TCAR(tmp))[1], id); tmp = TCDR(tmp)) {
;
}
if (tmp != NIL) {
return tuple_val(TCAR(tmp))[2];
}
} else if (is_not_nil(tmp)) {
#ifdef DEBUG
erts_fprintf(stderr,
"Process dictionary for process %T is broken, trying to "
"display term found in line %d:\n"
"%T\n", p->common.id, __LINE__, tmp);
#endif
erl_exit(1, "Damaged process dictionary found during get/1.");
}
return am_undefined;
}
/*
* BIF implementations
*/
static void pd_hash_erase(Process *p, Eterm id, Eterm *ret)
{
unsigned int hval;
Eterm old;
Eterm tmp;
unsigned int range;
*ret = am_undefined;
if (p->dictionary == NULL) {
return;
}
hval = pd_hash_value(p->dictionary, id);
old = ARRAY_GET(p->dictionary, hval);
if (is_boxed(old)) { /* Tuple */
ASSERT(is_tuple(old));
if (EQ(tuple_val(old)[1], id)) {
array_put(&(p->dictionary), hval, NIL);
--(p->dictionary->numElements);
*ret = tuple_val(old)[2];
}
} else if (is_list(old)) {
/* Find cons cell for identical value */
Eterm* prev = &p->dictionary->data[hval];
for (tmp = *prev; tmp != NIL; prev = &TCDR(tmp), tmp = *prev) {
if (EQ(tuple_val(TCAR(tmp))[1], id)) {
*prev = TCDR(tmp);
*ret = tuple_val(TCAR(tmp))[2];
--(p->dictionary->numElements);
}
}
/* If there is only one element left in the list we must remove the list. */
old = ARRAY_GET(p->dictionary, hval);
ASSERT(is_list(old));
if (is_nil(TCDR(old))) {
array_put(&p->dictionary, hval, TCAR(old));
}
} else if (is_not_nil(old)) {
#ifdef DEBUG
erts_fprintf(stderr,
"Process dictionary for process %T is broken, trying to "
"display term found in line %d:\n"
"%T\n", p->common.id, __LINE__, old);
#endif
erl_exit(1, "Damaged process dictionary found during erase/1.");
}
if ((range = HASH_RANGE(p->dictionary)) > INITIAL_SIZE &&
range / 2 > (p->dictionary->numElements)) {
shrink(p, ret);
}
}
static value_t *e_tuple(env_t *env, expr_t *expr)
{
value_t *result;
eli_closure_t c;
c.env = env;
c.list = list_empty();
list_iterate(tuple_val(expr), thunk_list_i, &c);
list_reverse(c.list);
result = alloc_value(v_tuple);
tuple_val(result) = c.list;
return result;
}
/* Merges the the global environment and the given {Key, Value} list into env,
* unsetting all keys whose value is either 'false' or NIL. The behavior on
* NIL is undocumented and perhaps surprising, but the previous implementation
* worked in this manner. */
static int merge_global_environment(erts_osenv_t *env, Eterm key_value_pairs) {
const erts_osenv_t *global_env = erts_sys_rlock_global_osenv();
erts_osenv_merge(env, global_env, 0);
erts_sys_runlock_global_osenv();
while (is_list(key_value_pairs)) {
Eterm *cell, *tuple;
cell = list_val(key_value_pairs);
if(!is_tuple_arity(CAR(cell), 2)) {
return -1;
}
tuple = tuple_val(CAR(cell));
key_value_pairs = CDR(cell);
if(is_nil(tuple[2]) || tuple[2] == am_false) {
if(erts_osenv_unset_term(env, tuple[1]) < 0) {
return -1;
}
} else {
if(erts_osenv_put_term(env, tuple[1], tuple[2]) < 0) {
return -1;
}
}
}
if(!is_nil(key_value_pairs)) {
return -1;
}
return 0;
}
static void
delete_table(Process* c_p, HashTable* table)
{
Uint idx = table->first_to_delete;
Uint n = table->num_to_delete;
/*
* There are no longer any references to this hash table.
*
* Any literals pointed for deletion can be queued for
* deletion and the table itself can be deallocated.
*/
#ifdef DEBUG
if (n == 1) {
ASSERT(is_tuple_arity(table->term[idx], 2));
}
#endif
while (n > 0) {
Eterm term = table->term[idx];
if (is_tuple_arity(term, 2)) {
if (is_immed(tuple_val(term)[2])) {
erts_release_literal_area(term_to_area(term));
} else {
erts_queue_release_literals(c_p, term_to_area(term));
}
}
idx++, n--;
}
erts_free(ERTS_ALC_T_PERSISTENT_TERM, table);
}
static ErtsLiteralArea*
term_to_area(Eterm tuple)
{
ASSERT(is_tuple_arity(tuple, 2));
return (ErtsLiteralArea *) (((char *) tuple_val(tuple)) -
offsetof(ErtsLiteralArea, start));
}
static int equality_test(value_t *l, value_t *r)
{
int result;
switch (l->type) {
default:
case v_unused:
if (*(int *)NULL) {
printf("should crash.\n");
}
break;
case v_bool:
result = bool_val(l) == bool_val(r);
break;
case v_char:
result = char_val(l) == char_val(r);
break;
case v_datacons:
if (strcmp(datacons_tag(l), datacons_tag(r)) == 0) {
result = 1;
list_zip_with(datacons_params(l),
datacons_params(r),
equality_test_i, &result);
} else {
result = 0;
}
break;
case v_num:
result = num_val(l) == num_val(r);
break;
case v_tuple:
result = 1;
list_zip_with(tuple_val(l),
tuple_val(r),
equality_test_i, &result);
break;
}
return result;
}
int enif_get_tuple(ErlNifEnv* env, Eterm tpl, int* arity, const Eterm** array)
{
Eterm* ptr;
if (is_not_tuple(tpl)) {
return 0;
}
ptr = tuple_val(tpl);
*arity = arityval(*ptr);
*array = ptr+1;
return 1;
}
BIF_RETTYPE erts_internal_check_process_code_2(BIF_ALIST_2)
{
int reds = 0;
Eterm res;
Eterm olist = BIF_ARG_2;
int allow_gc = 1;
if (is_not_atom(BIF_ARG_1))
goto badarg;
while (is_list(olist)) {
Eterm *lp = list_val(olist);
Eterm opt = CAR(lp);
if (is_tuple(opt)) {
Eterm* tp = tuple_val(opt);
switch (arityval(tp[0])) {
case 2:
switch (tp[1]) {
case am_allow_gc:
switch (tp[2]) {
case am_false:
allow_gc = 0;
break;
case am_true:
allow_gc = 1;
break;
default:
goto badarg;
}
break;
default:
goto badarg;
}
break;
default:
goto badarg;
}
}
else
goto badarg;
olist = CDR(lp);
}
if (is_not_nil(olist))
goto badarg;
res = erts_check_process_code(BIF_P, BIF_ARG_1, allow_gc, &reds);
ASSERT(is_value(res));
BIF_RET2(res, reds);
badarg:
BIF_ERROR(BIF_P, BADARG);
}
static Uint
lookup(HashTable* hash_table, Eterm key)
{
Uint mask = hash_table->mask;
Eterm* table = hash_table->term;
Uint32 idx = make_internal_hash(key, 0);
Eterm term;
do {
idx++;
term = table[idx & mask];
} while (is_boxed(term) && !EQ(key, (tuple_val(term))[1]));
return idx & mask;
}
/*
* Record test cannot actually be a bif. The epp processor is involved in
* the real guard test, we have to add one more parameter, the
* return value of record_info(size, Rec), which is the arity of the TUPLE.
* his may seem awkward when applied from the shell, where the plain
* tuple test is more understandable, I think...
*/
BIF_RETTYPE is_record_3(BIF_ALIST_3)
{
Eterm *t;
if (is_not_atom(BIF_ARG_2) || is_not_small(BIF_ARG_3)) {
BIF_ERROR(BIF_P, BADARG);
}
if (is_tuple(BIF_ARG_1) &&
arityval(*(t = tuple_val(BIF_ARG_1))) == signed_val(BIF_ARG_3)
&& t[1] == BIF_ARG_2) {
BIF_RET(am_true);
}
BIF_RET(am_false);
}
BIF_RETTYPE persistent_term_get_1(BIF_ALIST_1)
{
Eterm key = BIF_ARG_1;
HashTable* hash_table = (HashTable *) erts_atomic_read_nob(&the_hash_table);
Uint entry_index;
Eterm term;
entry_index = lookup(hash_table, key);
term = hash_table->term[entry_index];
if (is_boxed(term)) {
ASSERT(is_tuple_arity(term, 2));
BIF_RET(tuple_val(term)[2]);
}
BIF_ERROR(BIF_P, BADARG);
}
/*
* The compiler usually translates calls to is_record/2 to more primitive
* operations. In some cases this is not possible. We'll need to implement
* a weak version of is_record/2 as BIF (the size of the record cannot
* be verified).
*/
BIF_RETTYPE is_record_2(BIF_ALIST_2)
{
Eterm *t;
if (is_not_atom(BIF_ARG_2)) {
BIF_ERROR(BIF_P, BADARG);
}
if (is_tuple(BIF_ARG_1) &&
arityval(*(t = tuple_val(BIF_ARG_1))) >= 1 &&
t[1] == BIF_ARG_2) {
BIF_RET(am_true);
}
BIF_RET(am_false);
}
BIF_RETTYPE persistent_term_get_2(BIF_ALIST_2)
{
Eterm key = BIF_ARG_1;
Eterm result = BIF_ARG_2;
HashTable* hash_table = (HashTable *) erts_atomic_read_nob(&the_hash_table);
Uint entry_index;
Eterm term;
entry_index = lookup(hash_table, key);
term = hash_table->term[entry_index];
if (is_boxed(term)) {
ASSERT(is_tuple_arity(term, 2));
result = tuple_val(term)[2];
}
BIF_RET(result);
}
BIF_RETTYPE size_1(BIF_ALIST_1)
{
if (is_tuple(BIF_ARG_1)) {
Eterm* tupleptr = tuple_val(BIF_ARG_1);
BIF_RET(make_small(arityval(*tupleptr)));
} else if (is_binary(BIF_ARG_1)) {
Uint sz = binary_size(BIF_ARG_1);
if (IS_USMALL(0, sz)) {
return make_small(sz);
} else {
Eterm* hp = HAlloc(BIF_P, BIG_UINT_HEAP_SIZE);
BIF_RET(uint_to_big(sz, hp));
}
}
BIF_ERROR(BIF_P, BADARG);
}
/* Return value as a bif, called by erlang:monitor */
Eterm erts_ddll_monitor_driver(Process *p,
Eterm description,
ErtsProcLocks plocks)
{
Eterm *tp;
Eterm ret;
char *name;
if (is_not_tuple(description)) {
BIF_ERROR(p,BADARG);
}
tp = tuple_val(description);
if (*tp != make_arityval(2)) {
BIF_ERROR(p,BADARG);
}
if ((name = pick_list_or_atom(tp[1])) == NULL) {
BIF_ERROR(p,BADARG);
}
switch (tp[2]) {
case am_loaded:
ERTS_BIF_PREP_RET(ret, notify_when_loaded(p,tp[1],name,plocks));
break;
case am_unloaded:
ERTS_BIF_PREP_RET(ret, notify_when_unloaded(p,tp[1],name,plocks,
ERL_DE_PROC_AWAIT_UNLOAD));
break;
case am_unloaded_only:
ERTS_BIF_PREP_RET(ret,
notify_when_unloaded(p,tp[1],name,plocks,
ERL_DE_PROC_AWAIT_UNLOAD_ONLY));
break;
default:
ERTS_BIF_PREP_ERROR(ret,p,BADARG);
break;
}
erts_free(ERTS_ALC_T_DDLL_TMP_BUF, (void *) name);
return ret;
}
static int errdesc_to_code(Eterm errdesc, int *code /* out */)
{
int i;
if (is_atom(errdesc)) {
Atom *ap = atom_tab(atom_val(errdesc));
for (i = 0; errcode_tab[i].atm != NULL; ++i) {
int len = sys_strlen(errcode_tab[i].atm);
if (len == ap->len &&
!sys_strncmp(errcode_tab[i].atm,(char *) ap->name,len)) {
*code = errcode_tab[i].code;
return 0;
}
}
return -1;
} else if (is_tuple(errdesc)) {
Eterm *tp = tuple_val(errdesc);
if (*tp != make_arityval(2) || tp[1] != am_open_error || is_not_small(tp[2])) {
return -1;
}
*code = signed_val(tp[2]);
return 0;
}
return -1;
}
BIF_RETTYPE
erts_debug_breakpoint_2(BIF_ALIST_2)
{
Process* p = BIF_P;
Eterm MFA = BIF_ARG_1;
Eterm boolean = BIF_ARG_2;
Eterm* tp;
ErtsCodeMFA mfa;
int i;
int specified = 0;
Eterm res;
BpFunctions f;
if (boolean != am_true && boolean != am_false)
goto error;
if (is_not_tuple(MFA)) {
goto error;
}
tp = tuple_val(MFA);
if (*tp != make_arityval(3)) {
goto error;
}
if (!is_atom(tp[1]) || !is_atom(tp[2]) ||
(!is_small(tp[3]) && tp[3] != am_Underscore)) {
goto error;
}
for (i = 0; i < 3 && tp[i+1] != am_Underscore; i++, specified++) {
/* Empty loop body */
}
for (i = specified; i < 3; i++) {
if (tp[i+1] != am_Underscore) {
goto error;
}
}
mfa.module = tp[1];
mfa.function = tp[2];
if (is_small(tp[3])) {
mfa.arity = signed_val(tp[3]);
}
if (!erts_try_seize_code_write_permission(BIF_P)) {
ERTS_BIF_YIELD2(bif_export[BIF_erts_debug_breakpoint_2],
BIF_P, BIF_ARG_1, BIF_ARG_2);
}
erts_proc_unlock(p, ERTS_PROC_LOCK_MAIN);
erts_thr_progress_block();
erts_bp_match_functions(&f, &mfa, specified);
if (boolean == am_true) {
erts_set_debug_break(&f);
erts_install_breakpoints(&f);
erts_commit_staged_bp();
} else {
erts_clear_debug_break(&f);
erts_commit_staged_bp();
erts_uninstall_breakpoints(&f);
}
erts_consolidate_bp_data(&f, 1);
res = make_small(f.matched);
erts_bp_free_matched_functions(&f);
erts_thr_progress_unblock();
erts_proc_lock(p, ERTS_PROC_LOCK_MAIN);
erts_release_code_write_permission();
return res;
error:
BIF_ERROR(p, BADARG);
}
/*
You have to have loaded the driver and the pid state
is LOADED or AWAIT_LOAD. You will be removed from the list
regardless of driver state.
If the driver is loaded by someone else to, return is
{ok, pending_process}
If the driver is loaded but locked by a port, return is
{ok, pending_driver}
If the driver is loaded and free to unload (you're the last holding it)
{ok, unloaded}
If it's not loaded or not loaded by you
{error, not_loaded} or {error, not_loaded_by_you}
Internally, if its in state UNLOADING, just return {ok, pending_driver} and
remove/decrement this pid (which should be an LOADED tagged one).
If the state is RELOADING, this pid should be in list as LOADED tagged,
only AWAIT_LOAD would be possible but not allowed for unloading, remove it
and, if the last LOADED tagged, change from RELOAD to UNLOAD and notify
any AWAIT_LOAD-waiters with {'DOWN', ref(), driver, name(), load_cancelled}
If the driver made itself permanent, {'UP', ref(), driver, name(), permanent}
*/
Eterm erl_ddll_try_unload_2(BIF_ALIST_2)
{
Eterm name_term = BIF_ARG_1;
Eterm options = BIF_ARG_2;
char *name = NULL;
Eterm ok_term = NIL;
Eterm soft_error_term = NIL;
erts_driver_t *drv;
DE_Handle *dh;
DE_ProcEntry *pe;
Eterm *hp;
Eterm t;
int monitor = 0;
Eterm l;
int kill_ports = 0;
erts_proc_unlock(BIF_P, ERTS_PROC_LOCK_MAIN);
for(l = options; is_list(l); l = CDR(list_val(l))) {
Eterm opt = CAR(list_val(l));
Eterm *tp;
if (is_not_tuple(opt)) {
if (opt == am_kill_ports) {
kill_ports = 1;
continue;
} else {
goto error;
}
}
tp = tuple_val(opt);
if (*tp != make_arityval(2) || tp[1] != am_monitor) {
goto error;
}
if (tp[2] == am_pending_driver) {
monitor = 1;
} else if (tp[2] == am_pending) {
monitor = 2;
} else {
goto error;
}
}
if (is_not_nil(l)) {
goto error;
}
if ((name = pick_list_or_atom(name_term)) == NULL) {
goto error;
}
lock_drv_list();
if ((drv = lookup_driver(name)) == NULL) {
soft_error_term = am_not_loaded;
goto soft_error;
}
if (drv->handle == NULL) {
soft_error_term = am_linked_in_driver;
goto soft_error;
} else if (drv->handle->status == ERL_DE_PERMANENT) {
soft_error_term = am_permanent;
goto soft_error;
}
dh = drv->handle;
if (dh->flags & ERL_DE_FL_KILL_PORTS) {
kill_ports = 1;
}
if ((pe = find_proc_entry(dh, BIF_P, ERL_DE_PROC_LOADED)) == NULL) {
if (num_procs(dh, ERL_DE_PROC_LOADED) > 0) {
soft_error_term = am_not_loaded_by_this_process;
goto soft_error;
}
} else {
remove_proc_entry(dh, pe);
if (!(pe->flags & ERL_DE_FL_DEREFERENCED)) {
erts_ddll_dereference_driver(dh);
}
erts_free(ERTS_ALC_T_DDLL_PROCESS, pe);
}
if (num_procs(dh, ERL_DE_PROC_LOADED) > 0) {
ok_term = am_pending_process;
--monitor;
goto done;
}
if (dh->status == ERL_DE_RELOAD ||
dh->status == ERL_DE_FORCE_RELOAD) {
notify_all(dh, drv->name,
ERL_DE_PROC_AWAIT_LOAD, am_DOWN, am_load_cancelled);
erts_free(ERTS_ALC_T_DDLL_HANDLE,dh->reload_full_path);
erts_free(ERTS_ALC_T_DDLL_HANDLE,dh->reload_driver_name);
dh->reload_full_path = dh->reload_driver_name = NULL;
dh->reload_flags = 0;
}
if (erts_atomic32_read_nob(&dh->port_count) > 0) {
++kill_ports;
}
dh->status = ERL_DE_UNLOAD;
ok_term = am_pending_driver;
done:
assert_drv_list_rwlocked();
if (kill_ports > 1) {
/* Avoid closing the driver by referencing it */
erts_ddll_reference_driver(dh);
dh->status = ERL_DE_FORCE_UNLOAD;
unlock_drv_list();
kill_ports_driver_unloaded(dh);
lock_drv_list();
erts_ddll_dereference_driver(dh);
}
erts_ddll_reference_driver(dh);
unlock_drv_list();
erts_proc_lock(BIF_P, ERTS_PROC_LOCK_MAIN);
lock_drv_list();
erts_ddll_dereference_driver(dh);
erts_free(ERTS_ALC_T_DDLL_TMP_BUF, (void *) name);
BIF_P->flags |= F_USING_DDLL;
if (monitor > 0) {
Eterm mref = add_monitor(BIF_P, dh, ERL_DE_PROC_AWAIT_UNLOAD);
hp = HAlloc(BIF_P, 4);
t = TUPLE3(hp, am_ok, ok_term, mref);
} else {
hp = HAlloc(BIF_P, 3);
t = TUPLE2(hp, am_ok, ok_term);
}
if (kill_ports > 1) {
ERTS_BIF_CHK_EXITED(BIF_P); /* May be exited by port killing */
}
unlock_drv_list();
BIF_RET(t);
soft_error:
unlock_drv_list();
erts_free(ERTS_ALC_T_DDLL_TMP_BUF, (void *) name);
erts_proc_lock(BIF_P, ERTS_PROC_LOCK_MAIN);
hp = HAlloc(BIF_P, 3);
t = TUPLE2(hp, am_error, soft_error_term);
BIF_RET(t);
error: /* No lock fiddling before going here */
assert_drv_list_not_locked();
if (name != NULL) {
erts_free(ERTS_ALC_T_DDLL_TMP_BUF, (void *) name);
}
erts_proc_lock(BIF_P, ERTS_PROC_LOCK_MAIN);
BIF_ERROR(BIF_P, BADARG);
}
/*
* Try to load. If the driver is OK, add as LOADED. If the driver is
* UNLOAD, possibly change to reload and add as LOADED,
* there should be no other
* LOADED tagged pid's. If the driver is RELOAD then add/increment as
* LOADED (should be some LOADED pid). If the driver is not present,
* really load and add as LOADED {ok,loaded} {ok,pending_driver}
* {error, permanent} {error,load_error()}
*/
BIF_RETTYPE erl_ddll_try_load_3(BIF_ALIST_3)
{
Eterm path_term = BIF_ARG_1;
Eterm name_term = BIF_ARG_2;
Eterm options = BIF_ARG_3;
char *path = NULL;
Sint path_len;
char *name = NULL;
DE_Handle *dh;
erts_driver_t *drv;
int res;
Eterm soft_error_term = NIL;
Eterm ok_term = NIL;
Eterm *hp;
Eterm t;
int monitor = 0;
int reload = 0;
Eterm l;
Uint flags = 0;
int kill_ports = 0;
int do_build_load_error = 0;
int build_this_load_error = 0;
int encoding;
for(l = options; is_list(l); l = CDR(list_val(l))) {
Eterm opt = CAR(list_val(l));
Eterm *tp;
if (is_not_tuple(opt)) {
goto error;
}
tp = tuple_val(opt);
if (*tp != make_arityval(2) || is_not_atom(tp[1])) {
goto error;
}
switch (tp[1]) {
case am_driver_options:
{
Eterm ll;
for(ll = tp[2]; is_list(ll); ll = CDR(list_val(ll))) {
Eterm dopt = CAR(list_val(ll));
if (dopt == am_kill_ports) {
flags |= ERL_DE_FL_KILL_PORTS;
} else {
goto error;
}
}
if (is_not_nil(ll)) {
goto error;
}
}
break;
case am_monitor:
if (tp[2] == am_pending_driver) {
monitor = 1;
} else if (tp[2] == am_pending ) {
monitor = 2;
} else {
goto error;
}
break;
case am_reload:
if (tp[2] == am_pending_driver) {
reload = 1;
} else if (tp[2] == am_pending ) {
reload = 2;
} else {
goto error;
}
break;
default:
goto error;
}
}
if (is_not_nil(l)) {
goto error;
}
if ((name = pick_list_or_atom(name_term)) == NULL) {
goto error;
}
encoding = erts_get_native_filename_encoding();
if (encoding == ERL_FILENAME_WIN_WCHAR) {
/* Do not convert the lib name to utf-16le yet, do that in win32 specific code */
/* since lib_name is used in error messages */
encoding = ERL_FILENAME_UTF8;
}
path = erts_convert_filename_to_encoding(path_term, NULL, 0,
ERTS_ALC_T_DDLL_TMP_BUF, 1, 0,
encoding, &path_len,
sys_strlen(name) + 2); /* might need path separator */
if (!path) {
goto error;
}
ASSERT(path_len > 0 && path[path_len-1] == 0);
while (--path_len > 0 && (path[path_len-1] == '\\' || path[path_len-1] == '/'))
;
path[path_len++] = '/';
sys_strcpy(path+path_len,name);
erts_proc_unlock(BIF_P, ERTS_PROC_LOCK_MAIN);
lock_drv_list();
if ((drv = lookup_driver(name)) != NULL) {
if (drv->handle == NULL) {
/* static_driver */
soft_error_term = am_linked_in_driver;
goto soft_error;
} else {
dh = drv->handle;
if (dh->status == ERL_DE_OK) {
int is_last = is_last_user(dh, BIF_P);
if (reload == 1 && !is_last) {
/*Want reload if no other users,
but there are others...*/
soft_error_term = am_pending_process;
goto soft_error;
}
if (reload != 0) {
DE_ProcEntry *old;
if ((dh->flags & ERL_FL_CONSISTENT_MASK) !=
(flags & ERL_FL_CONSISTENT_MASK)) {
soft_error_term = am_inconsistent;
goto soft_error;
}
if ((old = find_proc_entry(dh, BIF_P,
ERL_DE_PROC_LOADED)) ==
NULL) {
soft_error_term = am_not_loaded_by_this_process;
goto soft_error;
} else {
remove_proc_entry(dh, old);
erts_ddll_dereference_driver(dh);
erts_free(ERTS_ALC_T_DDLL_PROCESS, old);
}
/* Reload requested and granted */
dereference_all_processes(dh);
set_driver_reloading(dh, BIF_P, path, name, flags);
if (dh->flags & ERL_DE_FL_KILL_PORTS) {
kill_ports = 1;
}
ok_term = (reload == 1) ? am_pending_driver :
am_pending_process;
} else {
/* Already loaded and healthy (might be by me) */
if (sys_strcmp(dh->full_path, path) ||
(dh->flags & ERL_FL_CONSISTENT_MASK) !=
(flags & ERL_FL_CONSISTENT_MASK)) {
soft_error_term = am_inconsistent;
goto soft_error;
}
add_proc_loaded(dh, BIF_P);
erts_ddll_reference_driver(dh);
monitor = 0;
ok_term = mkatom("already_loaded");
}
} else if (dh->status == ERL_DE_UNLOAD ||
dh->status == ERL_DE_FORCE_UNLOAD) {
/* pending driver */
if (reload != 0) {
soft_error_term = am_not_loaded_by_this_process;
goto soft_error;
}
if (sys_strcmp(dh->full_path, path) ||
(dh->flags & ERL_FL_CONSISTENT_MASK) !=
(flags & ERL_FL_CONSISTENT_MASK)) {
soft_error_term = am_inconsistent;
goto soft_error;
}
dh->status = ERL_DE_OK;
notify_all(dh, drv->name,
ERL_DE_PROC_AWAIT_UNLOAD, am_UP,
am_unload_cancelled);
add_proc_loaded(dh, BIF_P);
erts_ddll_reference_driver(dh);
monitor = 0;
ok_term = mkatom("already_loaded");
} else if (dh->status == ERL_DE_RELOAD ||
dh->status == ERL_DE_FORCE_RELOAD) {
if (reload != 0) {
soft_error_term = am_pending_reload;
goto soft_error;
}
if (sys_strcmp(dh->reload_full_path, path) ||
(dh->reload_flags & ERL_FL_CONSISTENT_MASK) !=
(flags & ERL_FL_CONSISTENT_MASK)) {
soft_error_term = am_inconsistent;
goto soft_error;
}
/* Load of granted unload... */
/* Don't reference, will happen after reload */
add_proc_loaded_deref(dh, BIF_P);
++monitor;
ok_term = am_pending_driver;
} else { /* ERL_DE_PERMANENT */
soft_error_term = am_permanent;
goto soft_error;
}
}
} else { /* driver non-existing */
if (reload != 0) {
soft_error_term = am_not_loaded;
goto soft_error;
}
if ((res = load_driver_entry(&dh, path, name)) != ERL_DE_NO_ERROR) {
build_this_load_error = res;
do_build_load_error = 1;
soft_error_term = am_undefined;
goto soft_error;
} else {
dh->flags = flags;
add_proc_loaded(dh, BIF_P);
first_ddll_reference(dh);
monitor = 0;
ok_term = mkatom("loaded");
}
}
assert_drv_list_rwlocked();
if (kill_ports) {
/* Avoid closing the driver by referencing it */
erts_ddll_reference_driver(dh);
ASSERT(dh->status == ERL_DE_RELOAD);
dh->status = ERL_DE_FORCE_RELOAD;
unlock_drv_list();
kill_ports_driver_unloaded(dh);
/* Dereference, eventually causing driver destruction */
lock_drv_list();
erts_ddll_dereference_driver(dh);
}
erts_ddll_reference_driver(dh);
unlock_drv_list();
erts_proc_lock(BIF_P, ERTS_PROC_LOCK_MAIN);
lock_drv_list();
erts_ddll_dereference_driver(dh);
BIF_P->flags |= F_USING_DDLL;
if (monitor) {
Eterm mref = add_monitor(BIF_P, dh, ERL_DE_PROC_AWAIT_LOAD);
hp = HAlloc(BIF_P, 4);
t = TUPLE3(hp, am_ok, ok_term, mref);
} else {
hp = HAlloc(BIF_P, 3);
t = TUPLE2(hp, am_ok, ok_term);
}
unlock_drv_list();
erts_free(ERTS_ALC_T_DDLL_TMP_BUF, (void *) path);
erts_free(ERTS_ALC_T_DDLL_TMP_BUF, (void *) name);
ERTS_LC_ASSERT(ERTS_PROC_LOCK_MAIN & erts_proc_lc_my_proc_locks(BIF_P));
BIF_RET(t);
soft_error:
unlock_drv_list();
erts_proc_lock(BIF_P, ERTS_PROC_LOCK_MAIN);
if (do_build_load_error) {
soft_error_term = build_load_error(BIF_P, build_this_load_error);
}
hp = HAlloc(BIF_P, 3);
t = TUPLE2(hp, am_error, soft_error_term);
erts_free(ERTS_ALC_T_DDLL_TMP_BUF, (void *) path);
erts_free(ERTS_ALC_T_DDLL_TMP_BUF, (void *) name);
ERTS_LC_ASSERT(ERTS_PROC_LOCK_MAIN & erts_proc_lc_my_proc_locks(BIF_P));
BIF_RET(t);
error:
assert_drv_list_not_locked();
ERTS_LC_ASSERT(ERTS_PROC_LOCK_MAIN & erts_proc_lc_my_proc_locks(BIF_P));
if (path != NULL) {
erts_free(ERTS_ALC_T_DDLL_TMP_BUF, (void *) path);
}
if (name != NULL) {
erts_free(ERTS_ALC_T_DDLL_TMP_BUF, (void *) name);
}
BIF_ERROR(BIF_P, BADARG);
}
static Eterm
reference_table_term(Uint **hpp, Uint *szp)
{
#undef MK_2TUP
#undef MK_3TUP
#undef MK_CONS
#undef MK_UINT
#define MK_2TUP(E1, E2) erts_bld_tuple(hpp, szp, 2, (E1), (E2))
#define MK_3TUP(E1, E2, E3) erts_bld_tuple(hpp, szp, 3, (E1), (E2), (E3))
#define MK_CONS(CAR, CDR) erts_bld_cons(hpp, szp, (CAR), (CDR))
#define MK_UINT(UI) erts_bld_uint(hpp, szp, (UI))
int i;
Eterm tup;
Eterm tup2;
Eterm nl = NIL;
Eterm dl = NIL;
Eterm nrid;
for(i = 0; i < no_referred_nodes; i++) {
NodeReferrer *nrp;
Eterm nril = NIL;
for(nrp = referred_nodes[i].referrers; nrp; nrp = nrp->next) {
Eterm nrl = NIL;
/* NodeReferenceList = [{ReferenceType,References}] */
if(nrp->heap_ref) {
tup = MK_2TUP(AM_heap, MK_UINT(nrp->heap_ref));
nrl = MK_CONS(tup, nrl);
}
if(nrp->link_ref) {
tup = MK_2TUP(AM_link, MK_UINT(nrp->link_ref));
nrl = MK_CONS(tup, nrl);
}
if(nrp->monitor_ref) {
tup = MK_2TUP(AM_monitor, MK_UINT(nrp->monitor_ref));
nrl = MK_CONS(tup, nrl);
}
if(nrp->ets_ref) {
tup = MK_2TUP(AM_ets, MK_UINT(nrp->ets_ref));
nrl = MK_CONS(tup, nrl);
}
if(nrp->bin_ref) {
tup = MK_2TUP(AM_binary, MK_UINT(nrp->bin_ref));
nrl = MK_CONS(tup, nrl);
}
if(nrp->timer_ref) {
tup = MK_2TUP(AM_timer, MK_UINT(nrp->timer_ref));
nrl = MK_CONS(tup, nrl);
}
if(nrp->system_ref) {
tup = MK_2TUP(AM_system, MK_UINT(nrp->system_ref));
nrl = MK_CONS(tup, nrl);
}
nrid = nrp->id;
if (!IS_CONST(nrp->id)) {
Uint nrid_sz = size_object(nrp->id);
if (szp)
*szp += nrid_sz;
if (hpp)
nrid = copy_struct(nrp->id, nrid_sz, hpp, NULL);
}
if (is_internal_pid(nrid) || nrid == am_error_logger) {
ASSERT(!nrp->ets_ref && !nrp->bin_ref && !nrp->system_ref);
tup = MK_2TUP(AM_process, nrid);
}
else if (is_tuple(nrid)) {
Eterm *t;
ASSERT(!nrp->ets_ref && !nrp->bin_ref);
t = tuple_val(nrid);
ASSERT(2 == arityval(t[0]));
tup = MK_2TUP(t[1], t[2]);
}
else if(is_internal_port(nrid)) {
ASSERT(!nrp->heap_ref && !nrp->ets_ref && !nrp->bin_ref
&& !nrp->timer_ref && !nrp->system_ref);
tup = MK_2TUP(AM_port, nrid);
}
else if(nrp->ets_ref) {
ASSERT(!nrp->heap_ref && !nrp->link_ref &&
!nrp->monitor_ref && !nrp->bin_ref
&& !nrp->timer_ref && !nrp->system_ref);
tup = MK_2TUP(AM_ets, nrid);
}
else if(nrp->bin_ref) {
ASSERT(is_small(nrid) || is_big(nrid));
ASSERT(!nrp->heap_ref && !nrp->ets_ref && !nrp->link_ref &&
!nrp->monitor_ref && !nrp->timer_ref
&& !nrp->system_ref);
tup = MK_2TUP(AM_match_spec, nrid);
}
else {
ASSERT(!nrp->heap_ref && !nrp->ets_ref && !nrp->bin_ref);
ASSERT(is_atom(nrid));
tup = MK_2TUP(AM_dist, nrid);
}
tup = MK_2TUP(tup, nrl);
/* NodeReferenceIdList = [{{ReferrerType, ID}, NodeReferenceList}] */
nril = MK_CONS(tup, nril);
}
/* NodeList = [{{Node, Creation}, Refc, NodeReferenceIdList}] */
tup = MK_2TUP(referred_nodes[i].node->sysname,
MK_UINT(referred_nodes[i].node->creation));
tup = MK_3TUP(tup, MK_UINT(erts_refc_read(&referred_nodes[i].node->refc, 1)), nril);
nl = MK_CONS(tup, nl);
}
for(i = 0; i < no_referred_dists; i++) {
DistReferrer *drp;
Eterm dril = NIL;
for(drp = referred_dists[i].referrers; drp; drp = drp->next) {
Eterm drl = NIL;
/* DistReferenceList = [{ReferenceType,References}] */
if(drp->node_ref) {
tup = MK_2TUP(AM_node, MK_UINT(drp->node_ref));
drl = MK_CONS(tup, drl);
}
if(drp->ctrl_ref) {
tup = MK_2TUP(AM_control, MK_UINT(drp->ctrl_ref));
drl = MK_CONS(tup, drl);
}
if (is_internal_pid(drp->id)) {
ASSERT(drp->ctrl_ref && !drp->node_ref);
tup = MK_2TUP(AM_process, drp->id);
}
else if(is_internal_port(drp->id)) {
ASSERT(drp->ctrl_ref && !drp->node_ref);
tup = MK_2TUP(AM_port, drp->id);
}
else {
ASSERT(!drp->ctrl_ref && drp->node_ref);
ASSERT(is_atom(drp->id));
tup = MK_2TUP(drp->id, MK_UINT(drp->creation));
tup = MK_2TUP(AM_node, tup);
}
tup = MK_2TUP(tup, drl);
/* DistReferenceIdList =
[{{ReferrerType, ID}, DistReferenceList}] */
dril = MK_CONS(tup, dril);
}
/* DistList = [{Dist, Refc, ReferenceIdList}] */
tup = MK_3TUP(referred_dists[i].dist->sysname,
MK_UINT(erts_refc_read(&referred_dists[i].dist->refc, 1)),
dril);
dl = MK_CONS(tup, dl);
}
/* {{node_references, NodeList}, {dist_references, DistList}} */
tup = MK_2TUP(AM_node_references, nl);
tup2 = MK_2TUP(AM_dist_references, dl);
tup = MK_2TUP(tup, tup2);
return tup;
#undef MK_2TUP
#undef MK_3TUP
#undef MK_CONS
#undef MK_UINT
}
static Port *
open_port(Process* p, Eterm name, Eterm settings, int *err_typep, int *err_nump)
{
Sint i;
Eterm option;
Uint arity;
Eterm* tp;
Uint* nargs;
erts_driver_t* driver;
char* name_buf = NULL;
SysDriverOpts opts;
Sint linebuf;
Eterm edir = NIL;
byte dir[MAXPATHLEN];
erts_aint32_t sflgs = 0;
Port *port;
/* These are the defaults */
opts.packet_bytes = 0;
opts.use_stdio = 1;
opts.redir_stderr = 0;
opts.read_write = 0;
opts.hide_window = 0;
opts.wd = NULL;
opts.envir = NULL;
opts.exit_status = 0;
opts.overlapped_io = 0;
opts.spawn_type = ERTS_SPAWN_ANY;
opts.argv = NULL;
opts.parallelism = erts_port_parallelism;
linebuf = 0;
*err_nump = 0;
if (is_not_list(settings) && is_not_nil(settings)) {
goto badarg;
}
/*
* Parse the settings.
*/
if (is_not_nil(settings)) {
nargs = list_val(settings);
while (1) {
if (is_tuple_arity(*nargs, 2)) {
tp = tuple_val(*nargs);
arity = *tp++;
option = *tp++;
if (option == am_packet) {
if (is_not_small(*tp)) {
goto badarg;
}
opts.packet_bytes = signed_val(*tp);
switch (opts.packet_bytes) {
case 1:
case 2:
case 4:
break;
default:
goto badarg;
}
} else if (option == am_line) {
if (is_not_small(*tp)) {
goto badarg;
}
linebuf = signed_val(*tp);
if (linebuf <= 0) {
goto badarg;
}
} else if (option == am_env) {
byte* bytes;
if ((bytes = convert_environment(p, *tp)) == NULL) {
goto badarg;
}
opts.envir = (char *) bytes;
} else if (option == am_args) {
char **av;
char **oav = opts.argv;
if ((av = convert_args(*tp)) == NULL) {
goto badarg;
}
opts.argv = av;
if (oav) {
opts.argv[0] = oav[0];
oav[0] = erts_default_arg0;
free_args(oav);
}
} else if (option == am_arg0) {
char *a0;
if ((a0 = erts_convert_filename_to_native(*tp, NULL, 0, ERTS_ALC_T_TMP, 1, 1, NULL)) == NULL) {
goto badarg;
}
if (opts.argv == NULL) {
opts.argv = erts_alloc(ERTS_ALC_T_TMP,
2 * sizeof(char **));
opts.argv[0] = a0;
opts.argv[1] = NULL;
} else {
if (opts.argv[0] != erts_default_arg0) {
erts_free(ERTS_ALC_T_TMP, opts.argv[0]);
}
opts.argv[0] = a0;
}
} else if (option == am_cd) {
edir = *tp;
} else if (option == am_parallelism) {
if (*tp == am_true)
opts.parallelism = 1;
else if (*tp == am_false)
opts.parallelism = 0;
else
goto badarg;
} else {
goto badarg;
}
} else if (*nargs == am_stream) {
opts.packet_bytes = 0;
} else if (*nargs == am_use_stdio) {
opts.use_stdio = 1;
} else if (*nargs == am_stderr_to_stdout) {
opts.redir_stderr = 1;
} else if (*nargs == am_line) {
linebuf = 512;
} else if (*nargs == am_nouse_stdio) {
opts.use_stdio = 0;
} else if (*nargs == am_binary) {
sflgs |= ERTS_PORT_SFLG_BINARY_IO;
} else if (*nargs == am_in) {
opts.read_write |= DO_READ;
} else if (*nargs == am_out) {
opts.read_write |= DO_WRITE;
} else if (*nargs == am_eof) {
sflgs |= ERTS_PORT_SFLG_SOFT_EOF;
} else if (*nargs == am_hide) {
opts.hide_window = 1;
} else if (*nargs == am_exit_status) {
opts.exit_status = 1;
} else if (*nargs == am_overlapped_io) {
opts.overlapped_io = 1;
} else {
goto badarg;
}
if (is_nil(*++nargs))
break;
if (is_not_list(*nargs)) {
goto badarg;
}
nargs = list_val(*nargs);
}
}
if (opts.read_write == 0) /* implement default */
opts.read_write = DO_READ|DO_WRITE;
/* Mutually exclusive arguments. */
if((linebuf && opts.packet_bytes) ||
(opts.redir_stderr && !opts.use_stdio)) {
goto badarg;
}
/*
* Parse the first argument and start the appropriate driver.
*/
if (is_atom(name) || (i = is_string(name))) {
/* a vanilla port */
if (is_atom(name)) {
name_buf = (char *) erts_alloc(ERTS_ALC_T_TMP,
atom_tab(atom_val(name))->len+1);
sys_memcpy((void *) name_buf,
(void *) atom_tab(atom_val(name))->name,
atom_tab(atom_val(name))->len);
name_buf[atom_tab(atom_val(name))->len] = '\0';
} else {
name_buf = (char *) erts_alloc(ERTS_ALC_T_TMP, i + 1);
if (intlist_to_buf(name, name_buf, i) != i)
erts_exit(ERTS_ERROR_EXIT, "%s:%d: Internal error\n", __FILE__, __LINE__);
name_buf[i] = '\0';
}
driver = &vanilla_driver;
} else {
if (is_not_tuple(name)) {
goto badarg; /* Not a process or fd port */
}
tp = tuple_val(name);
arity = *tp++;
if (arity == make_arityval(0)) {
goto badarg;
}
if (*tp == am_spawn || *tp == am_spawn_driver || *tp == am_spawn_executable) { /* A process port */
int encoding;
if (arity != make_arityval(2)) {
goto badarg;
}
name = tp[1];
encoding = erts_get_native_filename_encoding();
/* Do not convert the command to utf-16le yet, do that in win32 specific code */
/* since the cmd is used for comparsion with drivers names and copied to port info */
if (encoding == ERL_FILENAME_WIN_WCHAR) {
encoding = ERL_FILENAME_UTF8;
}
if ((name_buf = erts_convert_filename_to_encoding(name, NULL, 0, ERTS_ALC_T_TMP,0,1, encoding, NULL, 0))
== NULL) {
goto badarg;
}
if (*tp == am_spawn_driver) {
opts.spawn_type = ERTS_SPAWN_DRIVER;
} else if (*tp == am_spawn_executable) {
opts.spawn_type = ERTS_SPAWN_EXECUTABLE;
}
driver = &spawn_driver;
} else if (*tp == am_fd) { /* An fd port */
int n;
struct Sint_buf sbuf;
char* p;
if (arity != make_arityval(3)) {
goto badarg;
}
if (is_not_small(tp[1]) || is_not_small(tp[2])) {
goto badarg;
}
opts.ifd = unsigned_val(tp[1]);
opts.ofd = unsigned_val(tp[2]);
/* Syntesize name from input and output descriptor. */
name_buf = erts_alloc(ERTS_ALC_T_TMP,
2*sizeof(struct Sint_buf) + 2);
p = Sint_to_buf(opts.ifd, &sbuf);
n = sys_strlen(p);
sys_strncpy(name_buf, p, n);
name_buf[n] = '/';
p = Sint_to_buf(opts.ofd, &sbuf);
sys_strcpy(name_buf+n+1, p);
driver = &fd_driver;
} else {
goto badarg;
}
}
if ((driver != &spawn_driver && opts.argv != NULL) ||
(driver == &spawn_driver &&
opts.spawn_type != ERTS_SPAWN_EXECUTABLE &&
opts.argv != NULL)) {
/* Argument vector only if explicit spawn_executable */
goto badarg;
}
if (edir != NIL) {
if ((opts.wd = erts_convert_filename_to_native(edir, NULL, 0, ERTS_ALC_T_TMP,0,1,NULL)) == NULL) {
goto badarg;
}
}
if (driver != &spawn_driver && opts.exit_status) {
goto badarg;
}
if (IS_TRACED_FL(p, F_TRACE_SCHED_PROCS)) {
trace_sched(p, ERTS_PROC_LOCK_MAIN, am_out);
}
erts_smp_proc_unlock(p, ERTS_PROC_LOCK_MAIN);
port = erts_open_driver(driver, p->common.id, name_buf, &opts, err_typep, err_nump);
#ifdef USE_VM_PROBES
if (port && DTRACE_ENABLED(port_open)) {
DTRACE_CHARBUF(process_str, DTRACE_TERM_BUF_SIZE);
DTRACE_CHARBUF(port_str, DTRACE_TERM_BUF_SIZE);
dtrace_proc_str(p, process_str);
erts_snprintf(port_str, sizeof(DTRACE_CHARBUF_NAME(port_str)), "%T", port->common.id);
DTRACE3(port_open, process_str, name_buf, port_str);
}
#endif
if (port && IS_TRACED_FL(port, F_TRACE_PORTS))
trace_port(port, am_getting_linked, p->common.id);
erts_smp_proc_lock(p, ERTS_PROC_LOCK_MAIN);
if (IS_TRACED_FL(p, F_TRACE_SCHED_PROCS)) {
trace_sched(p, ERTS_PROC_LOCK_MAIN, am_in);
}
if (!port) {
DEBUGF(("open_driver returned (%d:%d)\n",
err_typep ? *err_typep : 4711,
err_nump ? *err_nump : 4711));
goto do_return;
}
if (linebuf && port->linebuf == NULL){
port->linebuf = allocate_linebuf(linebuf);
sflgs |= ERTS_PORT_SFLG_LINEBUF_IO;
}
if (sflgs)
erts_atomic32_read_bor_relb(&port->state, sflgs);
do_return:
if (name_buf)
erts_free(ERTS_ALC_T_TMP, (void *) name_buf);
if (opts.argv) {
free_args(opts.argv);
}
if (opts.wd && opts.wd != ((char *)dir)) {
erts_free(ERTS_ALC_T_TMP, (void *) opts.wd);
}
return port;
badarg:
if (err_typep)
*err_typep = -3;
if (err_nump)
*err_nump = BADARG;
port = NULL;
goto do_return;
}
Uint
size_object(Eterm obj)
{
Uint sum = 0;
Eterm* ptr;
int arity;
DECLARE_ESTACK(s);
for (;;) {
switch (primary_tag(obj)) {
case TAG_PRIMARY_LIST:
sum += 2;
ptr = list_val(obj);
obj = *ptr++;
if (!IS_CONST(obj)) {
ESTACK_PUSH(s, obj);
}
obj = *ptr;
break;
case TAG_PRIMARY_BOXED:
{
Eterm hdr = *boxed_val(obj);
ASSERT(is_header(hdr));
switch (hdr & _TAG_HEADER_MASK) {
case ARITYVAL_SUBTAG:
ptr = tuple_val(obj);
arity = header_arity(hdr);
sum += arity + 1;
if (arity == 0) { /* Empty tuple -- unusual. */
goto pop_next;
}
while (arity-- > 1) {
obj = *++ptr;
if (!IS_CONST(obj)) {
ESTACK_PUSH(s, obj);
}
}
obj = *++ptr;
break;
case FUN_SUBTAG:
{
Eterm* bptr = fun_val(obj);
ErlFunThing* funp = (ErlFunThing *) bptr;
unsigned eterms = 1 /* creator */ + funp->num_free;
unsigned sz = thing_arityval(hdr);
sum += 1 /* header */ + sz + eterms;
bptr += 1 /* header */ + sz;
while (eterms-- > 1) {
obj = *bptr++;
if (!IS_CONST(obj)) {
ESTACK_PUSH(s, obj);
}
}
obj = *bptr;
break;
}
case SUB_BINARY_SUBTAG:
{
Eterm real_bin;
Uint offset; /* Not used. */
Uint bitsize;
Uint bitoffs;
Uint extra_bytes;
Eterm hdr;
ERTS_GET_REAL_BIN(obj, real_bin, offset, bitoffs, bitsize);
if ((bitsize + bitoffs) > 8) {
sum += ERL_SUB_BIN_SIZE;
extra_bytes = 2;
} else if ((bitsize + bitoffs) > 0) {
sum += ERL_SUB_BIN_SIZE;
extra_bytes = 1;
} else {
extra_bytes = 0;
}
hdr = *binary_val(real_bin);
if (thing_subtag(hdr) == REFC_BINARY_SUBTAG) {
sum += PROC_BIN_SIZE;
} else {
sum += heap_bin_size(binary_size(obj)+extra_bytes);
}
goto pop_next;
}
break;
case BIN_MATCHSTATE_SUBTAG:
erl_exit(ERTS_ABORT_EXIT,
"size_object: matchstate term not allowed");
default:
sum += thing_arityval(hdr) + 1;
goto pop_next;
}
}
break;
case TAG_PRIMARY_IMMED1:
pop_next:
if (ESTACK_ISEMPTY(s)) {
DESTROY_ESTACK(s);
return sum;
}
obj = ESTACK_POP(s);
break;
default:
erl_exit(ERTS_ABORT_EXIT, "size_object: bad tag for %#x\n", obj);
}
}
}
static void grow(Process *p)
{
unsigned int i,j;
unsigned int steps = p->dictionary->homeSize / 5;
Eterm l1,l2;
Eterm l;
Eterm *hp;
unsigned int pos;
unsigned int homeSize;
int needed = 0;
ProcDict *pd;
#ifdef DEBUG
Eterm *hp_limit;
#endif
HDEBUGF(("grow: steps = %d", steps));
if (steps == 0)
steps = 1;
/* Dont grow over MAX_HASH */
if ((MAX_HASH - steps) <= HASH_RANGE(p->dictionary)) {
return;
}
/*
* Calculate total number of heap words needed, and garbage collect
* if necessary.
*/
pd = p->dictionary;
pos = pd->splitPosition;
homeSize = pd->homeSize;
for (i = 0; i < steps; ++i) {
if (pos == homeSize) {
homeSize *= 2;
pos = 0;
}
l = ARRAY_GET(pd, pos);
pos++;
if (is_not_tuple(l)) {
while (l != NIL) {
needed += 2;
l = TCDR(l);
}
}
}
if (HeapWordsLeft(p) < needed) {
BUMP_REDS(p, erts_garbage_collect(p, needed, 0, 0));
}
#ifdef DEBUG
hp_limit = p->htop + needed;
#endif
/*
* Now grow.
*/
for (i = 0; i < steps; ++i) {
ProcDict *pd = p->dictionary;
if (pd->splitPosition == pd->homeSize) {
pd->homeSize *= 2;
pd->splitPosition = 0;
}
pos = pd->splitPosition;
++pd->splitPosition; /* For the hashes */
l = ARRAY_GET(pd, pos);
if (is_tuple(l)) {
if (pd_hash_value(pd, tuple_val(l)[1]) != pos) {
array_put(&(p->dictionary), pos +
p->dictionary->homeSize, l);
array_put(&(p->dictionary), pos, NIL);
}
} else {
l2 = NIL;
l1 = l;
for (j = 0; l1 != NIL; l1 = TCDR(l1))
j += 2;
hp = HeapOnlyAlloc(p, j);
while (l != NIL) {
if (pd_hash_value(pd, tuple_val(TCAR(l))[1]) == pos)
l1 = CONS(hp, TCAR(l), l1);
else
l2 = CONS(hp, TCAR(l), l2);
hp += 2;
l = TCDR(l);
}
if (l1 != NIL && TCDR(l1) == NIL)
l1 = TCAR(l1);
if (l2 != NIL && TCDR(l2) == NIL)
l2 = TCAR(l2);
ASSERT(hp <= hp_limit);
/* After array_put pd is no longer valid */
array_put(&(p->dictionary), pos, l1);
array_put(&(p->dictionary), pos +
p->dictionary->homeSize, l2);
}
}
#ifdef HARDDEBUG
dictionary_dump(p->dictionary,CERR);
#endif
}
static Eterm pd_hash_put(Process *p, Eterm id, Eterm value)
{
unsigned int hval;
Eterm *hp;
Eterm tpl;
Eterm old;
Eterm tmp;
int needed;
int i = 0;
#ifdef DEBUG
Eterm *hp_limit;
#endif
if (p->dictionary == NULL) {
/* Create it */
array_put(&(p->dictionary), INITIAL_SIZE - 1, NIL);
p->dictionary->homeSize = INITIAL_SIZE;
}
hval = pd_hash_value(p->dictionary, id);
old = ARRAY_GET(p->dictionary, hval);
/*
* Calculate the number of heap words needed and garbage
* collect if necessary. (Might be a slight overestimation.)
*/
needed = 3; /* {Key,Value} tuple */
if (is_boxed(old)) {
/*
* We don't want to compare keys twice, so we'll always
* reserve the space for two CONS cells.
*/
needed += 2+2;
} else if (is_list(old)) {
i = 0;
for (tmp = old; tmp != NIL && !EQ(tuple_val(TCAR(tmp))[1], id); tmp = TCDR(tmp)) {
++i;
}
if (is_nil(tmp)) {
i = -1;
needed += 2;
} else {
needed += 2*(i+1);
}
}
if (HeapWordsLeft(p) < needed) {
Eterm root[3];
root[0] = id;
root[1] = value;
root[2] = old;
BUMP_REDS(p, erts_garbage_collect(p, needed, root, 3));
id = root[0];
value = root[1];
old = root[2];
}
#ifdef DEBUG
hp_limit = p->htop + needed;
#endif
/*
* Create the {Key,Value} tuple.
*/
hp = HeapOnlyAlloc(p, 3);
tpl = TUPLE2(hp, id, value);
/*
* Update the dictionary.
*/
if (is_nil(old)) {
array_put(&(p->dictionary), hval, tpl);
++(p->dictionary->numElements);
} else if (is_boxed(old)) {
ASSERT(is_tuple(old));
if (EQ(tuple_val(old)[1],id)) {
array_put(&(p->dictionary), hval, tpl);
return tuple_val(old)[2];
} else {
hp = HeapOnlyAlloc(p, 4);
tmp = CONS(hp, old, NIL);
hp += 2;
++(p->dictionary->numElements);
array_put(&(p->dictionary), hval, CONS(hp, tpl, tmp));
hp += 2;
ASSERT(hp <= hp_limit);
}
} else if (is_list(old)) {
if (i == -1) {
/*
* New key. Simply prepend the tuple to the beginning of the list.
*/
hp = HeapOnlyAlloc(p, 2);
array_put(&(p->dictionary), hval, CONS(hp, tpl, old));
hp += 2;
ASSERT(hp <= hp_limit);
++(p->dictionary->numElements);
} else {
/*
* i = Number of CDRs to skip to reach the changed element in the list.
*
* Replace old value in list. To avoid pointers from the old generation
* to the new, we must rebuild the list from the beginning up to and
* including the changed element.
*/
Eterm nlist;
int j;
hp = HeapOnlyAlloc(p, (i+1)*2);
/* Find the list element to change. */
for (j = 0, nlist = old; j < i; j++, nlist = TCDR(nlist)) {
;
}
ASSERT(EQ(tuple_val(TCAR(nlist))[1], id));
nlist = TCDR(nlist); /* Unchanged part of list. */
/* Rebuild list before the updated element. */
for (tmp = old; i-- > 0; tmp = TCDR(tmp)) {
nlist = CONS(hp, TCAR(tmp), nlist);
hp += 2;
}
ASSERT(EQ(tuple_val(TCAR(tmp))[1], id));
/* Put the updated element first in the new list. */
nlist = CONS(hp, tpl, nlist);
hp += 2;
ASSERT(hp <= hp_limit);
array_put(&(p->dictionary), hval, nlist);
return tuple_val(TCAR(tmp))[2];
}
} else {
#ifdef DEBUG
erts_fprintf(stderr,
"Process dictionary for process %T is broken, trying to "
"display term found in line %d:\n"
"%T\n", p->common.id, __LINE__, old);
#endif
erl_exit(1, "Damaged process dictionary found during put/2.");
}
if (HASH_RANGE(p->dictionary) <= p->dictionary->numElements) {
grow(p);
}
return am_undefined;
}
BIF_RETTYPE
erts_debug_disassemble_1(BIF_ALIST_1)
{
Process* p = BIF_P;
Eterm addr = BIF_ARG_1;
erts_dsprintf_buf_t *dsbufp;
Eterm* hp;
Eterm* tp;
Eterm bin;
Eterm mfa;
ErtsCodeMFA *cmfa = NULL;
BeamCodeHeader* code_hdr;
BeamInstr *code_ptr;
BeamInstr instr;
BeamInstr uaddr;
Uint hsz;
int i;
if (term_to_UWord(addr, &uaddr)) {
code_ptr = (BeamInstr *) uaddr;
if ((cmfa = find_function_from_pc(code_ptr)) == NULL) {
BIF_RET(am_false);
}
} else if (is_tuple(addr)) {
ErtsCodeIndex code_ix;
Module* modp;
Eterm mod;
Eterm name;
Export* ep;
Sint arity;
int n;
tp = tuple_val(addr);
if (tp[0] != make_arityval(3)) {
error:
BIF_ERROR(p, BADARG);
}
mod = tp[1];
name = tp[2];
if (!is_atom(mod) || !is_atom(name) || !is_small(tp[3])) {
goto error;
}
arity = signed_val(tp[3]);
code_ix = erts_active_code_ix();
modp = erts_get_module(mod, code_ix);
/*
* Try the export entry first to allow disassembly of special functions
* such as erts_debug:apply/4. Then search for it in the module.
*/
if ((ep = erts_find_function(mod, name, arity, code_ix)) != NULL) {
/* XXX: add "&& ep->address != ep->code" condition?
* Consider a traced function.
* Its ep will have ep->address == ep->code.
* erts_find_function() will return the non-NULL ep.
* Below we'll try to derive a code_ptr from ep->address.
* But this code_ptr will point to the start of the Export,
* not the function's func_info instruction. BOOM !?
*/
cmfa = erts_code_to_codemfa(ep->addressv[code_ix]);
} else if (modp == NULL || (code_hdr = modp->curr.code_hdr) == NULL) {
BIF_RET(am_undef);
} else {
n = code_hdr->num_functions;
for (i = 0; i < n; i++) {
cmfa = &code_hdr->functions[i]->mfa;
if (cmfa->function == name && cmfa->arity == arity) {
break;
}
}
if (i == n) {
BIF_RET(am_undef);
}
}
code_ptr = (BeamInstr*)erts_code_to_codeinfo(erts_codemfa_to_code(cmfa));
} else {
goto error;
}
dsbufp = erts_create_tmp_dsbuf(0);
erts_print(ERTS_PRINT_DSBUF, (void *) dsbufp, HEXF ": ", code_ptr);
instr = (BeamInstr) code_ptr[0];
for (i = 0; i < NUM_SPECIFIC_OPS; i++) {
if (BeamIsOpCode(instr, i) && opc[i].name[0] != '\0') {
code_ptr += print_op(ERTS_PRINT_DSBUF, (void *) dsbufp,
i, opc[i].sz-1, code_ptr) + 1;
break;
}
}
if (i >= NUM_SPECIFIC_OPS) {
erts_print(ERTS_PRINT_DSBUF, (void *) dsbufp,
"unknown " HEXF "\n", instr);
code_ptr++;
}
bin = new_binary(p, (byte *) dsbufp->str, dsbufp->str_len);
erts_destroy_tmp_dsbuf(dsbufp);
hsz = 4+4;
(void) erts_bld_uword(NULL, &hsz, (BeamInstr) code_ptr);
hp = HAlloc(p, hsz);
addr = erts_bld_uword(&hp, NULL, (BeamInstr) code_ptr);
ASSERT(is_atom(cmfa->module) || is_nil(cmfa->module));
ASSERT(is_atom(cmfa->function) || is_nil(cmfa->function));
mfa = TUPLE3(hp, cmfa->module, cmfa->function,
make_small(cmfa->arity));
hp += 4;
return TUPLE3(hp, addr, bin, mfa);
}
static int
pdisplay1(fmtfn_t to, void *to_arg, Process* p, Eterm obj)
{
int i, k;
Eterm* nobj;
if (dcount-- <= 0)
return(1);
if (is_CP(obj)) {
erts_print(to, to_arg, "<cp/header:%0*lX",PTR_SIZE,obj);
return 0;
}
switch (tag_val_def(obj)) {
case NIL_DEF:
erts_print(to, to_arg, "[]");
break;
case ATOM_DEF:
erts_print(to, to_arg, "%T", obj);
break;
case SMALL_DEF:
erts_print(to, to_arg, "%ld", signed_val(obj));
break;
case BIG_DEF:
nobj = big_val(obj);
if (!IN_HEAP(p, nobj)) {
erts_print(to, to_arg, "#<bad big %X>#", obj);
return 1;
}
i = BIG_SIZE(nobj);
if (BIG_SIGN(nobj))
erts_print(to, to_arg, "-#integer(%d) = {", i);
else
erts_print(to, to_arg, "#integer(%d) = {", i);
erts_print(to, to_arg, "%d", BIG_DIGIT(nobj, 0));
for (k = 1; k < i; k++)
erts_print(to, to_arg, ",%d", BIG_DIGIT(nobj, k));
erts_putc(to, to_arg, '}');
break;
case REF_DEF:
case EXTERNAL_REF_DEF: {
Uint32 *ref_num;
erts_print(to, to_arg, "#Ref<%lu", ref_channel_no(obj));
ref_num = ref_numbers(obj);
for (i = ref_no_numbers(obj)-1; i >= 0; i--)
erts_print(to, to_arg, ",%lu", ref_num[i]);
erts_print(to, to_arg, ">");
break;
}
case PID_DEF:
case EXTERNAL_PID_DEF:
erts_print(to, to_arg, "<%lu.%lu.%lu>",
pid_channel_no(obj),
pid_number(obj),
pid_serial(obj));
break;
case PORT_DEF:
case EXTERNAL_PORT_DEF:
erts_print(to, to_arg, "#Port<%lu.%lu>",
port_channel_no(obj),
port_number(obj));
break;
case LIST_DEF:
erts_putc(to, to_arg, '[');
nobj = list_val(obj);
while (1) {
if (!IN_HEAP(p, nobj)) {
erts_print(to, to_arg, "#<bad list %X>", obj);
return 1;
}
if (pdisplay1(to, to_arg, p, *nobj++) != 0)
return(1);
if (is_not_list(*nobj))
break;
erts_putc(to, to_arg, ',');
nobj = list_val(*nobj);
}
if (is_not_nil(*nobj)) {
erts_putc(to, to_arg, '|');
if (pdisplay1(to, to_arg, p, *nobj) != 0)
return(1);
}
erts_putc(to, to_arg, ']');
break;
case TUPLE_DEF:
nobj = tuple_val(obj); /* pointer to arity */
i = arityval(*nobj); /* arity */
erts_putc(to, to_arg, '{');
while (i--) {
if (pdisplay1(to, to_arg, p, *++nobj) != 0) return(1);
if (i >= 1) erts_putc(to, to_arg, ',');
}
erts_putc(to, to_arg, '}');
break;
case FLOAT_DEF: {
FloatDef ff;
GET_DOUBLE(obj, ff);
erts_print(to, to_arg, "%.20e", ff.fd);
}
break;
case BINARY_DEF:
erts_print(to, to_arg, "#Bin");
break;
case MATCHSTATE_DEF:
erts_print(to, to_arg, "#Matchstate");
break;
default:
erts_print(to, to_arg, "unknown object %x", obj);
}
return(0);
}
static int
print_op(fmtfn_t to, void *to_arg, int op, int size, BeamInstr* addr)
{
int i;
BeamInstr tag;
char* sign;
char* start_prog; /* Start of program for packer. */
char* prog; /* Current position in packer program. */
BeamInstr stack[8]; /* Stack for packer. */
BeamInstr* sp = stack; /* Points to next free position. */
BeamInstr packed = 0; /* Accumulator for packed operations. */
BeamInstr args[8]; /* Arguments for this instruction. */
BeamInstr* ap; /* Pointer to arguments. */
BeamInstr* unpacked; /* Unpacked arguments */
BeamInstr* first_arg; /* First argument */
start_prog = opc[op].pack;
if (start_prog[0] == '\0') {
/*
* There is no pack program.
* Avoid copying because instructions containing bignum operands
* are bigger than actually declared.
*/
addr++;
ap = addr;
} else {
#if defined(ARCH_64) && defined(CODE_MODEL_SMALL)
BeamInstr instr_word = addr[0];
#endif
addr++;
/*
* Copy all arguments to a local buffer for the unpacking.
*/
ASSERT(size <= sizeof(args)/sizeof(args[0]));
ap = args;
for (i = 0; i < size; i++) {
*ap++ = addr[i];
}
/*
* Undo any packing done by the loader. This is easily done by running
* the packing program backwards and in reverse.
*/
prog = start_prog + sys_strlen(start_prog);
while (start_prog < prog) {
prog--;
switch (*prog) {
case 'f':
case 'g':
case 'q':
*ap++ = *--sp;
break;
#ifdef ARCH_64
case '1': /* Tightest shift */
*ap++ = (packed & BEAM_TIGHTEST_MASK) << 3;
packed >>= BEAM_TIGHTEST_SHIFT;
break;
#endif
case '2': /* Tight shift */
*ap++ = packed & BEAM_TIGHT_MASK;
packed >>= BEAM_TIGHT_SHIFT;
break;
case '3': /* Loose shift */
*ap++ = packed & BEAM_LOOSE_MASK;
packed >>= BEAM_LOOSE_SHIFT;
break;
#ifdef ARCH_64
case '4': /* Shift 32 steps */
*ap++ = packed & BEAM_WIDE_MASK;
packed >>= BEAM_WIDE_SHIFT;
break;
#endif
case 'p':
*sp++ = *--ap;
break;
case 'P':
packed = *--sp;
break;
#if defined(ARCH_64) && defined(CODE_MODEL_SMALL)
case '#': /* -1 */
case '$': /* -2 */
case '%': /* -3 */
case '&': /* -4 */
case '\'': /* -5 */
case '(': /* -6 */
packed = (packed << BEAM_WIDE_SHIFT) | BeamExtraData(instr_word);
break;
#endif
default:
erts_exit(ERTS_ERROR_EXIT, "beam_debug: invalid packing op: %c\n", *prog);
}
}
ap = args;
}
first_arg = ap;
/*
* Print the name and all operands of the instructions.
*/
erts_print(to, to_arg, "%s ", opc[op].name);
sign = opc[op].sign;
while (*sign) {
switch (*sign) {
case 'r': /* x(0) */
erts_print(to, to_arg, "r(0)");
break;
case 'x': /* x(N) */
{
Uint n = ap[0] / sizeof(Eterm);
erts_print(to, to_arg, "x(%d)", n);
ap++;
}
break;
case 'y': /* y(N) */
{
Uint n = ap[0] / sizeof(Eterm) - CP_SIZE;
erts_print(to, to_arg, "y(%d)", n);
ap++;
}
break;
case 'n': /* Nil */
erts_print(to, to_arg, "[]");
break;
case 'S': /* Register */
{
Uint reg_type = (*ap & 1) ? 'y' : 'x';
Uint n = ap[0] / sizeof(Eterm);
erts_print(to, to_arg, "%c(%d)", reg_type, n);
ap++;
break;
}
case 's': /* Any source (tagged constant or register) */
tag = loader_tag(*ap);
if (tag == LOADER_X_REG) {
erts_print(to, to_arg, "x(%d)", loader_x_reg_index(*ap));
ap++;
break;
} else if (tag == LOADER_Y_REG) {
erts_print(to, to_arg, "y(%d)", loader_y_reg_index(*ap) - CP_SIZE);
ap++;
break;
}
/*FALLTHROUGH*/
case 'a': /* Tagged atom */
case 'i': /* Tagged integer */
case 'c': /* Tagged constant */
case 'q': /* Tagged literal */
erts_print(to, to_arg, "%T", (Eterm) *ap);
ap++;
break;
case 'A':
erts_print(to, to_arg, "%d", arityval( (Eterm) ap[0]));
ap++;
break;
case 'd': /* Destination (x(0), x(N), y(N)) */
if (*ap & 1) {
erts_print(to, to_arg, "y(%d)",
*ap / sizeof(Eterm) - CP_SIZE);
} else {
erts_print(to, to_arg, "x(%d)",
*ap / sizeof(Eterm));
}
ap++;
break;
case 't': /* Untagged integers */
case 'I':
case 'W':
switch (op) {
case op_i_gc_bif1_jWstd:
case op_i_gc_bif2_jWtssd:
case op_i_gc_bif3_jWtssd:
{
const ErtsGcBif* p;
BifFunction gcf = (BifFunction) *ap;
for (p = erts_gc_bifs; p->bif != 0; p++) {
if (p->gc_bif == gcf) {
print_bif_name(to, to_arg, p->bif);
break;
}
}
if (p->bif == 0) {
erts_print(to, to_arg, "%d", (Uint)gcf);
}
break;
}
case op_i_make_fun_Wt:
if (*sign == 'W') {
ErlFunEntry* fe = (ErlFunEntry *) *ap;
ErtsCodeMFA* cmfa = find_function_from_pc(fe->address);
erts_print(to, to_arg, "%T:%T/%bpu", cmfa->module,
cmfa->function, cmfa->arity);
} else {
erts_print(to, to_arg, "%d", *ap);
}
break;
case op_i_bs_match_string_xfWW:
if (ap - first_arg < 3) {
erts_print(to, to_arg, "%d", *ap);
} else {
Uint bits = ap[-1];
Uint bytes = (bits+7)/8;
byte* str = (byte *) *ap;
print_byte_string(to, to_arg, str, bytes);
}
break;
case op_bs_put_string_WW:
if (ap - first_arg == 0) {
erts_print(to, to_arg, "%d", *ap);
} else {
Uint bytes = ap[-1];
byte* str = (byte *) ap[0];
print_byte_string(to, to_arg, str, bytes);
}
break;
default:
erts_print(to, to_arg, "%d", *ap);
}
ap++;
break;
case 'f': /* Destination label */
switch (op) {
case op_catch_yf:
erts_print(to, to_arg, "f(" HEXF ")", catch_pc((BeamInstr)*ap));
break;
default:
{
BeamInstr* target = f_to_addr(addr, op, ap);
ErtsCodeMFA* cmfa = find_function_from_pc(target);
if (!cmfa || erts_codemfa_to_code(cmfa) != target) {
erts_print(to, to_arg, "f(" HEXF ")", target);
} else {
erts_print(to, to_arg, "%T:%T/%bpu", cmfa->module,
cmfa->function, cmfa->arity);
}
ap++;
}
break;
}
break;
case 'p': /* Pointer (to label) */
{
BeamInstr* target = f_to_addr(addr, op, ap);
erts_print(to, to_arg, "p(" HEXF ")", target);
ap++;
}
break;
case 'j': /* Pointer (to label) */
if (*ap == 0) {
erts_print(to, to_arg, "j(0)");
} else {
BeamInstr* target = f_to_addr(addr, op, ap);
erts_print(to, to_arg, "j(" HEXF ")", target);
}
ap++;
break;
case 'e': /* Export entry */
{
Export* ex = (Export *) *ap;
erts_print(to, to_arg,
"%T:%T/%bpu", (Eterm) ex->info.mfa.module,
(Eterm) ex->info.mfa.function,
ex->info.mfa.arity);
ap++;
}
break;
case 'F': /* Function definition */
break;
case 'b':
print_bif_name(to, to_arg, (BifFunction) *ap);
ap++;
break;
case 'P': /* Byte offset into tuple (see beam_load.c) */
case 'Q': /* Like 'P', but packable */
erts_print(to, to_arg, "%d", (*ap / sizeof(Eterm)) - 1);
ap++;
break;
case 'l': /* fr(N) */
erts_print(to, to_arg, "fr(%d)", loader_reg_index(ap[0]));
ap++;
break;
default:
erts_print(to, to_arg, "???");
ap++;
break;
}
erts_print(to, to_arg, " ");
sign++;
}
/*
* Print more information about certain instructions.
*/
unpacked = ap;
ap = addr + size;
/*
* In the code below, never use ap[-1], ap[-2], ...
* (will not work if the arguments have been packed).
*
* Instead use unpacked[-1], unpacked[-2], ...
*/
switch (op) {
case op_i_select_val_lins_xfI:
case op_i_select_val_lins_yfI:
case op_i_select_val_bins_xfI:
case op_i_select_val_bins_yfI:
{
int n = unpacked[-1];
int ix = n;
Sint32* jump_tab = (Sint32 *)(ap + n);
while (ix--) {
erts_print(to, to_arg, "%T ", (Eterm) ap[0]);
ap++;
size++;
}
ix = n;
while (ix--) {
BeamInstr* target = f_to_addr_packed(addr, op, jump_tab);
erts_print(to, to_arg, "f(" HEXF ") ", target);
jump_tab++;
}
size += (n+1) / 2;
}
break;
case op_i_select_tuple_arity_xfI:
case op_i_select_tuple_arity_yfI:
{
int n = unpacked[-1];
int ix = n - 1; /* without sentinel */
Sint32* jump_tab = (Sint32 *)(ap + n);
while (ix--) {
Uint arity = arityval(ap[0]);
erts_print(to, to_arg, "{%d} ", arity, ap[1]);
ap++;
size++;
}
/* print sentinel */
erts_print(to, to_arg, "{%T} ", ap[0], ap[1]);
ap++;
size++;
ix = n;
while (ix--) {
BeamInstr* target = f_to_addr_packed(addr, op, jump_tab);
erts_print(to, to_arg, "f(" HEXF ") ", target);
jump_tab++;
}
size += (n+1) / 2;
}
break;
case op_i_select_val2_xfcc:
case op_i_select_val2_yfcc:
case op_i_select_tuple_arity2_xfAA:
case op_i_select_tuple_arity2_yfAA:
{
Sint32* jump_tab = (Sint32 *) ap;
BeamInstr* target;
int i;
for (i = 0; i < 2; i++) {
target = f_to_addr_packed(addr, op, jump_tab++);
erts_print(to, to_arg, "f(" HEXF ") ", target);
}
size += 1;
}
break;
case op_i_jump_on_val_xfIW:
case op_i_jump_on_val_yfIW:
{
int n = unpacked[-2];
Sint32* jump_tab = (Sint32 *) ap;
size += (n+1) / 2;
while (n-- > 0) {
BeamInstr* target = f_to_addr_packed(addr, op, jump_tab);
erts_print(to, to_arg, "f(" HEXF ") ", target);
jump_tab++;
}
}
break;
case op_i_jump_on_val_zero_xfI:
case op_i_jump_on_val_zero_yfI:
{
int n = unpacked[-1];
Sint32* jump_tab = (Sint32 *) ap;
size += (n+1) / 2;
while (n-- > 0) {
BeamInstr* target = f_to_addr_packed(addr, op, jump_tab);
erts_print(to, to_arg, "f(" HEXF ") ", target);
jump_tab++;
}
}
break;
case op_i_put_tuple_xI:
case op_i_put_tuple_yI:
case op_new_map_dtI:
case op_update_map_assoc_sdtI:
case op_update_map_exact_jsdtI:
{
int n = unpacked[-1];
while (n > 0) {
switch (loader_tag(ap[0])) {
case LOADER_X_REG:
erts_print(to, to_arg, " x(%d)", loader_x_reg_index(ap[0]));
break;
case LOADER_Y_REG:
erts_print(to, to_arg, " y(%d)", loader_y_reg_index(ap[0]) - CP_SIZE);
break;
default:
erts_print(to, to_arg, " %T", (Eterm) ap[0]);
break;
}
ap++, size++, n--;
}
}
break;
case op_i_new_small_map_lit_dtq:
{
Eterm *tp = tuple_val(unpacked[-1]);
int n = arityval(*tp);
while (n > 0) {
switch (loader_tag(ap[0])) {
case LOADER_X_REG:
erts_print(to, to_arg, " x(%d)", loader_x_reg_index(ap[0]));
break;
case LOADER_Y_REG:
erts_print(to, to_arg, " y(%d)", loader_y_reg_index(ap[0]) - CP_SIZE);
break;
default:
erts_print(to, to_arg, " %T", (Eterm) ap[0]);
break;
}
ap++, size++, n--;
}
}
break;
case op_i_get_map_elements_fsI:
{
int n = unpacked[-1];
while (n > 0) {
if (n % 3 == 1) {
erts_print(to, to_arg, " %X", ap[0]);
} else {
switch (loader_tag(ap[0])) {
case LOADER_X_REG:
erts_print(to, to_arg, " x(%d)", loader_x_reg_index(ap[0]));
break;
case LOADER_Y_REG:
erts_print(to, to_arg, " y(%d)", loader_y_reg_index(ap[0]) - CP_SIZE);
break;
default:
erts_print(to, to_arg, " %T", (Eterm) ap[0]);
break;
}
}
ap++, size++, n--;
}
}
break;
}
erts_print(to, to_arg, "\n");
return size;
}