The R13B03 release.OTP_R13B03

1 files changed, 548 insertions, 0 deletions

diff --git a/erts/emulator/beam/beam_debug.c b/erts/emulator/beam/beam_debug.c
new file mode 100644
index 0000000000..4242a4161e
--- /dev/null
+++ b/erts/emulator/beam/beam_debug.c
@@ -0,0 +1,548 @@
+/*
+ * %CopyrightBegin%
+ * 
+ * Copyright Ericsson AB 1998-2009. All Rights Reserved.
+ * 
+ * The contents of this file are subject to the Erlang Public License,
+ * Version 1.1, (the "License"); you may not use this file except in
+ * compliance with the License. You should have received a copy of the
+ * Erlang Public License along with this software. If not, it can be
+ * retrieved online at http://www.erlang.org/.
+ * 
+ * Software distributed under the License is distributed on an "AS IS"
+ * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+ * the License for the specific language governing rights and limitations
+ * under the License.
+ * 
+ * %CopyrightEnd%
+ */
+
+/*
+ * Purpose: Basic debugging support.
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include "config.h"
+#endif
+
+#include "sys.h"
+#include "erl_vm.h"
+#include "global.h"
+#include "erl_process.h"
+#include "error.h"
+#include "erl_driver.h"
+#include "bif.h"
+#include "big.h"
+#include "external.h"
+#include "beam_load.h"
+#include "beam_bp.h"
+#include "erl_binary.h"
+
+#ifdef ARCH_64
+# define HEXF "%016bpX"
+#else
+# define HEXF "%08bpX"
+#endif
+
+void dbg_bt(Process* p, Eterm* sp);
+void dbg_where(Eterm* addr, Eterm x0, Eterm* reg);
+
+static void print_big(int to, void *to_arg, Eterm* addr);
+static int print_op(int to, void *to_arg, int op, int size, Eterm* addr);
+Eterm
+erts_debug_same_2(Process* p, Eterm term1, Eterm term2)
+{
+    return (term1 == term2) ? am_true : am_false;
+}
+
+Eterm
+erts_debug_flat_size_1(Process* p, Eterm term)
+{
+    Uint size = size_object(term);
+
+    if (IS_USMALL(0, size)) {
+	BIF_RET(make_small(size));
+    } else {
+	Eterm* hp = HAlloc(p, BIG_UINT_HEAP_SIZE);
+	BIF_RET(uint_to_big(size, hp));
+    }
+}
+
+Eterm
+erts_debug_breakpoint_2(Process* p, Eterm MFA, Eterm bool)
+{
+    Eterm* tp;
+    Eterm mfa[3];
+    int i;
+    int specified = 0;
+    Eterm res;
+
+    if (bool != am_true && bool != am_false)
+	goto error;
+
+    if (is_not_tuple(MFA)) {
+	goto error;
+    }
+    tp = tuple_val(MFA);
+    if (*tp != make_arityval(3)) {
+	goto error;
+    }
+    mfa[0] = tp[1];
+    mfa[1] = tp[2];
+    mfa[2] = tp[3];
+    if (!is_atom(mfa[0]) || !is_atom(mfa[1]) ||
+	(!is_small(mfa[2]) && mfa[2] != am_Underscore)) {
+	goto error;
+    }
+    for (i = 0; i < 3 && mfa[i] != am_Underscore; i++, specified++) {
+	/* Empty loop body */
+    }
+    for (i = specified; i < 3; i++) {
+	if (mfa[i] != am_Underscore) {
+	    goto error;
+	}
+    }
+    if (is_small(mfa[2])) {
+	mfa[2] = signed_val(mfa[2]);
+    }
+
+    erts_smp_proc_unlock(p, ERTS_PROC_LOCK_MAIN);
+    erts_smp_block_system(0);
+
+    if (bool == am_true) {
+	res = make_small(erts_set_debug_break(mfa, specified));
+    } else {
+	res = make_small(erts_clear_debug_break(mfa, specified));
+    }
+
+    erts_smp_release_system();
+    erts_smp_proc_lock(p, ERTS_PROC_LOCK_MAIN);
+
+    return res;
+
+ error:
+    BIF_ERROR(p, BADARG);
+}
+
+Eterm
+erts_debug_disassemble_1(Process* p, Eterm addr)
+{
+    erts_dsprintf_buf_t *dsbufp;
+    Eterm* hp;
+    Eterm* tp;
+    Eterm bin;
+    Eterm mfa;
+    Eterm* funcinfo = NULL;	/* Initialized to eliminate warning. */
+    Uint* code_base;
+    Uint* code_ptr = NULL;	/* Initialized to eliminate warning. */
+    Uint instr;
+    Uint uaddr;
+    Uint hsz;
+    int i;
+
+    if (term_to_Uint(addr, &uaddr)) {
+	code_ptr = (Uint *) uaddr;
+	if ((funcinfo = find_function_from_pc(code_ptr)) == NULL) {
+	    BIF_RET(am_false);
+	}
+    } else if (is_tuple(addr)) {
+	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]);
+	modp = erts_get_module(mod);
+
+	/*
+	 * 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)) != NULL) {
+	    /* XXX: add "&& ep->address != ep->code+3" condition?
+	     * Consider a traced function.
+	     * Its ep will have ep->address == ep->code+3.
+	     * 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 !?
+	     */
+	    code_ptr = ((Eterm *) ep->address) - 5;
+	    funcinfo = code_ptr+2;
+	} else if (modp == NULL || (code_base = modp->code) == NULL) {
+	    BIF_RET(am_undef);
+	} else {
+	    n = code_base[MI_NUM_FUNCTIONS];
+	    for (i = 0; i < n; i++) {
+		code_ptr = (Uint *) code_base[MI_FUNCTIONS+i];
+		if (code_ptr[3] == name && code_ptr[4] == arity) {
+		    funcinfo = code_ptr+2;
+		    break;
+		}
+	    }
+	    if (i == n) {
+		BIF_RET(am_undef);
+	    }
+	}
+    } else {
+	goto error;
+    }
+
+    dsbufp = erts_create_tmp_dsbuf(0);
+    erts_print(ERTS_PRINT_DSBUF, (void *) dsbufp, HEXF ": ", code_ptr);
+    instr = (Uint) code_ptr[0];
+    for (i = 0; i < NUM_SPECIFIC_OPS; i++) {
+	if (instr == (Uint) BeamOp(i) && opc[i].name[0] != '\0') {
+	    code_ptr += print_op(ERTS_PRINT_DSBUF, (void *) dsbufp,
+				 i, opc[i].sz-1, code_ptr+1) + 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, (int) dsbufp->str_len);
+    erts_destroy_tmp_dsbuf(dsbufp);
+    hsz = 4+4;
+    (void) erts_bld_uint(NULL, &hsz, (Uint) code_ptr);
+    hp = HAlloc(p, hsz);
+    addr = erts_bld_uint(&hp, NULL, (Uint) code_ptr);
+    ASSERT(is_atom(funcinfo[0]));
+    ASSERT(is_atom(funcinfo[1]));
+    mfa = TUPLE3(hp, funcinfo[0], funcinfo[1], make_small(funcinfo[2]));
+    hp += 4;
+    return TUPLE3(hp, addr, bin, mfa);
+}
+
+void
+dbg_bt(Process* p, Eterm* sp)
+{
+    Eterm* stack = STACK_START(p);
+
+    while (sp < stack) {
+	if (is_CP(*sp)) {
+	    Eterm* addr = find_function_from_pc(cp_val(*sp));
+	    if (addr)
+		erts_fprintf(stderr,
+			     HEXF ": %T:%T/%bpu\n",
+			     addr, addr[0], addr[1], addr[2]);
+	}
+	sp++;
+    }
+}
+
+void
+dbg_where(Eterm* addr, Eterm x0, Eterm* reg)
+{
+    Eterm* f = find_function_from_pc(addr);
+
+    if (f == NULL) {
+	erts_fprintf(stderr, "???\n");
+    } else {
+	int arity;
+	int i;
+
+	addr = f;
+	arity = addr[2];
+	erts_fprintf(stderr, HEXF ": %T:%T(", addr, addr[0], addr[1]);
+	for (i = 0; i < arity; i++)
+	    erts_fprintf(stderr, i ? ", %T" : "%T", i ? reg[i] : x0);
+	erts_fprintf(stderr, ")\n");
+    }
+}
+
+static int
+print_op(int to, void *to_arg, int op, int size, Eterm* addr)
+{
+    int i;
+    Uint tag;
+    char* sign;
+    char* start_prog;		/* Start of program for packer. */
+    char* prog;			/* Current position in packer program. */
+    Uint stack[8];		/* Stack for packer. */
+    Uint* sp = stack;		/* Points to next free position. */
+    Uint packed = 0;		/* Accumulator for packed operations. */
+    Uint args[8];		/* Arguments for this instruction. */
+    Uint* ap;			/* Pointer to arguments. */
+
+    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.
+	 */
+	ap = (Uint *) addr;
+    } else {
+	/*
+	 * 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 + strlen(start_prog);
+	while (start_prog < prog) {
+	    prog--;
+	    switch (*prog) {
+	    case 'g':
+		*ap++ = *--sp;
+		break;
+	    case 'i':		/* Initialize packing accumulator. */
+		*ap++ = packed;
+		break;
+	    case 's':
+		*ap++ = packed & 0x3ff;
+		packed >>= 10;
+		break;
+	    case '0':		/* Tight shift */
+		*ap++ = packed & (BEAM_TIGHT_MASK / sizeof(Eterm));
+		packed >>= BEAM_TIGHT_SHIFT;
+		break;
+	    case '6':		/* Shift 16 steps */
+		*ap++ = packed & 0xffff;
+		packed >>= 16;
+		break;
+	    case 'p':
+		*sp++ = *--ap;
+		break;
+	    case 'P':
+		packed = *--sp;
+		break;
+	    default:
+		ASSERT(0);
+	    }
+	}
+	ap = args;
+    }
+
+    /*
+     * 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, "x(0)");
+	    break;
+	case 'x':		/* x(N) */
+	    if (reg_index(ap[0]) == 0) {
+		erts_print(to, to_arg, "X[0]");
+	    } else {
+		erts_print(to, to_arg, "x(%d)", reg_index(ap[0]));
+	    }
+	    ap++;
+	    break;
+	case 'y':		/* y(N) */
+	    erts_print(to, to_arg, "y(%d)", reg_index(ap[0]) - CP_SIZE);
+	    ap++;
+	    break;
+	case 'n':		/* Nil */
+	    erts_print(to, to_arg, "[]");
+	    break;
+	case 's':		/* Any source (tagged constant or register) */
+	    tag = beam_reg_tag(*ap);
+	    if (tag == X_REG_DEF) {
+		if (reg_index(*ap) == 0) {
+		    erts_print(to, to_arg, "x[0]");
+		} else {
+		    erts_print(to, to_arg, "x(%d)", reg_index(*ap));
+		}
+		ap++;
+		break;
+	    } else if (tag == Y_REG_DEF) {
+		erts_print(to, to_arg, "y(%d)", reg_index(*ap) - CP_SIZE);
+		ap++;
+		break;
+	    } else if (tag == R_REG_DEF) {
+		erts_print(to, to_arg, "x(0)");
+		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", *ap);
+	    ap++;
+	    break;
+	case 'A':
+	    erts_print(to, to_arg, "%d", arityval(ap[0]));
+	    ap++;
+	    break;
+	case 'd':		/* Destination (x(0), x(N), y(N)) */
+	    switch (beam_reg_tag(*ap)) {
+	    case X_REG_DEF:
+		if (reg_index(*ap) == 0) {
+		    erts_print(to, to_arg, "x[0]");
+		} else {
+		    erts_print(to, to_arg, "x(%d)", reg_index(*ap));
+		}
+		break;
+	    case Y_REG_DEF:
+		erts_print(to, to_arg, "y(%d)", reg_index(*ap) - CP_SIZE);
+		break;
+	    case R_REG_DEF:
+		erts_print(to, to_arg, "x(0)");
+		break;
+	    }
+	    ap++;
+	    break;
+	case 'I':		/* Untagged integer. */
+	case 't':
+	    erts_print(to, to_arg, "%d", *ap);
+	    ap++;
+	    break;
+	case 'f':		/* Destination label */
+	    erts_print(to, to_arg, "f(%X)", *ap);
+	    ap++;
+	    break;
+	case 'p':		/* Pointer (to label) */
+	    {
+		Eterm* f = find_function_from_pc((Eterm *)*ap);
+
+		if (f+3 != (Eterm *) *ap) {
+		    erts_print(to, to_arg, "p(%X)", *ap);
+		} else {
+		    erts_print(to, to_arg, "%T:%T/%bpu", f[0], f[1], f[2]);
+		}
+		ap++;
+	    }
+	    break;
+	case 'j':		/* Pointer (to label) */
+	    erts_print(to, to_arg, "j(%X)", *ap);
+	    ap++;
+	    break;
+	case 'e':		/* Export entry */
+	    {
+		Export* ex = (Export *) *ap;
+		erts_print(to, to_arg,
+			   "%T:%T/%bpu", ex->code[0], ex->code[1], ex->code[2]);
+		ap++;
+	    }
+	    break;
+	case 'F':		/* Function definition */
+	    break;
+	case 'b':
+	    for (i = 0; i < BIF_SIZE; i++) {
+		BifFunction bif = (BifFunction) *ap;
+		if (bif == bif_table[i].f) {
+		    break;
+		}
+	    }
+	    if (i == BIF_SIZE) {
+		erts_print(to, to_arg, "b(%d)", (Uint) *ap);
+	    } else {
+		Eterm name = bif_table[i].name;
+		unsigned arity = bif_table[i].arity;
+		erts_print(to, to_arg, "%T/%u", name, arity);
+	    }
+	    ap++;
+	    break;
+	case 'P':	/* Byte offset into tuple (see beam_load.c) */
+	    erts_print(to, to_arg, "%d", (*ap / sizeof(Eterm*)) - 1);
+	    ap++;
+	    break;
+	case 'l':		/* fr(N) */
+	    erts_print(to, to_arg, "fr(%d)", 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.
+     */
+
+    ap = addr + size;
+    switch (op) {
+    case op_i_select_val_sfI:
+	{
+	    int n = ap[-1];
+
+	    while (n > 0) {
+		erts_print(to, to_arg, "%T f(%X) ", ap[0], ap[1]);
+		ap += 2;
+		size += 2;
+		n--;
+	    }
+	}
+	break;
+    case op_i_jump_on_val_sfII:
+	{
+	    int n;
+	    for (n = ap[-2]; n > 0; n--) {
+		erts_print(to, to_arg, "f(%X) ", ap[0]);
+		ap++;
+		size++;
+	    }
+	}
+	break;
+    case op_i_select_big_sf:
+	while (ap[0]) {
+	    int arity = thing_arityval(ap[0]);
+	    print_big(to, to_arg, ap);
+	    size += arity+1;
+	    ap += arity+1;
+	    erts_print(to, to_arg, " f(%X) ", ap[0]);
+	    ap++;
+	    size++;
+	}
+	ap++;
+	size++;
+	break;
+    }
+    erts_print(to, to_arg, "\n");
+
+    return size;
+}
+
+static void
+print_big(int to, void *to_arg, Eterm* addr)
+{
+    int i;
+    int k;
+
+    i = BIG_SIZE(addr);
+    if (BIG_SIGN(addr))
+	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(addr, 0));
+    for (k = 1; k < i; k++)
+	erts_print(to, to_arg, ",%d", BIG_DIGIT(addr, k));
+    erts_print(to, to_arg, "}");
+}