Use a cheaper tag scheme for 'd' operands

Since 'd' operands can only either an X register or an Y register,
we only need a single bit to distinguish them. Furthermore, we can
pre-multiply the register number with the word size to speed up
address calculation.

4 files changed, 33 insertions, 42 deletions

diff --git a/erts/emulator/beam/beam_debug.c b/erts/emulator/beam/beam_debug.c
index 30e3765502..ea1f2cd012 100644
--- a/erts/emulator/beam/beam_debug.c
+++ b/erts/emulator/beam/beam_debug.c
@@ -475,15 +475,12 @@ print_op(int to, void *to_arg, int op, int size, BeamInstr* addr)
 	    ap++;
 	    break;
 	case 'd':		/* Destination (x(0), x(N), y(N)) */
-	    switch (loader_tag(*ap)) {
-	    case LOADER_X_REG:
-		erts_print(to, to_arg, "x(%d)",
-			   loader_x_reg_index(*ap));
-		break;
-	    case LOADER_Y_REG:
+	    if (*ap & 1) {
 		erts_print(to, to_arg, "y(%d)",
-			   loader_y_reg_index(*ap) - CP_SIZE);
-		break;
+			   *ap / sizeof(Eterm) - CP_SIZE);
+	    } else {
+		erts_print(to, to_arg, "x(%d)",
+			   *ap / sizeof(Eterm));
 	    }
 	    ap++;
 	    break;
diff --git a/erts/emulator/beam/beam_emu.c b/erts/emulator/beam/beam_emu.c
index 4e6e7aa48a..60a399a5ac 100644
--- a/erts/emulator/beam/beam_emu.c
+++ b/erts/emulator/beam/beam_emu.c
@@ -149,22 +149,20 @@ do {                                     \
    I = (ip)
 
 /*
+ * Register target (X or Y register).
+ */
+#define REG_TARGET(Target) (*(((Target) & 1) ? &yb(Target-1) : &xb(Target)))
+
+/*
  * Store a result into a register given a destination descriptor.
  */
 
-#define StoreResult(Result, DestDesc)			\
-  do {							\
-    Eterm stb_reg;					\
-    stb_reg = (DestDesc);				\
-    CHECK_TERM(Result);					\
-    switch (loader_tag(stb_reg)) {			\
-    case LOADER_X_REG:					\
-      x(loader_x_reg_index(stb_reg)) = (Result);	\
-      break;						\
-    default:						\
-      y(loader_y_reg_index(stb_reg)) = (Result);	\
-      break;						\
-    }							\
+#define StoreResult(Result, DestDesc)		\
+  do {						\
+    Eterm stb_reg;				\
+    stb_reg = (DestDesc);			\
+    CHECK_TERM(Result);				\
+    REG_TARGET(stb_reg) = (Result);		\
   } while (0)
 
 #define StoreSimpleDest(Src, Dest) Dest = (Src)
@@ -175,22 +173,16 @@ do {                                     \
  * be just before the next instruction.
  */
  
-#define StoreBifResult(Dst, Result)			\
-  do {							\
-    BeamInstr* stb_next;				\
-    Eterm stb_reg;					\
-    stb_reg = Arg(Dst);					\
-    I += (Dst) + 2;					\
-    stb_next = (BeamInstr *) *I;			\
-    CHECK_TERM(Result);					\
-    switch (loader_tag(stb_reg)) {			\
-    case LOADER_X_REG:					\
-      x(loader_x_reg_index(stb_reg)) = (Result);	\
-      Goto(stb_next);					\
-    default:						\
-      y(loader_y_reg_index(stb_reg)) = (Result);	\
-      Goto(stb_next);					\
-    }							\
+#define StoreBifResult(Dst, Result)		\
+  do {						\
+    BeamInstr* stb_next;			\
+    Eterm stb_reg;				\
+    stb_reg = Arg(Dst);				\
+    I += (Dst) + 2;				\
+    stb_next = (BeamInstr *) *I;		\
+    CHECK_TERM(Result);				\
+    REG_TARGET(stb_reg) = (Result);		\
+    Goto(stb_next);				\
   } while (0)
 
 #define ClauseFail() goto jump_f
@@ -3277,7 +3269,8 @@ do {						\
      Eterm* p;
      
      PreFetch(3, next);
-     GetArg2(0, element, tuple);
+     GetArg1(0, element);
+     tuple = REG_TARGET(Arg(1));
      ASSERT(is_tuple(tuple));
      p = (Eterm *) ((unsigned char *) tuple_val(tuple) + Arg(2));
      *p = element;
@@ -4605,7 +4598,7 @@ do {						\
      BeamInstr *next;
 
      PreFetch(2, next);
-     GetR(0, targ1);
+     targ1 = REG_TARGET(Arg(0));
      /* Arg(0) == HEADER_FLONUM */
      GET_DOUBLE(targ1, *(FloatDef*)ADD_BYTE_OFFSET(freg, fr));
      NextPF(2, next);
@@ -4625,7 +4618,7 @@ do {						\
      Eterm fr = Arg(1);
      BeamInstr *next;
 
-     GetR(0, targ1);
+     targ1 = REG_TARGET(Arg(0));
      PreFetch(2, next);
      if (is_small(targ1)) {
 	 fb(fr) = (double) signed_val(targ1);
diff --git a/erts/emulator/beam/beam_load.c b/erts/emulator/beam/beam_load.c
index 1e3690fcd6..a9d47eb7b0 100644
--- a/erts/emulator/beam/beam_load.c
+++ b/erts/emulator/beam/beam_load.c
@@ -2227,10 +2227,10 @@ load_code(LoaderState* stp)
 	    case 'd':	/* Destination (x(0), x(N), y(N) */
 		switch (tag) {
 		case TAG_x:
-		    code[ci++] = make_loader_x_reg(tmp_op->a[arg].val);
+		    code[ci++] = tmp_op->a[arg].val * sizeof(Eterm);
 		    break;
 		case TAG_y:
-		    code[ci++] = make_loader_y_reg(tmp_op->a[arg].val);
+		    code[ci++] = tmp_op->a[arg].val * sizeof(Eterm) + 1;
 		    break;
 		default:
 		    LoadError1(stp, "bad tag %d for destination",
diff --git a/erts/emulator/beam/beam_load.h b/erts/emulator/beam/beam_load.h
index d5af634fad..eedb5ee4cd 100644
--- a/erts/emulator/beam/beam_load.h
+++ b/erts/emulator/beam/beam_load.h
@@ -52,6 +52,7 @@ extern BeamInstr* em_call_error_handler;
 extern BeamInstr* em_apply_bif;
 extern BeamInstr* em_call_nif;
 
+
 /*
  * The following variables keep a sorted list of address ranges for
  * each module.  It allows us to quickly find a function given an