Allow X and Y registers to be overloaded with any literal

Consider the try_case_end instruction:

  try_case_end s

The 's' operand type means that the operand can either be a
literal of one of the types atom, integer, or empty list, or
a register. That worked well before R12. In R12 additional
types of literals where introduced. Because of way the
overloading was done, an 's' operand cannot handle the
new types of literals. Therefore, code such as the following
is necessary in ops.tab to avoid giving an 's' operand a
literal:

  try_case_end Literal=q => move Literal x | try_case_end x

While this work, it is error-prone in that it is easy to
forget to add that kind of rule. It would also be complicated
in case we wanted to introduce a new kind of addition operator
such as:

  i_plus jssd

Since there are two 's' operands, two scratch registers and
two 'move' instructions would be needed.

Therefore, we'll need to find a smarter way to find tag
register operands. We will overload the pid and port tags
for X and Y register, respectively. That works because pids
and port are immediate values (fit in one word), and there
are no literals for pids and ports.

7 files changed, 155 insertions, 171 deletions

diff --git a/erts/emulator/beam/beam_debug.c b/erts/emulator/beam/beam_debug.c
index 00d0b27178..243ccb9afd 100644
--- a/erts/emulator/beam/beam_debug.c
+++ b/erts/emulator/beam/beam_debug.c
@@ -432,31 +432,33 @@ print_op(int to, void *to_arg, int op, int size, BeamInstr* addr)
     while (*sign) {
 	switch (*sign) {
 	case 'r':		/* x(0) */
-	    erts_print(to, to_arg, "x(0)");
+	    erts_print(to, to_arg, "r(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]));
+	    {
+		Uint n = ap[0] / sizeof(Eterm);
+		erts_print(to, to_arg, "x(%d)", n);
+		ap++;
 	    }
-	    ap++;
 	    break;
 	case 'y':		/* y(N) */
-	    erts_print(to, to_arg, "y(%d)", reg_index(ap[0]) - CP_SIZE);
-	    ap++;
+	    {
+		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':		/* Any source (tagged constant or register) */
-	    tag = beam_reg_tag(*ap);
-	    if (tag == X_REG_DEF) {
-		erts_print(to, to_arg, "x(%d)", reg_index(*ap));
+	    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 == Y_REG_DEF) {
-		erts_print(to, to_arg, "y(%d)", reg_index(*ap) - CP_SIZE);
+	    } else if (tag == LOADER_Y_REG) {
+		erts_print(to, to_arg, "y(%d)", loader_y_reg_index(*ap) - CP_SIZE);
 		ap++;
 		break;
 	    }
@@ -473,12 +475,14 @@ 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 (beam_reg_tag(*ap)) {
-	    case X_REG_DEF:
-		erts_print(to, to_arg, "x(%d)", reg_index(*ap));
+	    switch (loader_tag(*ap)) {
+	    case LOADER_X_REG:
+		erts_print(to, to_arg, "x(%d)",
+			   loader_x_reg_index(*ap));
 		break;
-	    case Y_REG_DEF:
-		erts_print(to, to_arg, "y(%d)", reg_index(*ap) - CP_SIZE);
+	    case LOADER_Y_REG:
+		erts_print(to, to_arg, "y(%d)",
+			   loader_y_reg_index(*ap) - CP_SIZE);
 		break;
 	    }
 	    ap++;
@@ -546,7 +550,7 @@ print_op(int to, void *to_arg, int op, int size, BeamInstr* addr)
 	    ap++;
 	    break;
 	case 'l':		/* fr(N) */
-	    erts_print(to, to_arg, "fr(%d)", reg_index(ap[0]));
+	    erts_print(to, to_arg, "fr(%d)", loader_reg_index(ap[0]));
 	    ap++;
 	    break;
 	default:
@@ -658,17 +662,16 @@ print_op(int to, void *to_arg, int op, int size, BeamInstr* addr)
 	    int n = unpacked[-1];
 
 	    while (n > 0) {
-		if (!is_header(ap[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, " x(%d)", loader_y_reg_index(ap[0]));
+		    break;
+		default:
 		    erts_print(to, to_arg, " %T", (Eterm) ap[0]);
-		} else {
-		    switch ((ap[0] >> 2) & 0x03) {
-		    case X_REG_DEF:
-			erts_print(to, to_arg, " x(%d)", ap[0] >> 4);
-			break;
-		    case Y_REG_DEF:
-			erts_print(to, to_arg, " y(%d)", ap[0] >> 4);
-			break;
-		    }
+		    break;
 		}
 		ap++, size++, n--;
 	    }
@@ -681,18 +684,16 @@ print_op(int to, void *to_arg, int op, int size, BeamInstr* addr)
 	    while (n > 0) {
 		if (n % 3 == 1) {
 		    erts_print(to, to_arg, " %X", ap[0]);
-		} else if (!is_header(ap[0])) {
-		    erts_print(to, to_arg, " %T", (Eterm) ap[0]);
 		} else {
-		    switch ((ap[0] >> 2) & 0x03) {
-		    case R_REG_DEF:
-			erts_print(to, to_arg, " x(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 X_REG_DEF:
-			erts_print(to, to_arg, " x(%d)", ap[0] >> 4);
+		    case LOADER_Y_REG:
+			erts_print(to, to_arg, " y(%d)", loader_y_reg_index(ap[0]));
 			break;
-		    case Y_REG_DEF:
-			erts_print(to, to_arg, " y(%d)", ap[0] >> 4);
+		    default:
+			erts_print(to, to_arg, " %T", (Eterm) ap[0]);
 			break;
 		    }
 		}
diff --git a/erts/emulator/beam/beam_emu.c b/erts/emulator/beam/beam_emu.c
index 059c443450..a74da2d872 100644
--- a/erts/emulator/beam/beam_emu.c
+++ b/erts/emulator/beam/beam_emu.c
@@ -154,17 +154,19 @@ do {                                     \
  * 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 (beam_reg_tag(stb_reg)) {                \
-    case X_REG_DEF:                                 \
-      xb(x_reg_offset(stb_reg)) = (Result); break;  \
-    default:                                        \
-      yb(y_reg_offset(stb_reg)) = (Result); break;  \
-    }                                               \
+#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;						\
+    }							\
   } while (0)
 
 #define StoreSimpleDest(Src, Dest) Dest = (Src)
@@ -175,20 +177,22 @@ 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 (beam_reg_tag(stb_reg)) {                         \
-    case X_REG_DEF:                                          \
-      xb(x_reg_offset(stb_reg)) = (Result); Goto(stb_next);  \
-    default:                                                 \
-      yb(y_reg_offset(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);					\
+    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);					\
+    }							\
   } while (0)
 
 #define ClauseFail() goto jump_f
@@ -513,14 +517,19 @@ void** beam_ops;
     ASSERT(VALID_INSTR(Dst));  \
     Goto(Dst)
 
-#define GetR(pos, tr) \
-   do { \
-     tr = Arg(pos); \
-     switch (beam_reg_tag(tr)) { \
-     case X_REG_DEF: tr = xb(x_reg_offset(tr)); break; \
-     case Y_REG_DEF: ASSERT(y_reg_offset(tr) >= 1); tr = yb(y_reg_offset(tr)); break; \
-     } \
-     CHECK_TERM(tr); \
+#define GetR(pos, tr)				\
+   do {						\
+     tr = Arg(pos);				\
+     switch (loader_tag(tr)) {			\
+     case LOADER_X_REG:				\
+        tr = x(loader_x_reg_index(tr));		\
+        break;					\
+     case LOADER_Y_REG:				\
+        ASSERT(loader_y_reg_index(tr) >= 1);	\
+        tr = y(loader_y_reg_index(tr));		\
+        break;					\
+     }						\
+     CHECK_TERM(tr);				\
    } while (0)
 
 #define GetArg1(N, Dst) GetR((N), Dst)
@@ -2385,12 +2394,12 @@ void process_main(void)
 
      do {
 	 Eterm term = *I++;
-	 switch (term & _TAG_IMMED1_MASK) {
-	 case (X_REG_DEF << _TAG_PRIMARY_SIZE) | TAG_PRIMARY_HEADER:
-	     *hp++ = x(term >> _TAG_IMMED1_SIZE);
+	 switch (loader_tag(term)) {
+	 case LOADER_X_REG:
+	     *hp++ = x(loader_x_reg_index(term));
 	     break;
-	 case (Y_REG_DEF << _TAG_PRIMARY_SIZE) | TAG_PRIMARY_HEADER:
-	     *hp++ = y(term >> _TAG_IMMED1_SIZE);
+	 case LOADER_Y_REG:
+	     *hp++ = y(loader_y_reg_index(term));
 	     break;
 	 default:
 	     *hp++ = term;
@@ -2411,19 +2420,19 @@ void process_main(void)
      Next(3+Arg(2));
  }
 
-#define PUT_TERM_REG(term, desc)				\
-do {								\
-    switch ((desc) & _TAG_IMMED1_MASK) {			\
-    case (X_REG_DEF << _TAG_PRIMARY_SIZE) | TAG_PRIMARY_HEADER:	\
-	x((desc) >> _TAG_IMMED1_SIZE) = (term);			\
-	break;							\
-    case (Y_REG_DEF << _TAG_PRIMARY_SIZE) | TAG_PRIMARY_HEADER:	\
-	y((desc) >> _TAG_IMMED1_SIZE) = (term);			\
-	break;							\
-    default:							\
-	ASSERT(0);						\
-	break;							\
-    }								\
+#define PUT_TERM_REG(term, desc)		\
+do {						\
+    switch (loader_tag(desc)) {			\
+    case LOADER_X_REG:				\
+	x(loader_x_reg_index(desc)) = (term);	\
+	break;					\
+    case LOADER_Y_REG:				\
+	y(loader_y_reg_index(desc)) = (term);	\
+	break;					\
+    default:					\
+	ASSERT(0);				\
+	break;					\
+    }						\
 } while(0)
 
  OpCase(i_get_map_elements_fsI): {
@@ -6487,20 +6496,20 @@ static Eterm get_map_element_hash(Eterm map, Eterm key, Uint32 hx)
     return vs ? *vs : THE_NON_VALUE;
 }
 
-#define GET_TERM(term, dest)					\
-do {								\
-    Eterm src = (Eterm)(term);					\
-    switch (src & _TAG_IMMED1_MASK) {				\
-    case (X_REG_DEF << _TAG_PRIMARY_SIZE) | TAG_PRIMARY_HEADER:	\
-	dest = x(src >> _TAG_IMMED1_SIZE);			\
-	break;							\
-    case (Y_REG_DEF << _TAG_PRIMARY_SIZE) | TAG_PRIMARY_HEADER:	\
-	dest = y(src >> _TAG_IMMED1_SIZE);			\
-	break;							\
-    default:							\
-	dest = src;						\
-	break;							\
-    }								\
+#define GET_TERM(term, dest)			\
+do {						\
+    Eterm src = (Eterm)(term);			\
+    switch (loader_tag(src)) {			\
+    case LOADER_X_REG:				\
+        dest = x(loader_x_reg_index(src));	\
+	break;					\
+    case LOADER_Y_REG:				\
+        dest = y(loader_y_reg_index(src));	\
+	break;					\
+    default:					\
+	dest = src;				\
+	break;					\
+    }						\
 } while(0)
 
 
diff --git a/erts/emulator/beam/beam_load.c b/erts/emulator/beam/beam_load.c
index 495e92d600..3cd80c4ec2 100644
--- a/erts/emulator/beam/beam_load.c
+++ b/erts/emulator/beam/beam_load.c
@@ -2167,13 +2167,13 @@ load_code(LoaderState* stp)
 	    case 's':	/* Any source (tagged constant or register) */
 		switch (tag) {
 		case TAG_r:
-		    code[ci++] = make_xreg(0);
+		    code[ci++] = make_loader_x_reg(0);
 		    break;
 		case TAG_x:
-		    code[ci++] = make_xreg(tmp_op->a[arg].val);
+		    code[ci++] = make_loader_x_reg(tmp_op->a[arg].val);
 		    break;
 		case TAG_y:
-		    code[ci++] = make_yreg(tmp_op->a[arg].val);
+		    code[ci++] = make_loader_y_reg(tmp_op->a[arg].val);
 		    break;
 		case TAG_i:
 		    code[ci++] = (BeamInstr) make_small((Uint)tmp_op->a[arg].val);
@@ -2184,6 +2184,10 @@ load_code(LoaderState* stp)
 		case TAG_n:
 		    code[ci++] = NIL;
 		    break;
+		case TAG_q:
+		    new_literal_patch(stp, ci);
+		    code[ci++] = tmp_op->a[arg].val;
+		    break;
 		default:
 		    LoadError1(stp, "bad tag %d for general source",
 			       tmp_op->a[arg].type);
@@ -2193,13 +2197,13 @@ load_code(LoaderState* stp)
 	    case 'd':	/* Destination (x(0), x(N), y(N) */
 		switch (tag) {
 		case TAG_r:
-		    code[ci++] = make_xreg(0);
+		    code[ci++] = make_loader_x_reg(0);
 		    break;
 		case TAG_x:
-		    code[ci++] = make_xreg(tmp_op->a[arg].val);
+		    code[ci++] = make_loader_x_reg(tmp_op->a[arg].val);
 		    break;
 		case TAG_y:
-		    code[ci++] = make_yreg(tmp_op->a[arg].val);
+		    code[ci++] = make_loader_y_reg(tmp_op->a[arg].val);
 		    break;
 		default:
 		    LoadError1(stp, "bad tag %d for destination",
@@ -2359,13 +2363,11 @@ load_code(LoaderState* stp)
 	    case TAG_r:
 	    case TAG_x:
 		CodeNeed(1);
-		code[ci++] = (tmp_op->a[arg].val << _TAG_IMMED1_SIZE) |
-		    (X_REG_DEF << _TAG_PRIMARY_SIZE) | TAG_PRIMARY_HEADER;
+		code[ci++] = make_loader_x_reg(tmp_op->a[arg].val);
 		break;
 	    case TAG_y:
 		CodeNeed(1);
-		code[ci++] = (tmp_op->a[arg].val << _TAG_IMMED1_SIZE) |
-		    (Y_REG_DEF << _TAG_PRIMARY_SIZE) | TAG_PRIMARY_HEADER;
+		code[ci++] = make_loader_y_reg(tmp_op->a[arg].val);
 		break;
 	    case TAG_n:
 		CodeNeed(1);
diff --git a/erts/emulator/beam/erl_term.c b/erts/emulator/beam/erl_term.c
index 89459fb278..3a5fbcc284 100644
--- a/erts/emulator/beam/erl_term.c
+++ b/erts/emulator/beam/erl_term.c
@@ -173,9 +173,7 @@ ET_DEFINE_CHECKED(Uint,external_thing_data_words,ExternalThing*,is_thing_ptr);
 ET_DEFINE_CHECKED(Eterm,make_cp,UWord *,_is_taggable_pointer);
 ET_DEFINE_CHECKED(UWord *,cp_val,Eterm,is_CP);
 ET_DEFINE_CHECKED(Uint,catch_val,Eterm,is_catch);
-ET_DEFINE_CHECKED(Uint,x_reg_offset,Uint,_is_xreg);
-ET_DEFINE_CHECKED(Uint,y_reg_offset,Uint,_is_yreg);
-ET_DEFINE_CHECKED(Uint,x_reg_index,Uint,_is_xreg);
-ET_DEFINE_CHECKED(Uint,y_reg_index,Uint,_is_yreg);
+ET_DEFINE_CHECKED(Uint,loader_x_reg_index,Uint,_is_loader_x_reg);
+ET_DEFINE_CHECKED(Uint,loader_y_reg_index,Uint,_is_loader_y_reg);
 
 #endif	/* ET_DEBUG */
diff --git a/erts/emulator/beam/erl_term.h b/erts/emulator/beam/erl_term.h
index cff2430547..089eecf024 100644
--- a/erts/emulator/beam/erl_term.h
+++ b/erts/emulator/beam/erl_term.h
@@ -1027,42 +1027,40 @@ _ET_DECLARE_CHECKED(Uint,catch_val,Eterm)
 /*
  * Overloaded tags.
  *
- * SMALL = 15
- * ATOM/NIL=7
+ * In the loader, we want to tag a term in a way so that it can
+ * be any literal (atom/integer/float/tuple/list/binary) or a
+ * register.
  *
- * Note that the two least significant bits in SMALL/ATOM/NIL always are 3;
- * thus, we can distinguish register from literals by looking at only these
- * two bits.
+ * We can achive that by overloading the PID and PORT tags to
+ * mean X and Y registers. That works because there are no
+ * pid or port literals.
  */
 
-#define X_REG_DEF	0
-#define Y_REG_DEF	1
+#define _LOADER_TAG_XREG _TAG_IMMED1_PID
+#define _LOADER_TAG_YREG _TAG_IMMED1_PORT
+#define _LOADER_TAG_SIZE _TAG_IMMED1_SIZE
+#define _LOADER_MASK _TAG_IMMED1_MASK
 
-#define beam_reg_tag(x)	((x) & 3)
+#define LOADER_X_REG _LOADER_TAG_XREG
+#define LOADER_Y_REG _LOADER_TAG_YREG
 
-#define make_xreg(ix)	(((ix) * sizeof(Eterm)) | X_REG_DEF)
-#define make_yreg(ix)	(((ix) * sizeof(Eterm)) | Y_REG_DEF)
+#define make_loader_x_reg(R) (((R) << _LOADER_TAG_SIZE) | _LOADER_TAG_XREG)
+#define make_loader_y_reg(R) (((R) << _LOADER_TAG_SIZE) | _LOADER_TAG_YREG)
 
-#define _is_xreg(x)	(beam_reg_tag(x) == X_REG_DEF)
-#define _is_yreg(x)	(beam_reg_tag(x) == Y_REG_DEF)
+#define loader_reg_index(R) ((R) >> _LOADER_TAG_SIZE)
 
-#define _unchecked_x_reg_offset(R)	((R) - X_REG_DEF)
-_ET_DECLARE_CHECKED(Uint,x_reg_offset,Uint)
-#define x_reg_offset(R)	_ET_APPLY(x_reg_offset,(R))
+#define loader_tag(T) ((T) & _LOADER_MASK)
 
-#define _unchecked_y_reg_offset(R)	((R) - Y_REG_DEF)
-_ET_DECLARE_CHECKED(Uint,y_reg_offset,Uint)
-#define y_reg_offset(R)	_ET_APPLY(y_reg_offset,(R))
+#define _is_loader_x_reg(x) (loader_tag(x) == _LOADER_TAG_XREG)
+#define _is_loader_y_reg(x) (loader_tag(x) == _LOADER_TAG_YREG)
 
-#define reg_index(R) ((R) / sizeof(Eterm))
+#define _unchecked_loader_x_reg_index(R) ((R) >> _LOADER_TAG_SIZE)
+_ET_DECLARE_CHECKED(Uint,loader_x_reg_index,Uint)
+#define loader_x_reg_index(R) _ET_APPLY(loader_x_reg_index,(R))
 
-#define _unchecked_x_reg_index(R)	((R) >> 2)
-_ET_DECLARE_CHECKED(Uint,x_reg_index,Uint)
-#define x_reg_index(R)	_ET_APPLY(x_reg_index,(R))
-
-#define _unchecked_y_reg_index(R)	((R) >> 2)
-_ET_DECLARE_CHECKED(Uint,y_reg_index,Uint)
-#define y_reg_index(R)	_ET_APPLY(y_reg_index,(R))
+#define _unchecked_loader_y_reg_index(R)  ((R) >> _LOADER_TAG_SIZE)
+_ET_DECLARE_CHECKED(Uint,loader_y_reg_index,Uint)
+#define loader_y_reg_index(R) _ET_APPLY(loader_y_reg_index,(R))
 
 /*
  * Backwards compatibility definitions:
diff --git a/erts/emulator/beam/ops.tab b/erts/emulator/beam/ops.tab
index 1d32e72247..4fa6a087e2 100644
--- a/erts/emulator/beam/ops.tab
+++ b/erts/emulator/beam/ops.tab
@@ -237,12 +237,10 @@ try Y F => catch Y F
 try_case Y => try_end Y
 try_end y
 
-try_case_end Literal=q => move Literal x | try_case_end x
 try_case_end s
 
 # Destructive set tuple element
 
-set_tuple_element Lit=q Tuple Pos => move Lit x | set_tuple_element x Tuple Pos
 set_tuple_element s d P
 
 # Get tuple element
@@ -273,8 +271,8 @@ is_number Fail Literal=q => move Literal x | is_number Fail x
 
 jump f
 
-case_end Literal=cq => move Literal x | case_end x
-badmatch Literal=cq => move Literal x | badmatch x
+case_end Literal=c => move Literal x | case_end x
+badmatch Literal=c => move Literal x | badmatch x
 
 case_end r
 case_end x
@@ -849,7 +847,6 @@ is_boolean f y
 
 is_function2 Fail=f acq Arity => jump Fail
 is_function2 Fail=f Fun a => jump Fail
-is_function2 Fail Fun Literal=q => move Literal x | is_function2 Fail Fun x
 
 is_function2 f s s
 %macro: is_function2 IsFunction2 -fail_action
@@ -1122,11 +1119,8 @@ bif1 Fail Bif=u$bif:erlang:get/1 Src=s Dst=d => i_get Src Dst
 
 bif2 Jump=j u$bif:erlang:element/2 S1=s S2=rxy Dst=d => gen_element(Jump, S1, S2, Dst)
 
-bif1 Fail Bif Literal=q Dst => move Literal x | bif1 Fail Bif x Dst
 bif1 p Bif S1 Dst => bif1_body Bif S1 Dst
 
-bif1_body Bif Literal=q Dst => move Literal x | bif1_body Bif x Dst
-
 bif2 p Bif S1 S2 Dst => i_fetch S1 S2 | i_bif2_body Bif Dst
 bif2 Fail Bif S1 S2 Dst => i_fetch S1 S2 | i_bif2 Fail Bif Dst
 
@@ -1439,8 +1433,6 @@ i_bs_private_append j I d
 # Storing integers into binaries.
 #
 
-bs_put_integer Fail=j Sz=s Unit=u Flags=u Literal=q => \
-	move Literal x | bs_put_integer Fail Sz Unit Flags x
 bs_put_integer Fail=j Sz=sq Unit=u Flags=u Src=s => \
 			gen_put_integer(Fail, Sz, Unit, Flags, Src)
 
@@ -1454,32 +1446,22 @@ i_new_bs_put_integer_imm j I I s
 # Utf8/utf16/utf32 support. (R12B-5)
 #
 
-bs_utf8_size Fail Literal=q Dst=d => \
-	move Literal x | bs_utf8_size Fail x Dst
 bs_utf8_size j Src=s Dst=d => i_bs_utf8_size Src Dst
 
 i_bs_utf8_size s d
 
-bs_utf16_size Fail Literal=q Dst=d => \
-	move Literal x | bs_utf16_size Fail x Dst
 bs_utf16_size j Src=s Dst=d => i_bs_utf16_size Src Dst
 
 i_bs_utf16_size s d
 
-bs_put_utf8 Fail=j Flags=u Literal=q => \
-	move Literal x | bs_put_utf8 Fail Flags x
 bs_put_utf8 Fail u Src=s => i_bs_put_utf8 Fail Src
 
 i_bs_put_utf8 j s
 
-bs_put_utf16 Fail=j Flags=u Literal=q => \
-	move Literal x | bs_put_utf16 Fail Flags x
 bs_put_utf16 Fail Flags=u Src=s => i_bs_put_utf16 Fail Flags Src
 
 i_bs_put_utf16 j I s
 
-bs_put_utf32 Fail=j Flags=u Literal=q => \
-	move Literal x | bs_put_utf32 Fail Flags x
 bs_put_utf32 Fail=j Flags=u Src=s => \
    i_bs_validate_unicode Fail Src | bs_put_integer Fail i=32 u=1 Flags Src
 
@@ -1490,9 +1472,6 @@ i_bs_validate_unicode j s
 #
 bs_put_float Fail Sz=q Unit Flags Val => badarg Fail
 
-bs_put_float Fail=j Sz Unit=u Flags=u Literal=q => \
-	move Literal x | bs_put_float Fail Sz Unit Flags x
-
 bs_put_float Fail=j Sz=s Unit=u Flags=u Src=s => \
 			gen_put_float(Fail, Sz, Unit, Flags, Src)
 
@@ -1506,8 +1485,6 @@ i_new_bs_put_float_imm j I I s
 # Storing binaries into binaries.
 #
 
-bs_put_binary Fail Sz Unit Flags Literal=q => \
- 	move Literal x | bs_put_binary Fail Sz Unit Flags x
 bs_put_binary Fail=j Sz=s Unit=u Flags=u Src=s => \
 			gen_put_binary(Fail, Sz, Unit, Flags, Src)
 
@@ -1731,8 +1708,6 @@ gc_bif2 Fail I Bif S1 S2 Dst => \
 gc_bif3 Fail I Bif S1 S2 S3 Dst => \
 	gen_guard_bif3(Fail, I, Bif, S1, S2, S3, Dst)
 
-i_gc_bif1 Fail Bif V=q Live D => move V x | i_gc_bif1 Fail Bif x Live D
-
 i_gc_bif1 j I s I d
 
 ii_gc_bif2/6
diff --git a/erts/emulator/utils/beam_makeops b/erts/emulator/utils/beam_makeops
index 6e1741af85..00b0df5b73 100755
--- a/erts/emulator/utils/beam_makeops
+++ b/erts/emulator/utils/beam_makeops
@@ -180,7 +180,8 @@ sub define_type_bit {
     define_type_bit('c', $type_bit{'i'} | $type_bit{'a'} |
 		    $type_bit{'n'} | $type_bit{'q'});
     define_type_bit('s', $type_bit{'d'} | $type_bit{'i'} |
-		    $type_bit{'a'} | $type_bit{'n'});
+		    $type_bit{'a'} | $type_bit{'n'} |
+		    $type_bit{'q'});
     define_type_bit('j', $type_bit{'f'} | $type_bit{'p'});
 
     # Aliases (for matching purposes).