Correct the VM to work for more test suites

The following test suites now work:

send_term_SUITE
trace_nif_SUITE
binary_SUITE
match_spec_SUITE
node_container_SUITE
beam_literals_SUITE

Also add a testcases for system_info({wordsize,internal|external}).

8 files changed, 180 insertions, 55 deletions

diff --git a/erts/emulator/beam/beam_emu.c b/erts/emulator/beam/beam_emu.c
index 1078478ed9..0d1cce52ca 100644
--- a/erts/emulator/beam/beam_emu.c
+++ b/erts/emulator/beam/beam_emu.c
@@ -2775,7 +2775,7 @@ void process_main(void)
 	    given_size = thing_arityval(given_arity);
 	    bigp = (Eterm *) &Arg(2);
 	    while ((arity = bigp[0]) > given_arity) {
-		bigp += thing_arityval(arity) + 2;
+		bigp += (TermWords(thing_arityval(arity) + 1) + 1) * (sizeof(BeamInstr)/sizeof(Eterm));
 	    }
 	    while (bigp[0] == given_arity) {
 		if (memcmp(bigp+1, given+1, sizeof(Eterm)*given_size) == 0) {
@@ -2784,7 +2784,7 @@ void process_main(void)
 		    SET_I((BeamInstr *) *tmp);
 		    Goto(*I);
 		}
-		bigp += thing_arityval(arity) + 2;
+		bigp += (TermWords(thing_arityval(arity) + 1) + 1) * (sizeof(BeamInstr)/sizeof(Eterm));
 	    }
 	}
 
@@ -4291,7 +4291,7 @@ apply_bif_or_nif_epilogue:
      */
  OpCase(call_traced_function): {
      if (IS_TRACED_FL(c_p, F_TRACE_CALLS)) {
-	 unsigned offset = offsetof(Export, code) + 3*sizeof(Eterm);
+	 unsigned offset = offsetof(Export, code) + 3*sizeof(BeamInstr);
 	 Export* ep = (Export *) (((char *)I)-offset);
 	 Uint32 flags;
 
diff --git a/erts/emulator/beam/big.c b/erts/emulator/beam/big.c
index c70044ed43..40c8e15436 100644
--- a/erts/emulator/beam/big.c
+++ b/erts/emulator/beam/big.c
@@ -1504,7 +1504,7 @@ Eterm small_to_big(Sint x, Eterm *y)
 Eterm erts_uint64_to_big(Uint64 x, Eterm **hpp)
 {
     Eterm *hp = *hpp;
-#ifdef ARCH_32
+#if defined(ARCH_32) || HALFWORD_HEAP
     if (x >= (((Uint64) 1) << 32)) {
 	*hp = make_pos_bignum_header(2);
 	BIG_DIGIT(hp, 0) = (Uint) (x & ((Uint) 0xffffffff));
@@ -1531,7 +1531,7 @@ Eterm erts_sint64_to_big(Sint64 x, Eterm **hpp)
 	neg = 1;
 	x = -x;
     }
-#ifdef ARCH_32
+#if defined(ARCH_32) || HALFWORD_HEAP
     if (x >= (((Uint64) 1) << 32)) {
 	if (neg)
 	    *hp = make_neg_bignum_header(2);
diff --git a/erts/emulator/beam/big.h b/erts/emulator/beam/big.h
index 39689189e5..4047bd3fe3 100644
--- a/erts/emulator/beam/big.h
+++ b/erts/emulator/beam/big.h
@@ -94,7 +94,7 @@ typedef Uint  dsize_t;	 /* Vector size type */
 #define BIG_UWORD_HEAP_SIZE(UW) BIG_UINT_HEAP_SIZE
 #endif
 
-#ifdef ARCH_32
+#if defined(ARCH_32) || HALFWORD_HEAP
 
 #define ERTS_UINT64_BIG_HEAP_SIZE__(X) \
   ((X) >= (((Uint64) 1) << 32) ? (1 + 2) : (1 + 1))
diff --git a/erts/emulator/beam/erl_db.c b/erts/emulator/beam/erl_db.c
index 4c75659246..cbdaa459de 100644
--- a/erts/emulator/beam/erl_db.c
+++ b/erts/emulator/beam/erl_db.c
@@ -3359,8 +3359,11 @@ static BIF_RETTYPE ets_delete_trap(Process *p, Eterm cont)
     Eterm* ptr = big_val(cont);
     DbTable *tb = *((DbTable **) (UWord) (ptr + 1));
 
+#if HALFWORD_HEAP
+    ASSERT(*ptr == make_pos_bignum_header(2));
+#else
     ASSERT(*ptr == make_pos_bignum_header(1));
-
+#endif
     db_lock(tb, LCK_WRITE);
     trap = free_table_cont(p, tb, 0, 1);
     db_unlock(tb, LCK_WRITE);
diff --git a/erts/emulator/beam/erl_db_util.c b/erts/emulator/beam/erl_db_util.c
index 165c56cbf1..288f1f6d12 100644
--- a/erts/emulator/beam/erl_db_util.c
+++ b/erts/emulator/beam/erl_db_util.c
@@ -117,6 +117,10 @@ do {									\
 	erts_free(ERTS_ALC_T_DB_MC_STK, (Name).data);			\
 } while (0)
 
+
+#define TermWords(t) (((t) / (sizeof(UWord)/sizeof(Eterm))) + !!((t) % (sizeof(UWord)/sizeof(Eterm))))
+
+
 static ERTS_INLINE Process *
 get_proc(Process *cp, Uint32 cp_locks, Eterm id, Uint32 id_locks)
 {
@@ -1204,6 +1208,32 @@ Eterm erts_match_set_run(Process *p, Binary *mpsp,
      */
 }
 
+static Eterm erts_match_set_run_ets(Process *p, Binary *mpsp,
+				    Eterm args, int num_args,
+				    Uint32 *return_flags)
+{
+    Eterm ret;
+
+    ret = db_prog_match(p, mpsp,
+			args, NULL,
+			num_args, return_flags);
+#if defined(HARDDEBUG)
+    if (is_non_value(ret)) {
+	erts_fprintf(stderr, "Failed\n");
+    } else {
+	erts_fprintf(stderr, "Returning : %T\n", ret);
+    }
+#endif
+    return ret;
+    /* Returns
+     *   THE_NON_VALUE if no match
+     *   am_false      if {message,false} has been called,
+     *   am_true       if {message,_} has not been called or
+     *                 if {message,true} has been called,
+     *   Msg           if {message,Msg} has been called.
+     */
+}
+
 /*
 ** API Used by other erl_db modules.
 */
@@ -1773,29 +1803,34 @@ restart:
 		FAIL();
 	    if (memcmp(float_val(*ep) + 1, pc, sizeof(double)))
 		FAIL();
-	    pc += 2;
+	    pc += TermWords(2);
 	    ++ep;
 	    break;
 	case matchEqRef:
 	    if (!is_ref(*ep))
 		FAIL();
-	    if (!eq(*ep, make_internal_ref(pc)))
+	    if (!eq(*ep, make_internal_ref((Uint *) pc)))
 		FAIL();
-	    i = thing_arityval(*pc);
-	    pc += i+1;
+	    i = thing_arityval(*((Uint *) pc));
+	    pc += TermWords(i+1);
 	    ++ep;
 	    break;
 	case matchEqBig:
 	    if (!is_big(*ep))
 		FAIL();
 	    tp = big_val(*ep);
-	    if (*tp != *pc)
-		FAIL();
-	    i = BIG_ARITY(pc);
-	    while(i--)
-		if (*++tp != *++pc)
+	    {
+		Eterm *epc = (Eterm *) pc;
+		if (*tp != *epc)
 		    FAIL();
-	    ++pc;
+		i = BIG_ARITY(epc);
+		pc += TermWords(i+1);
+		while(i--) {
+		    if (*++tp != *++epc) {
+			FAIL();
+		    }
+		}
+	    }
 	    ++ep;
 	    break;
 	case matchEq:
@@ -1887,7 +1922,7 @@ restart:
 	    break;
 	case matchPushArrayAsList:
 	    n = arity; /* Only happens when 'term' is an array */
-	    tp = (Eterm *) EXPAND_POINTER(term);
+	    tp = termp;
 	    *esp++  = make_list(ehp);
 	    while (n--) {
 		*ehp++ = *tp++;
@@ -1900,7 +1935,7 @@ restart:
 	    break;
 	case matchPushArrayAsListU:
 	    /* This instruction is NOT efficient. */
-	    *esp++  = dpm_array_to_list(psp, (Eterm *) EXPAND_POINTER(term), arity);
+	    *esp++  = dpm_array_to_list(psp, termp, arity);
 	    break;
 	case matchTrue:
 	    if (*--esp != am_true)
@@ -2710,27 +2745,80 @@ static DMCRet dmc_one_term(DMCContext *context,
 	    DMC_PUSH(*stack, c);
 	    break;
 	case (_TAG_HEADER_REF >> _TAG_PRIMARY_SIZE):
-	    n = thing_arityval(*internal_ref_val(c));
 	    DMC_PUSH(*text, matchEqRef);
+#if HALFWORD_HEAP
+	    {
+		union {
+		    UWord u;
+		    Uint t[2];
+		} fiddle;
+		ASSERT(thing_arityval(*internal_ref_val(c)) == 3);
+		fiddle.t[0] = *internal_ref_val(c);
+		fiddle.t[1] = (Uint) internal_ref_val(c)[1];
+		DMC_PUSH(*text, fiddle.u);
+		fiddle.t[0] = (Uint) internal_ref_val(c)[2];
+		fiddle.t[1] = (Uint) internal_ref_val(c)[3];
+		DMC_PUSH(*text, fiddle.u);
+	    }
+#else
+	    n = thing_arityval(*internal_ref_val(c));
 	    DMC_PUSH(*text, *internal_ref_val(c));
 	    for (i = 1; i <= n; ++i) {
 		DMC_PUSH(*text, (Uint) internal_ref_val(c)[i]);
 	    }
+#endif
 	    break;
 	case (_TAG_HEADER_POS_BIG >> _TAG_PRIMARY_SIZE):
 	case (_TAG_HEADER_NEG_BIG >> _TAG_PRIMARY_SIZE):
 	    n = thing_arityval(*big_val(c));
 	    DMC_PUSH(*text, matchEqBig);
+#if HALFWORD_HEAP
+	    {
+		union {
+		    UWord u;
+		    Uint t[2];
+		} fiddle;
+		ASSERT(n >= 1);
+		fiddle.t[0] = *big_val(c);
+		fiddle.t[1] = big_val(c)[1];
+		DMC_PUSH(*text, fiddle.u);
+		for (i = 2; i <= n; ++i) {
+		    fiddle.t[0] = big_val(c)[i];
+		    if (++i <= n) {
+			fiddle.t[1] = big_val(c)[i];
+		    } else {
+			fiddle.t[1] = (Uint) 0;
+		    }
+		    DMC_PUSH(*text, fiddle.u);
+		}
+	    }
+#else
 	    DMC_PUSH(*text, *big_val(c));
 	    for (i = 1; i <= n; ++i) {
 		DMC_PUSH(*text, (Uint) big_val(c)[i]);
 	    }
+#endif
 	    break;
 	case (_TAG_HEADER_FLOAT >> _TAG_PRIMARY_SIZE):
 	    DMC_PUSH(*text,matchEqFloat);
+#if HALFWORD_HEAP
+	    {
+		union {
+		    UWord u;
+		    Uint t[2];
+		} fiddle;
+		fiddle.t[0] = float_val(c)[1];
+		fiddle.t[1] = float_val(c)[2];
+		DMC_PUSH(*text, fiddle.u);
+	    }
+#else
 	    DMC_PUSH(*text, (Uint) float_val(c)[1]);
-	    /* XXX: this reads and pushes random junk on ARCH_64 */
+#ifdef ARCH_64
+	    DMC_PUSH(*text, (Uint) 0);
+#else
 	    DMC_PUSH(*text, (Uint) float_val(c)[2]);
+#endif
+#endif
 	    break;
 	default: /* BINARY, FUN, VECTOR, or EXTERNAL */
 	    /*
@@ -4277,17 +4365,18 @@ static Eterm match_spec_test(Process *p, Eterm against, Eterm spec, int trace)
 		++n;
 		l = CDR(list_val(l));
 	    }
+	    save_cp = p->cp;
+	    p->cp = NULL;
+	    res = erts_match_set_run(p, mps, arr, n, &ret_flags);
+	    p->cp = save_cp;
 	} else {
 	    n = 0;
-	    arr = tuple_val(against);
+	    arr = NULL;
+	    res = erts_match_set_run_ets(p, mps, against, n, &ret_flags);
 	}
 	
 	/* We are in the context of a BIF, 
 	   {caller} should return 'undefined' */
-	save_cp = p->cp;
-	p->cp = NULL;
-	res = erts_match_set_run(p, mps, arr, n, &ret_flags);
-	p->cp = save_cp;
 	if (is_non_value(res)) {
 	    res = am_false;
 	}
@@ -4396,41 +4485,48 @@ static void db_match_dis(Binary *bp)
 	    break;
 	case matchEqRef:
 	    ++t;
-	    n = thing_arityval(*t);
-	    ++t;
-	    erts_printf("EqRef\t(%d) {", (int) n);
-	    first = 1;
-	    while (n--) {
-		if (first)
-		    first = 0;
-		else
-		    erts_printf(", ");
+	    {
+		RefThing *rt = (RefThing *) t;
+		int ri;
+		n = thing_arityval(rt->header);
+		erts_printf("EqRef\t(%d) {", (int) n);
+		first = 1;
+		for (ri = 0; ri < n; ++ri) {
+		    if (first)
+			first = 0;
+		    else
+			erts_printf(", ");
 #if defined(ARCH_64) && !HALFWORD_HEAP
-		erts_printf("0x%016bpx", *t);
+		    erts_printf("0x%016bpx", rt->data.ui[ri]);
 #else
-		erts_printf("0x%08bpx", *t);
+		    erts_printf("0x%08bpx", rt->data.ui[ri]);
 #endif
-		++t;
+		}
 	    }
+	    t += TermWords(REF_THING_SIZE);
 	    erts_printf("}\n");
 	    break;
 	case matchEqBig:
 	    ++t;
 	    n = thing_arityval(*t);
-	    ++t;
-	    erts_printf("EqBig\t(%d) {", (int) n);
-	    first = 1;
-	    while (n--) {
-		if (first)
-		    first = 0;
-		else
-		    erts_printf(", ");
+	    {
+		Eterm *et = (Eterm *) t;
+		t += TermWords(n+1);
+		erts_printf("EqBig\t(%d) {", (int) n);
+		first = 1;
+		++n;
+		while (n--) {
+		    if (first)
+			first = 0;
+		    else
+			erts_printf(", ");
 #if defined(ARCH_64) && !HALFWORD_HEAP
-		erts_printf("0x%016bpx", *t);
+		    erts_printf("0x%016bpx", *et);
 #else
-		erts_printf("0x%08bpx", *t);
+		    erts_printf("0x%08bpx", *et);
 #endif
-		++t;
+		++et;
+		}
 	    }
 	    erts_printf("}\n");
 	    break;
@@ -4438,8 +4534,8 @@ static void db_match_dis(Binary *bp)
 	    ++t;
 	    {
 		double num;
-		memcpy(&num,t, 2 * sizeof(*t));
-		t += 2;
+		memcpy(&num,t,sizeof(double));
+		t += TermWords(2);
 		erts_printf("EqFloat\t%f\n", num);
 	    }
 	    break;
diff --git a/erts/emulator/beam/erl_node_tables.c b/erts/emulator/beam/erl_node_tables.c
index 6960844e99..de4c4e353e 100644
--- a/erts/emulator/beam/erl_node_tables.c
+++ b/erts/emulator/beam/erl_node_tables.c
@@ -1118,7 +1118,9 @@ insert_offheap(ErlOffHeap *oh, int type, Eterm id)
 		    Uint *hp = &id_heap[0];
 		    InsertedBin *nib;
 #if HALFWORD_HEAP
-		    UseTmpHeapNoproc(BIG_UWORD_HEAP_SIZE(val));
+		    int actual_need = BIG_UWORD_HEAP_SIZE(val);
+		    ASSERT(actual_need <= (BIG_UINT_HEAP_SIZE*2));
+		    UseTmpHeapNoproc(actual_need);
 		    a.id = erts_bld_uword(&hp, NULL, (UWord) val);
 #else
 		    UseTmpHeapNoproc(BIG_UINT_HEAP_SIZE);
@@ -1132,7 +1134,7 @@ insert_offheap(ErlOffHeap *oh, int type, Eterm id)
 		    nib->next = inserted_bins;
 		    inserted_bins = nib;
 #if HALFWORD_HEAP
-		    UnUseTmpHeapNoproc(BIG_UINT_HEAP_SIZE*2);
+		    UnUseTmpHeapNoproc(actual_need);
 #else
 		    UnUseTmpHeapNoproc(BIG_UINT_HEAP_SIZE);
 #endif
diff --git a/erts/emulator/beam/external.c b/erts/emulator/beam/external.c
index ac8dd27b15..badefb728d 100644
--- a/erts/emulator/beam/external.c
+++ b/erts/emulator/beam/external.c
@@ -3011,7 +3011,11 @@ decoded_size(byte *ep, byte* endp, int no_refc_bins)
 	    break;
 	case EXPORT_EXT:
 	    terms += 3;
+#if HALFWORD_HEAP
+	    heap_size += 3;
+#else
 	    heap_size += 2;
+#endif
 	    break;
 	case NEW_FUN_EXT:
 	    {
diff --git a/erts/emulator/test/system_info_SUITE.erl b/erts/emulator/test/system_info_SUITE.erl
index e782d2f293..ba433d4e11 100644
--- a/erts/emulator/test/system_info_SUITE.erl
+++ b/erts/emulator/test/system_info_SUITE.erl
@@ -35,12 +35,12 @@
 %-compile(export_all).
 -export([all/1, init_per_testcase/2, fin_per_testcase/2]).
 
--export([process_count/1, system_version/1, misc_smoke_tests/1, heap_size/1]).
+-export([process_count/1, system_version/1, misc_smoke_tests/1, heap_size/1, wordsize/1]).
 
 -define(DEFAULT_TIMEOUT, ?t:minutes(2)).
 
 all(doc) -> [];
-all(suite) -> [process_count, system_version, misc_smoke_tests, heap_size].
+all(suite) -> [process_count, system_version, misc_smoke_tests, heap_size, wordsize].
 
 init_per_testcase(_Case, Config) when is_list(Config) ->
     Dog = ?t:timetrap(?DEFAULT_TIMEOUT),
@@ -145,3 +145,23 @@ heap_size(Config) when is_list(Config) ->
    ?line Hmin  = proplists:get_value(min_heap_size, GCinf),
    ok.
 
+wordsize(suite) ->
+    [];
+wordsize(doc) ->
+    ["Tests the various wordsize variants"];
+wordsize(Config) when is_list(Config) ->
+    ?line A = erlang:system_info(wordsize),
+    ?line true = is_integer(A),
+    ?line A = erlang:system_info({wordsize,internal}),
+    ?line B = erlang:system_info({wordsize,external}),
+    ?line true = A =< B,
+    case {B,A} of
+	{4,4} ->
+	    {comment, "True 32-bit emulator"};
+	{8,8} ->
+	    {comment, "True 64-bit emulator"};
+	{8,4} ->
+	    {comment, "Halfword 64-bit emulator"};
+	Other ->
+	    exit({unexpected_wordsizes,Other})
+    end.