Store pointers to heap data in 32-bit words

Store Erlang terms in 32-bit entities on the heap, expanding the
pointers to 64-bit when needed. This works because all terms are stored
on addresses in the 32-bit address range (the 32 most significant bits
of pointers to term data are always 0).

Introduce a new datatype called UWord (along with its companion SWord),
which is an integer having the exact same size as the machine word
(a void *), but might be larger than Eterm/Uint.

Store code as machine words, as the instructions are pointers to
executable code which might reside outside the 32-bit address range.

Continuation pointers are stored on the 32-bit stack and hence must
point to addresses in the low range, which means that loaded beam code
much be placed in the low 32-bit address range (but, as said earlier,
the instructions themselves are full words).

No Erlang term data can be stored on C stacks (enforced by an
earlier commit).

This version gives a prompt, but test cases still fail (and dump core).

The loader (and emulator loop) has instruction packing disabled.

The main issues has been in rewriting loader and actual virtual
machine. Subsystems (like distribution) does not work yet.

1 files changed, 15 insertions, 11 deletions

diff --git a/erts/emulator/beam/erl_process.h b/erts/emulator/beam/erl_process.h
index 4466442fbc..df08f2474c 100644
--- a/erts/emulator/beam/erl_process.h
+++ b/erts/emulator/beam/erl_process.h
@@ -179,7 +179,7 @@ extern int erts_sched_thread_suggested_stack_size;
 
 
 #ifdef DEBUG
-#  ifdef ARCH_64
+#  if defined(ARCH_64) && !HALFWORD_HEAP
 #    define ERTS_DBG_SET_INVALID_RUNQP(RQP, N) \
        (*((char **) &(RQP)) = (char *) (0xdeadbeefdead0003 | ((N) << 4)))
 #  define ERTS_DBG_VERIFY_VALID_RUNQP(RQP) \
@@ -344,7 +344,11 @@ struct ErtsSchedulerData_ {
      * numbered registers as possible in the same cache
      * line).
      */
+#if !HALFWORD_HEAP
     Eterm save_reg[ERTS_X_REGS_ALLOCATED]; /* X registers */
+#else
+    Eterm *save_reg;
+#endif
     FloatDef freg[MAX_REG];	/* Floating point registers. */
     ethr_tid tid;		/* Thread id */
     struct erl_bits_state erl_bits_state; /* erl_bits.c state */
@@ -525,8 +529,8 @@ struct process {
     unsigned max_arg_reg;	/* Maximum number of argument registers available. */
     Eterm def_arg_reg[6];	/* Default array for argument registers. */
 
-    Eterm* cp;			/* Continuation pointer (for threaded code). */
-    Eterm* i;			/* Program counter for threaded code. */
+    UWord* cp;			/* Continuation pointer (for threaded code). */
+    UWord* i;			/* Program counter for threaded code. */
     Sint catches;		/* Number of catches on stack */
     Sint fcalls;		/* 
 				 * Number of reductions left to execute.
@@ -573,11 +577,11 @@ struct process {
     Uint seq_trace_lastcnt;
     Eterm seq_trace_token;	/* Sequential trace token (tuple size 5 see below) */
 
-    Eterm initial[3];		/* Initial module(0), function(1), arity(2) */
-    Eterm* current;		/* Current Erlang function:
+    UWord initial[3];		/* Initial module(0), function(1), arity(2) */
+    UWord* current;		/* Current Erlang function, part of the funcinfo:
 				 * module(0), function(1), arity(2)
 				 * (module and functions are tagged atoms;
-				 * arity an untagged integer).
+				 * arity an untagged integer). UWord * because it references code
 				 */
     
     /*
@@ -1216,8 +1220,8 @@ erts_proc_get_error_handler(Process *p)
     if (!val)
 	return am_error_handler;
     else {
-	ASSERT(is_atom(((Eterm) val)));
-	return (Eterm) val;
+	ASSERT(is_atom(((Eterm) (UWord) val)));
+	return (Eterm) (UWord) val;
     }
 }
 
@@ -1227,13 +1231,13 @@ erts_proc_set_error_handler(Process *p, ErtsProcLocks plocks, Eterm handler)
     void *old_val;
     void *new_val;
     ASSERT(is_atom(handler));
-    new_val = handler == am_error_handler ? NULL : (void *) handler;
+    new_val = (handler == am_error_handler) ? NULL : (void *) (UWord) handler;
     old_val = erts_psd_set(p, plocks, ERTS_PSD_ERROR_HANDLER, new_val);
     if (!old_val)
 	return am_error_handler;
     else {
-	ASSERT(is_atom(((Eterm) old_val)));
-	return (Eterm) old_val;
+	ASSERT(is_atom(((Eterm) (UWord) old_val)));
+	return (Eterm) (UWord) old_val;
     }
 }