Real-mode i386 back end (Was: New back end ia16: 16-bit Intel x86)

[Rask Ingemann Lambertsen <rask@sygehus.dk>]

On Tue, Aug 21, 2007 at 10:44:46AM -0700, H. Peter Anvin wrote:
> The issue, rather, is the following error, which I haven't figured out
> the best way to address yet (mostly due to only running into it late
> last week):
> 
> /home/hpa/kernel/test-gcc16/arch/i386/boot/video.c:461: internal
> compiler error: in find_valid_class, at reload.c:699
> Please submit a full bug report,
> with preprocessed source if appropriate.
> See <URL:http://gcc.gnu.org/bugs.html> for instructions.
> 
> It happens mostly when compiling code which has previously been built
> with .code16gcc, so I'm using -mint32.
> 
> It looks like it calls find_valid_class with (outer=HImode,
> inner=SImode, n=1), however:
> 
> /* Find the largest class which has at least one register valid in
>    mode INNER, and which for every such register, that register number
>    plus N is also valid in OUTER (if in range) and is cheap to move
>    into REGNO.  Such a class must exist.  */
> 
> This does, however, cause trouble since we only allow SImode and HImode
> values in even registers; the odd registers being the upper half of a
> register.  Other than that, we're down to generating valid code for a
> fair number of the things I throw at it.

   This patch was once needed for my ia16 back end, but these days,
find_valid_class() isn't called any more. The problems with
find_valid_class() are still latent, though. The three problems I recall
being:

1) Assuming you can pass in a subreg_regno_offset and use it for any
register.
2) Not counting the number of registers in the class right.
3) Something about not checking HARD_REGNO_MODE_OK() enough.

   I'd like to know if the patch fixes your problem.

Index: reload.c
===================================================================
--- reload.c	(revision 126653)
+++ reload.c	(working copy)
@@ -252,7 +252,7 @@ static int push_secondary_reload (int, r
 				  enum machine_mode, enum reload_type,
 				  enum insn_code *, secondary_reload_info *);
 static enum reg_class find_valid_class (enum machine_mode, enum machine_mode,
-					int, unsigned int);
+					int, unsigned int, enum machine_mode);
 static int reload_inner_reg_of_subreg (rtx, enum machine_mode, int);
 static void push_replacement (rtx *, int, enum machine_mode);
 static void dup_replacements (rtx *, rtx *);
@@ -650,13 +650,15 @@ clear_secondary_mem (void)
 
 /* Find the largest class which has at least one register valid in
    mode INNER, and which for every such register, that register number
-   plus N is also valid in OUTER (if in range) and is cheap to move
-   into REGNO.  Such a class must exist.  */
+   plus subreg_regno_offset (regnum, INNER, OFFSET, OUTER2) is also valid
+   in OUTER (if in range) and is cheap to move into REGNO.
+   Such a class must exist.  */
 
 static enum reg_class
 find_valid_class (enum machine_mode outer ATTRIBUTE_UNUSED,
-		  enum machine_mode inner ATTRIBUTE_UNUSED, int n,
-		  unsigned int dest_regno ATTRIBUTE_UNUSED)
+		  enum machine_mode inner ATTRIBUTE_UNUSED, int offset,
+		  unsigned int dest_regno ATTRIBUTE_UNUSED,
+		  enum machine_mode outer2)
 {
   int best_cost = -1;
   int class;
@@ -666,16 +668,30 @@ find_valid_class (enum machine_mode oute
   unsigned int best_size = 0;
   int cost;
 
+  gcc_assert (outer2 == outer);
+
   for (class = 1; class < N_REG_CLASSES; class++)
     {
       int bad = 0;
       int good = 0;
-      for (regno = 0; regno < FIRST_PSEUDO_REGISTER - n && ! bad; regno++)
+      unsigned int nregs;
+      unsigned int class_size = 0;
+
+      for (regno = 0, nregs = hard_regno_nregs[0][inner];
+	   ((!HARD_REGNO_MODE_OK (regno, inner) && regno < FIRST_PSEUDO_REGISTER)
+	      || regno + nregs - 1 < FIRST_PSEUDO_REGISTER)
+	   && !bad;
+	   nregs = hard_regno_nregs[++regno][inner])
 	if (TEST_HARD_REG_BIT (reg_class_contents[class], regno))
 	  {
-	    if (HARD_REGNO_MODE_OK (regno, inner))
+	    /* We ought to check all registers [regno; regno + nregs - 1]. */
+	    /* nregs is bogus if ! HARD_REGNO_MODE_OK(). */
+	    if (HARD_REGNO_MODE_OK (regno, inner)
+	        && TEST_HARD_REG_BIT (reg_class_contents[class], regno + nregs - 1))
 	      {
+		int n = subreg_regno_offset (regno, inner, offset, outer);
 		good = 1;
+		class_size ++;
 		if (! TEST_HARD_REG_BIT (reg_class_contents[class], regno + n)
 		    || ! HARD_REGNO_MODE_OK (regno + n, outer))
 		  bad = 1;
@@ -686,18 +703,25 @@ find_valid_class (enum machine_mode oute
 	continue;
       cost = REGISTER_MOVE_COST (outer, class, dest_class);
 
-      if ((reg_class_size[class] > best_size
+      if ((class_size > best_size
 	   && (best_cost < 0 || best_cost >= cost))
 	  || best_cost > cost)
 	{
 	  best_class = class;
-	  best_size = reg_class_size[class];
+	  best_size = class_size;
 	  best_cost = REGISTER_MOVE_COST (outer, class, dest_class);
 	}
     }
 
   gcc_assert (best_size != 0);
 
+  {
+    FILE *log;
+    log = fopen ("/tmp/find_valid_class_log", "a");
+    fprintf (log, "(%s, %s, %d, %d) = %s\n", GET_MODE_NAME (outer),
+	     GET_MODE_NAME (inner), offset, dest_regno, reg_class_names[best_class]);
+    fclose (log);
+  }
   return best_class;
 }
 \f
@@ -1079,11 +1103,8 @@ push_reload (rtx in, rtx out, rtx *inloc
       if (REG_P (SUBREG_REG (in)))
 	in_class
 	  = find_valid_class (inmode, GET_MODE (SUBREG_REG (in)),
-			      subreg_regno_offset (REGNO (SUBREG_REG (in)),
-						   GET_MODE (SUBREG_REG (in)),
-						   SUBREG_BYTE (in),
-						   GET_MODE (in)),
-			      REGNO (SUBREG_REG (in)));
+			      SUBREG_BYTE (in), REGNO (SUBREG_REG (in)),
+			      GET_MODE (in));
 
       /* This relies on the fact that emit_reload_insns outputs the
 	 instructions for input reloads of type RELOAD_OTHER in the same
@@ -1173,11 +1194,8 @@ push_reload (rtx in, rtx out, rtx *inloc
       push_reload (SUBREG_REG (out), SUBREG_REG (out), &SUBREG_REG (out),
 		   &SUBREG_REG (out),
 		   find_valid_class (outmode, GET_MODE (SUBREG_REG (out)),
-				     subreg_regno_offset (REGNO (SUBREG_REG (out)),
-							  GET_MODE (SUBREG_REG (out)),
-							  SUBREG_BYTE (out),
-							  GET_MODE (out)),
-				     REGNO (SUBREG_REG (out))),
+				     SUBREG_BYTE (out),
+				     REGNO (SUBREG_REG (out)), GET_MODE (out)),
 		   VOIDmode, VOIDmode, 0, 0,
 		   opnum, RELOAD_OTHER);
     }

-- 
Rask Ingemann Lambertsen