ip2k.c

gcc-you can use this code to learn something about gcc, and inquire further into linux,

	        d = INTVAL (operands[1]) & 0xff;
	      }

            OUT_AS2 (mov, w, %A1);
	    if (imm_cmp && (b == a))
	      {
	        OUT_AS2 (csne, w, %A0);
	        OUT_AS2 (cse, w, %B0);
	      }
	    else
	      {
	        OUT_AS2 (cse, w, %A0);
	        OUT_AS1 (page, 2f);
	        OUT_AS1 (jmp, 2f);
	        OUT_AS2 (mov, w, %B1);
	        OUT_AS2 (cse, w, %B0);
	      }
	    OUT_AS1 (page, 2f);
	    OUT_AS1 (jmp, 2f);
	    if (! imm_cmp || (c != b))
	      OUT_AS2 (mov, w, %C1);
	    OUT_AS2 (cse, w, %C0);
	    OUT_AS1 (page, 2f);
	    OUT_AS1 (jmp, 2f);
	    if (! imm_cmp || (d != c))
	      OUT_AS2 (mov, w, %D1);
	    OUT_AS2 (csne, w, %D0);
	    OUT_AS1 (page, %2);
	    OUT_AS1 (jmp, %2);
	    OUT_AS1 (2:,);
	  }
	  break;

        case NE:
	  {
	    unsigned char a = 0, b = 1, c = 2, d = 3;

	    if (imm_cmp)
	      {
	        a = (INTVAL (operands[1]) >> 24) & 0xff;
	        b = (INTVAL (operands[1]) >> 16) & 0xff;
                c = (INTVAL (operands[1]) >> 8) & 0xff;
	        d = INTVAL (operands[1]) & 0xff;
	      }

	    OUT_AS2 (mov, w, %A1);
	    if (imm_cmp && (b == a))
	      {
	        OUT_AS2 (csne, w, %A0);
	        OUT_AS2 (cse, w, %B0);
	      }
	    else
	      {
	        OUT_AS2 (cse, w, %A0);
	        OUT_AS1 (page, %2);
	        OUT_AS1 (jmp, %2);
	        OUT_AS2 (mov, w, %B1);
	        OUT_AS2 (cse, w, %B0);
	      }
	    OUT_AS1 (page, %2);
	    OUT_AS1 (jmp, %2);
	    if (! imm_cmp || (c != b))
	      OUT_AS2 (mov, w, %C1);
	    if (imm_cmp && (d == c))
	      {
	        OUT_AS2 (csne, w, %C0);
	        OUT_AS2 (cse, w, %D0);
	      }
	    else
	      {
	        OUT_AS2 (cse, w, %C0);
	        OUT_AS1 (page, %2);
	        OUT_AS1 (jmp, %2);
	        OUT_AS2 (mov, w, %D1);
	        OUT_AS2 (cse, w, %D0);
	      }
	    OUT_AS1 (page, %2);
	    OUT_AS1 (jmp, %2);
	  }
	  break;

	case GTU:
	  if (imm_sub)
	    {
	      /* > 0xffffffff never suceeds!  */
	      if ((unsigned HOST_WIDE_INT)(INTVAL (operands[1]) & 0xffffffff)
		  != 0xffffffff)
		{
	          operands[3] = GEN_INT (INTVAL (operands[1]) + 1);
	          OUT_AS2 (mov, w, %D3);
	          OUT_AS2 (sub, w, %D0);
	          OUT_AS2 (mov, w, %C3);
	          OUT_AS2 (subc, w, %C0);
	          OUT_AS2 (mov, w, %B3);
	          OUT_AS2 (subc, w, %B0);
	          OUT_AS2 (mov, w, %A3);
	          OUT_AS2 (subc, w, %A0);
	          OUT_AS1 (snc,);
	          OUT_AS1 (page, %2);
	          OUT_AS1 (jmp, %2);
		}
	    }
	  else
	    {
	      OUT_AS2 (mov, w, %D0);
	      OUT_AS2 (sub, w, %D1);
	      OUT_AS2 (mov, w, %C0);
	      OUT_AS2 (subc, w, %C1);
	      OUT_AS2 (mov, w, %B0);
	      OUT_AS2 (subc, w, %B1);
	      OUT_AS2 (mov, w, %A0);
	      OUT_AS2 (subc, w, %A1);
	      OUT_AS1 (sc,);
	      OUT_AS1 (page, %2);
	      OUT_AS1 (jmp, %2);
	    }
	  break;

	case GEU:
	  if (imm_sub)
	    {
	      if (INTVAL (operands[0]) == 0)
		{
                  OUT_AS2 (mov, w, %A1);
                  OUT_AS2 (or, w, %B1);
                  OUT_AS2 (or, w, %C1);
                  OUT_AS2 (or, w, %D1);
		  OUT_AS1 (snz,);
	          OUT_AS1 (page, %2);
	          OUT_AS1 (jmp, %2);
		}
	      else
	        {
	          operands[3] = GEN_INT (INTVAL (operands[0]) - 1);
	          OUT_AS2 (mov, w, %D3);
	          OUT_AS2 (sub, w, %D1);
	          OUT_AS2 (mov, w, %C3);
	          OUT_AS2 (subc, w, %C1);
	          OUT_AS2 (mov, w, %B3);
	          OUT_AS2 (subc, w, %B1);
	          OUT_AS2 (mov, w, %A3);
	          OUT_AS2 (subc, w, %A1);
	          OUT_AS1 (sc,);
	          OUT_AS1 (page, %2);
	          OUT_AS1 (jmp, %2);
		}
	    }
	  else
	    {
	      OUT_AS2 (mov, w, %D1);
	      OUT_AS2 (sub, w, %D0);
	      OUT_AS2 (mov, w, %C1);
	      OUT_AS2 (subc, w, %C0);
	      OUT_AS2 (mov, w, %B1);
	      OUT_AS2 (subc, w, %B0);
	      OUT_AS2 (mov, w, %A1);
	      OUT_AS2 (subc, w, %A0);
	      OUT_AS1 (snc,);
	      OUT_AS1 (page, %2);
	      OUT_AS1 (jmp, %2);
	    }
	  break;

	case LTU:
	  if (imm_sub)
	    {
	      if (INTVAL (operands[0]) == 0)
	        {
                  OUT_AS2 (mov, w, %A1);
                  OUT_AS2 (or, w, %B1);
                  OUT_AS2 (or, w, %C1);
                  OUT_AS2 (or, w, %D1);
		  OUT_AS1 (sz,);
	          OUT_AS1 (page, %2);
	          OUT_AS1 (jmp, %2);
		}
	      else
	        {
	          operands[3] = GEN_INT (INTVAL (operands[0]) - 1);
	          OUT_AS2 (mov, w, %D3);
	          OUT_AS2 (sub, w, %D1);
	          OUT_AS2 (mov, w, %C3);
	          OUT_AS2 (subc, w, %C1);
	          OUT_AS2 (mov, w, %B3);
	          OUT_AS2 (subc, w, %B1);
	          OUT_AS2 (mov, w, %A3);
	          OUT_AS2 (subc, w, %A1);
	          OUT_AS1 (snc,);
	          OUT_AS1 (page, %2);
	          OUT_AS1 (jmp, %2);
	        }
	    }
	  else
	    {
	      OUT_AS2 (mov, w, %D1);
	      OUT_AS2 (sub, w, %D0);
	      OUT_AS2 (mov, w, %C1);
	      OUT_AS2 (subc, w, %C0);
	      OUT_AS2 (mov, w, %B1);
	      OUT_AS2 (subc, w, %B0);
	      OUT_AS2 (mov, w, %A1);
	      OUT_AS2 (subc, w, %A0);
	      OUT_AS1 (sc,);
	      OUT_AS1 (page, %2);
	      OUT_AS1 (jmp, %2);
	    }
	  break;

	case LEU:
	  if (imm_sub)
	    {
	      if ((unsigned HOST_WIDE_INT)(INTVAL (operands[1]) & 0xffffffff)
		  == 0xffffffff)
	        {
		  /* <= 0xffffffff always suceeds.  */
		  OUT_AS1 (page, %2);
	          OUT_AS1 (jmp, %2);
		}
	      else
		{
	          operands[3] = GEN_INT (INTVAL (operands[1]) + 1);
	          OUT_AS2 (mov, w, %D3);
	          OUT_AS2 (sub, w, %D0);
	          OUT_AS2 (mov, w, %C3);
	          OUT_AS2 (subc, w, %C0);
	          OUT_AS2 (mov, w, %B3);
	          OUT_AS2 (subc, w, %B0);
	          OUT_AS2 (mov, w, %A3);
	          OUT_AS2 (subc, w, %A0);
	          OUT_AS1 (sc,);
	          OUT_AS1 (page, %2);
	          OUT_AS1 (jmp, %2);
		}
	    }
	  else
	    {
	      OUT_AS2 (mov, w, %D0);
	      OUT_AS2 (sub, w, %D1);
	      OUT_AS2 (mov, w, %C0);
	      OUT_AS2 (subc, w, %C1);
	      OUT_AS2 (mov, w, %B0);
	      OUT_AS2 (subc, w, %B1);
	      OUT_AS2 (mov, w, %A0);
	      OUT_AS2 (subc, w, %A1);
	      OUT_AS1 (snc,);
	      OUT_AS1 (page, %2);
	      OUT_AS1 (jmp, %2);
	    }
	  break;

	default:
	  abort ();
        }
      break;

    case DImode:
      if (GET_CODE (operands[1]) == CONST_INT)
	{
	  const_low = INTVAL (operands[1]);
	  const_high = (const_low >= 0) - 1;
	}
      else if (GET_CODE (operands[1]) == CONST_DOUBLE)
	{
	  const_low = CONST_DOUBLE_LOW (operands[1]);
	  const_high = CONST_DOUBLE_HIGH (operands[1]);
	}
      switch (code)
        {
	case EQ:
	  {
	    unsigned char s = 0, t = 1, u = 2, v = 3;
	    unsigned char w = 4, x = 5, y = 6, z = 7;
	    if (optimize_size)
	      {
		if (GET_CODE (operands[0]) == MEM
		    && true_regnum (XEXP (operands[0], 0)) == REG_DP)
		  {
		    OUT_AS1 (push, %Z1%<);
		    OUT_AS1 (push, %Y1%<);
		    OUT_AS1 (push, %X1%<);
		    OUT_AS1 (push, %W1%<);
		    OUT_AS1 (push, %V1%<);
		    OUT_AS1 (push, %U1%<);
		    OUT_AS1 (push, %T1%<);
		    OUT_AS1 (push, %S1%>%>%>%>%>%>%>);
		    OUT_AS1 (page, __cmpdi2_dp);
		    OUT_AS1 (call, __cmpdi2_dp);
		    OUT_AS2 (csne, w, #1);
		    OUT_AS1 (page, %2);
		    OUT_AS1 (jmp, %2);
		  }
		else
		  {
		    OUT_AS1 (push, %Z1%<);
		    OUT_AS1 (push, %Y1%<);
		    OUT_AS1 (push, %X1%<);
		    OUT_AS1 (push, %W1%<);
		    OUT_AS1 (push, %V1%<);
		    OUT_AS1 (push, %U1%<);
		    OUT_AS1 (push, %T1%<);
		    OUT_AS1 (push, %S1%<);
		    OUT_AS1 (push, %Z0%<);
		    OUT_AS1 (push, %Y0%<);
		    OUT_AS1 (push, %X0%<);
		    OUT_AS1 (push, %W0%<);
		    OUT_AS1 (push, %V0%<);
		    OUT_AS1 (push, %U0%<);
		    OUT_AS1 (push, %T0%<);
		    OUT_AS1 (push, %S0%>%>%>%>%>%>%>%>%>%>%>%>%>%>%>);
		    OUT_AS1 (page, __cmpdi2);
		    OUT_AS1 (call, __cmpdi2);
		    OUT_AS2 (csne, w, #1);
		    OUT_AS1 (page, %2);
		    OUT_AS1 (jmp, %2);
		  }
	      }
	    else
	      {
		if (imm_cmp)
		  {
		    s = (const_high >> 24) & 0xff;
		    t = (const_high >> 16) & 0xff;
		    u = (const_high >> 8) & 0xff;
		    v = const_high & 0xff;
		    w = (const_low >> 24) & 0xff;
		    x = (const_low >> 16) & 0xff;
		    y = (const_low >> 8) & 0xff;
		    z = const_low & 0xff;
		  }

		OUT_AS2 (mov, w, %S1);
		if (imm_cmp && (s == t))
		  {
		    OUT_AS2 (csne, w, %S0);
		    OUT_AS2 (cse, w, %T0);
		  }
		else
		  {
		    OUT_AS2 (cse, w, %S0);
		    OUT_AS1 (page, 2f);
		    OUT_AS1 (jmp, 2f);
		    OUT_AS2 (mov, w, %T1);
		    OUT_AS2 (cse, w, %T0);
		  }
		OUT_AS1 (page, 2f);
		OUT_AS1 (jmp, 2f);

		OUT_AS2 (mov, w, %U1);
		if (imm_cmp && (u == v))
		  {
		    OUT_AS2 (csne, w, %U0);
		    OUT_AS2 (cse, w, %V0);
		  }
		else
		  {
		    OUT_AS2 (cse, w, %U0);
		    OUT_AS1 (page, 2f);
		    OUT_AS1 (jmp, 2f);
		    OUT_AS2 (mov, w, %V1);
		    OUT_AS2 (cse, w, %V0);
		  }
		OUT_AS1 (page, 2f);
		OUT_AS1 (jmp, 2f);

		OUT_AS2 (mov, w, %W1);
		if (imm_cmp && (w == x))
		  {
		    OUT_AS2 (csne, w, %W0);
		    OUT_AS2 (cse, w, %X0);
		  }
		else
		  {
		    OUT_AS2 (cse, w, %W0);
		    OUT_AS1 (page, 2f);
		    OUT_AS1 (jmp, 2f);
		    OUT_AS2 (mov, w, %X1);
		    OUT_AS2 (cse, w, %X0);
		  }
		OUT_AS1 (page, 2f);
		OUT_AS1 (jmp, 2f);

		if (! imm_cmp || (x != y))
		  OUT_AS2 (mov, w, %Y1);
		OUT_AS2 (cse, w, %Y0);
		OUT_AS1 (page, 2f);
		OUT_AS1 (jmp, 2f);
		if (! imm_cmp || (z != y))
		  OUT_AS2 (mov, w, %Z1);
		OUT_AS2 (csne, w, %Z0);
		OUT_AS1 (page, %2);
		OUT_AS1 (jmp, %2);
		OUT_AS1 (2:,);
	      }
	  }
	  break;

	case NE:
	  {
	    unsigned char s = 0, t = 1, u = 2, v = 3;
	    unsigned char w = 4, x = 5, y = 6, z = 7;
	    
	    if (optimize_size)
	      {
		if (GET_CODE (operands[0]) == MEM
		    && true_regnum (XEXP (operands[0], 0)) == REG_DP)
		  {
		    OUT_AS1 (push, %Z1%<);
		    OUT_AS1 (push, %Y1%<);
		    OUT_AS1 (push, %X1%<);
		    OUT_AS1 (push, %W1%<);
		    OUT_AS1 (push, %V1%<);
		    OUT_AS1 (push, %U1%<);
		    OUT_AS1 (push, %T1%<);
		    OUT_AS1 (push, %S1%>%>%>%>%>%>%>);
		    OUT_AS1 (page, __cmpdi2_dp);
		    OUT_AS1 (call, __cmpdi2_dp);
		    OUT_AS2 (cse, w, #1);
		    OUT_AS1 (page, %2);
		    OUT_AS1 (jmp, %2);
		  }
		else
		  {
		    OUT_AS1 (push, %Z1%<);
		    OUT_AS1 (push, %Y1%<);
		    OUT_AS1 (push, %X1%<);
		    OUT_AS1 (push, %W1%<);
		    OUT_AS1 (push, %V1%<);
		    OUT_AS1 (push, %U1%<);
		    OUT_AS1 (push, %T1%<);
		    OUT_AS1 (push, %S1%<);
		    OUT_AS1 (push, %Z0%<);
		    OUT_AS1 (push, %Y0%<);
		    OUT_AS1 (push, %X0%<);
		    OUT_AS1 (push, %W0%<);
		    OUT_AS1 (push, %V0%<);
		    OUT_AS1 (push, %U0%<);
		    OUT_AS1 (push, %T0%<);
		    OUT_AS1 (push, %S0%>%>%>%>%>%>%>%>%>%>%>%>%>%>%>);
		    OUT_AS1 (page, __cmpdi2);
		    OUT_AS1 (call, __cmpdi2);
		    OUT_AS2 (cse, w, #1);
		    OUT_AS1 (page, %2);
		    OUT_AS1 (jmp, %2);
		  }
	      }
	    else
	      {
		if (imm_cmp)
		  {
		    s = (const_high >> 24) & 0xff;
		    t = (const_high >> 16) & 0xff;
		    u = (const_high >> 8) & 0xff;
		    v = const_high & 0xff;
		    w = (const_low >> 24) & 0xff;
		    x = (const_low >> 16) & 0xff;
		    y = (const_low >> 8) & 0xff;
		    z = const_low & 0xff;
		  }

		OUT_AS2 (mov, w, %S1);
		if (imm_cmp && (s == t))
		  {
		    OUT_AS2 (csne, w, %S0);
		    OUT_AS2 (cse, w, %T0);
		  }
		else
		  {
		    OUT_AS2 (cse, w, %S0);
		    OUT_AS1 (page, %2);
		    OUT_AS1 (jmp, %2);
		    OUT_AS2 (mov, w, %T1);
		    OUT_AS2 (cse, w, %T0);
		  }
		OUT_AS1 (page, %2);
		OUT_AS1 (jmp, %2);

		OUT_AS2 (mov, w, %U1);
		if (imm_cmp && (u == v))
		  {
		    OUT_AS2 (csne, w, %U0);
		    OUT_AS2 (cse, w, %V0);
		  }
		else
		  {
		    OUT_AS2 (cse, w, %U0);
		    OUT_AS1 (page, %2);
		    OUT_AS1 (jmp, %2);
		    OUT_AS2 (mov, w, %V1);
		    OUT_AS2 (cse, w, %V0);
		  }
		OUT_AS1 (page, %2);
		OUT_AS1 (jmp, %2);

		OUT_AS2 (mov, w, %W1);
		if (imm_cmp && (w == x))
		  {
		    OUT_AS2 (csne, w, %W0);
		    OUT_AS2 (cse, w, %X0);
		  }
		else
		  {
		    OUT_AS2 (cse, w, %W0);
		    OUT_AS1 (page, %2);
		    OUT_AS1 (jmp, %2);
		    OUT_AS2 (mov, w, %X1);
		    OUT_AS2 (cse, w, %X0);
		  }
		OUT_AS1 (page, %2);
		OUT_AS1 (jmp, %2);

		if (! imm_cmp || (y != x))
		  OUT_AS2 (mov, w, %Y1);
		if (imm_cmp && (z == y))
		  {
		    OUT_AS2 (csne, w, %Y0);
		    OUT_AS2 (cse, w, %Z0);
		  }
		else
		  {
		    OUT_AS2 (cse, w, %Y0);
		    OUT_AS1 (page, %2);
		    OUT_AS1 (jmp, %2);
		    OUT_AS2 (mov, w, %Z1);
		    OUT_AS2 (cse, w, %Z0);
		  }
		OUT_AS1 (page, %2);
		OUT_AS1 (jmp, %2);
	      }
	  }
	  break;

	case GTU:
	  if (imm_sub)
	    {
	      /* > 0xffffffffffffffff never suceeds!  */
	      if (((const_high & 0xffffffff) != 0xffffffff)
		  || ((const_low & 0xffffffff) != 0xffffffff))
		{
	          operands[3] = GEN_INT (const_low + 1);
		  operands[4] = GEN_INT (const_high
					 + (INTVAL (operands[3]) ? 0 : 1));
	          OUT_AS2 (mov, w, %D3);
	          OUT_AS2 (sub, w, %Z0);
	          OUT_AS2 (mov, w, %C3);
	          OUT_AS2 (subc, w, %Y0);
	          OUT_AS2 (mov, w, %B3);
	          OUT_AS2 (subc, w, %X0);
	          OUT_AS2 (mov, w, %A3);
	          OUT_AS2 (subc, w, %W0);
	          O