home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / gnu / ae / patch-1.36 < prev    next >
Encoding:
Text File  |  1990-02-28  |  12.1 KB  |  353 lines
  1. *** gcc/config/mips.md.orig    Thu Sep 21 11:06:18 1989
  2. --- gcc/config/mips.md    Wed Dec 20 14:38:31 1989
  3. ***************
  4. *** 528,534 ****
  5.   (define_insn "andsi3"
  6.     [(set (match_operand:SI 0 "general_operand" "=r,&r")
  7.       (and:SI (match_operand:SI 1 "general_operand" "%r,r")
  8. !         (match_operand:SI 2 "general_operand" "rJ,I")))]
  9.     ""
  10.     "*
  11.   {
  12. --- 528,534 ----
  13.   (define_insn "andsi3"
  14.     [(set (match_operand:SI 0 "general_operand" "=r,&r")
  15.       (and:SI (match_operand:SI 1 "general_operand" "%r,r")
  16. !         (match_operand:SI 2 "general_operand" "rJ,K")))]
  17.     ""
  18.     "*
  19.   {
  20. ***************
  21. *** 535,541 ****
  22.     rtx xops[3];
  23.     if (GET_CODE (operands[2]) == CONST_INT)
  24.       {
  25. !       if (CONST_OK_FOR_LETTER_P (INTVAL (operands[2]), 'I'))
  26.       if (INTVAL (operands[2]) >= 0)
  27.         {
  28.           return \"andi\\t%0,%1,%x2\\t#andsi3\\t%1,%d2 -> %0\";
  29. --- 535,541 ----
  30.     rtx xops[3];
  31.     if (GET_CODE (operands[2]) == CONST_INT)
  32.       {
  33. !       if (CONST_OK_FOR_LETTER_P (INTVAL (operands[2]), 'K'))
  34.       if (INTVAL (operands[2]) >= 0)
  35.         {
  36.           return \"andi\\t%0,%1,%x2\\t#andsi3\\t%1,%d2 -> %0\";
  37. ***************
  38. *** 607,619 ****
  39.   (define_insn "iorsi3"
  40.     [(set (match_operand:SI 0 "general_operand" "=r")
  41.       (ior:SI (match_operand:SI 1 "general_operand" "%r")
  42. !         (match_operand:SI 2 "general_operand" "rIJ")))]
  43.     ""
  44.     "*
  45.   {
  46.     if (GET_CODE (operands[2]) == CONST_INT)
  47.       {
  48. !       if (CONST_OK_FOR_LETTER_P (INTVAL (operands[2]), 'I'))
  49.       {
  50.         return \"ori\\t%0,%1,%x2\\t#iorsi3\\t%1,%d2 -> %0\";
  51.       }
  52. --- 607,619 ----
  53.   (define_insn "iorsi3"
  54.     [(set (match_operand:SI 0 "general_operand" "=r")
  55.       (ior:SI (match_operand:SI 1 "general_operand" "%r")
  56. !         (match_operand:SI 2 "general_operand" "rKJ")))]
  57.     ""
  58.     "*
  59.   {
  60.     if (GET_CODE (operands[2]) == CONST_INT)
  61.       {
  62. !       if (CONST_OK_FOR_LETTER_P (INTVAL (operands[2]), 'K'))
  63.       {
  64.         return \"ori\\t%0,%1,%x2\\t#iorsi3\\t%1,%d2 -> %0\";
  65.       }
  66. ***************
  67. *** 669,681 ****
  68.   (define_insn "xorsi3"
  69.     [(set (match_operand:SI 0 "general_operand" "=r")
  70.       (xor:SI (match_operand:SI 1 "general_operand" "%r")
  71. !         (match_operand:SI 2 "general_operand" "rIJ")))]
  72.     ""
  73.     "*
  74.   {
  75.     if (GET_CODE (operands[2]) == CONST_INT)
  76.       {
  77. !       if (CONST_OK_FOR_LETTER_P (INTVAL (operands[2]), 'I'))
  78.       {
  79.         return \"xori\\t%0,%1,%x2\\t#xorsi3\\t%1,%d2 -> %0\";
  80.       }
  81. --- 669,681 ----
  82.   (define_insn "xorsi3"
  83.     [(set (match_operand:SI 0 "general_operand" "=r")
  84.       (xor:SI (match_operand:SI 1 "general_operand" "%r")
  85. !         (match_operand:SI 2 "general_operand" "rKJ")))]
  86.     ""
  87.     "*
  88.   {
  89.     if (GET_CODE (operands[2]) == CONST_INT)
  90.       {
  91. !       if (CONST_OK_FOR_LETTER_P (INTVAL (operands[2]), 'K'))
  92.       {
  93.         return \"xori\\t%0,%1,%x2\\t#xorsi3\\t%1,%d2 -> %0\";
  94.       }
  95. *** gcc/config/tm-mips.h.orig    Sat Sep 23 23:52:22 1989
  96. --- gcc/config/tm-mips.h    Mon Dec  4 14:42:42 1989
  97. ***************
  98. *** 546,562 ****
  99.      C is the letter, and VALUE is a constant value.
  100.      Return 1 if VALUE is in the range specified by C.  */
  101.   
  102. ! /*   For MIPS, `I' is used for the range of constants an insn
  103. !                    can actually contain (16 bits signed integers).
  104.                  `J' is used for the range which is just zero (since that is
  105.                  available as $R0).
  106.   */
  107.   
  108. ! #define SMALL_INT(X) ((unsigned) (INTVAL (X) + 0x10000) < 0x20000)
  109.   
  110.   #define CONST_OK_FOR_LETTER_P(VALUE, C)                    \
  111. !   ((C) == 'I' ? (unsigned) ((VALUE) + 0x10000) < 0x20000        \
  112.      : (C) == 'J' ? (VALUE) == 0                        \
  113.      : 0)
  114.   
  115.   /* Similar, but for floating constants, and defining letters G and H.
  116. --- 546,566 ----
  117.      C is the letter, and VALUE is a constant value.
  118.      Return 1 if VALUE is in the range specified by C.  */
  119.   
  120. ! /*   For MIPS, `I' is used for the range of constants an arithmetic insn
  121. !                    can actually contain (16 bits sign-extended integers).
  122.                  `J' is used for the range which is just zero (since that is
  123.                  available as $R0).
  124. +            `K' is used for the range of constants a logical insn
  125. +                can actually contain (16 bit zero-extended integers).
  126.   */
  127.   
  128. ! #define SMALL_INT_SX(X) ((-32768 <= (X)) && ((X) <= 32767))
  129. ! #define SMALL_INT_ZX(X) ((0 <= (X)) && ((X) <= 65535))
  130.   
  131.   #define CONST_OK_FOR_LETTER_P(VALUE, C)                    \
  132. !   ((C) == 'I' ? SMALL_INT_SX (VALUE)                    \
  133.      : (C) == 'J' ? (VALUE) == 0                        \
  134. +    : (C) == 'K' ? SMALL_INT_ZX (VALUE)                    \
  135.      : 0)
  136.   
  137.   /* Similar, but for floating constants, and defining letters G and H.
  138. ***************
  139. *** 867,873 ****
  140.   #define FUNCTION_PROLOGUE(FILE, SIZE)                    \
  141.   { register int regno;                            \
  142.     register int mask = 0, fmask=0;                    \
  143. !   static char dont_save_regs[] = CALL_USED_REGISTERS;            \
  144.     register int push_loc = 0,tsize = SIZE+8;                \
  145.     char *fp_str;                                \
  146.     extern char *reg_numchar[];                        \
  147. --- 871,877 ----
  148.   #define FUNCTION_PROLOGUE(FILE, SIZE)                    \
  149.   { register int regno;                            \
  150.     register int mask = 0, fmask=0;                    \
  151. !   extern char call_used_regs [];                    \
  152.     register int push_loc = 0,tsize = SIZE+8;                \
  153.     char *fp_str;                                \
  154.     extern char *reg_numchar[];                        \
  155. ***************
  156. *** 877,886 ****
  157.       : reg_numchar[STACK_POINTER_REGNUM];                \
  158.     for (regno = 0; regno < 32; regno++)                    \
  159.       if (  MUST_SAVE_REG_LOGUES                        \
  160. !     || (regs_ever_live[regno] && !dont_save_regs[regno]))        \
  161.         {tsize += 4; mask |= 1 << regno;}                    \
  162.     for (regno = 32; regno < FIRST_PSEUDO_REGISTER; regno += 2)        \
  163. !     if (regs_ever_live[regno] && !dont_save_regs[regno])        \
  164.         {tsize += 8; fmask |= 1 << (regno-32);}                \
  165.     if (THIS_VARARGS_SUSPECTED) tsize += 16;                \
  166.     fprintf (FILE," #PROLOGUE\n");                    \
  167. --- 881,890 ----
  168.       : reg_numchar[STACK_POINTER_REGNUM];                \
  169.     for (regno = 0; regno < 32; regno++)                    \
  170.       if (  MUST_SAVE_REG_LOGUES                        \
  171. !     || (regs_ever_live[regno] && !call_used_regs[regno]))        \
  172.         {tsize += 4; mask |= 1 << regno;}                    \
  173.     for (regno = 32; regno < FIRST_PSEUDO_REGISTER; regno += 2)        \
  174. !     if (regs_ever_live[regno] && !call_used_regs[regno])        \
  175.         {tsize += 8; fmask |= 1 << (regno-32);}                \
  176.     if (THIS_VARARGS_SUSPECTED) tsize += 16;                \
  177.     fprintf (FILE," #PROLOGUE\n");                    \
  178. ***************
  179. *** 910,916 ****
  180.     for  (regno = 31; regno >= 30; regno--)                \
  181.       {                                    \
  182.         if (MUST_SAVE_REG_LOGUES                        \
  183. !       || (regs_ever_live[regno] && !dont_save_regs[regno]))        \
  184.       {                                \
  185.         fprintf (FILE, "\tsw\t%s,%d(%s)\n",                \
  186.              TARGET_NAME_REGS ? reg_names[regno] : reg_numchar[regno], \
  187. --- 914,920 ----
  188.     for  (regno = 31; regno >= 30; regno--)                \
  189.       {                                    \
  190.         if (MUST_SAVE_REG_LOGUES                        \
  191. !       || (regs_ever_live[regno] && !call_used_regs[regno]))        \
  192.       {                                \
  193.         fprintf (FILE, "\tsw\t%s,%d(%s)\n",                \
  194.              TARGET_NAME_REGS ? reg_names[regno] : reg_numchar[regno], \
  195. ***************
  196. *** 939,945 ****
  197.     for (regno = 29; regno >= 0; regno--)                    \
  198.       {                                    \
  199.         if (MUST_SAVE_REG_LOGUES                        \
  200. !       || (regs_ever_live[regno] && !dont_save_regs[regno]))        \
  201.       {                                \
  202.         fprintf (FILE, "\tsw\t%s,%d(%s)\n",                \
  203.              TARGET_NAME_REGS ? reg_names[regno] : reg_numchar[regno], \
  204. --- 943,949 ----
  205.     for (regno = 29; regno >= 0; regno--)                    \
  206.       {                                    \
  207.         if (MUST_SAVE_REG_LOGUES                        \
  208. !       || (regs_ever_live[regno] && !call_used_regs[regno]))        \
  209.       {                                \
  210.         fprintf (FILE, "\tsw\t%s,%d(%s)\n",                \
  211.              TARGET_NAME_REGS ? reg_names[regno] : reg_numchar[regno], \
  212. ***************
  213. *** 949,955 ****
  214.       }                                    \
  215.     fprintf (FILE, " #\t.fmask\t0x%x\n", fmask);                \
  216.     for  (regno = 32; regno < FIRST_PSEUDO_REGISTER; regno += 2)        \
  217. !     if (regs_ever_live[regno] && !dont_save_regs[regno])        \
  218.         {                                    \
  219.       fprintf (FILE, "\ts.d\t%s,%d(%s)\n",                \
  220.            (TARGET_NAME_REGS) ? reg_names[regno] : reg_numchar[regno], \
  221. --- 953,959 ----
  222.       }                                    \
  223.     fprintf (FILE, " #\t.fmask\t0x%x\n", fmask);                \
  224.     for  (regno = 32; regno < FIRST_PSEUDO_REGISTER; regno += 2)        \
  225. !     if (regs_ever_live[regno] && !call_used_regs[regno])        \
  226.         {                                    \
  227.       fprintf (FILE, "\ts.d\t%s,%d(%s)\n",                \
  228.            (TARGET_NAME_REGS) ? reg_names[regno] : reg_numchar[regno], \
  229. ***************
  230. *** 1011,1017 ****
  231.     register int fmask = 0;                        \
  232.     char *fp_str;                                \
  233.     char *sp_str;                                \
  234. !   static char dont_save_regs[] = CALL_USED_REGISTERS;            \
  235.     register int push_loc ;                        \
  236.     extern char *reg_numchar[];                        \
  237.     extern char *current_function_name;                    \
  238. --- 1015,1021 ----
  239.     register int fmask = 0;                        \
  240.     char *fp_str;                                \
  241.     char *sp_str;                                \
  242. !   extern char call_used_regs [];                    \
  243.     register int push_loc ;                        \
  244.     extern char *reg_numchar[];                        \
  245.     extern char *current_function_name;                    \
  246. ***************
  247. *** 1033,1044 ****
  248.            );                                \
  249.     for  (regno = 0; regno < 32; regno++)                    \
  250.       if  ( MUST_SAVE_REG_LOGUES                        \
  251. !      || (regs_ever_live[regno] && !dont_save_regs[regno]))        \
  252.         mask |= 1 << regno;                        \
  253.     fprintf  (FILE, " #\t.mask\t0x%x\n", mask);                \
  254.     for  (regno = 31; regno >= 0; regno--)                \
  255.       { if  ( MUST_SAVE_REG_LOGUES                    \
  256. !        || (regs_ever_live[regno] && !dont_save_regs[regno]))    \
  257.       {                                \
  258.         fprintf (FILE,"\tlw\t%s,%d(%s)\n",                \
  259.              TARGET_NAME_REGS ? reg_names[regno]            \
  260. --- 1037,1048 ----
  261.            );                                \
  262.     for  (regno = 0; regno < 32; regno++)                    \
  263.       if  ( MUST_SAVE_REG_LOGUES                        \
  264. !      || (regs_ever_live[regno] && !call_used_regs[regno]))        \
  265.         mask |= 1 << regno;                        \
  266.     fprintf  (FILE, " #\t.mask\t0x%x\n", mask);                \
  267.     for  (regno = 31; regno >= 0; regno--)                \
  268.       { if  ( MUST_SAVE_REG_LOGUES                    \
  269. !        || (regs_ever_live[regno] && !call_used_regs[regno]))    \
  270.       {                                \
  271.         fprintf (FILE,"\tlw\t%s,%d(%s)\n",                \
  272.              TARGET_NAME_REGS ? reg_names[regno]            \
  273. ***************
  274. *** 1052,1063 ****
  275.         if ( THIS_VARARGS_SUSPECTED &&  (regno == 30)) push_loc += 16;    \
  276.       }                                    \
  277.     for  (regno = 32; regno < FIRST_PSEUDO_REGISTER; regno += 2)        \
  278. !     if  (regs_ever_live[regno] && !dont_save_regs[regno])        \
  279.         fmask |= 1 <<  (regno-32);                    \
  280.     fprintf  (FILE, " #\t.fmask\t0x%x\n", fmask);                \
  281.       for  (regno = 32; regno < FIRST_PSEUDO_REGISTER; regno += 2)    \
  282.       {                                    \
  283. !       if  (regs_ever_live[regno] && !dont_save_regs[regno])        \
  284.       {                                \
  285.         fprintf (FILE,"\tl.d\t%s,%d(%s)\n",                \
  286.              ( ( TARGET_NAME_REGS) ? reg_names[regno]        \
  287. --- 1056,1067 ----
  288.         if ( THIS_VARARGS_SUSPECTED &&  (regno == 30)) push_loc += 16;    \
  289.       }                                    \
  290.     for  (regno = 32; regno < FIRST_PSEUDO_REGISTER; regno += 2)        \
  291. !     if  (regs_ever_live[regno] && !call_used_regs[regno])        \
  292.         fmask |= 1 <<  (regno-32);                    \
  293.     fprintf  (FILE, " #\t.fmask\t0x%x\n", fmask);                \
  294.       for  (regno = 32; regno < FIRST_PSEUDO_REGISTER; regno += 2)    \
  295.       {                                    \
  296. !       if  (regs_ever_live[regno] && !call_used_regs[regno])        \
  297.       {                                \
  298.         fprintf (FILE,"\tl.d\t%s,%d(%s)\n",                \
  299.              ( ( TARGET_NAME_REGS) ? reg_names[regno]        \
  300. *** gcc/config/xm-mips.h.orig    Wed Apr  5 16:25:08 1989
  301. --- gcc/config/xm-mips.h    Mon Dec  4 14:43:27 1989
  302. ***************
  303. *** 35,37 ****
  304. --- 35,46 ----
  305.   /* Arguments to use with `exit'.  */
  306.   #define SUCCESS_EXIT_CODE 0
  307.   #define FATAL_EXIT_CODE 33
  308. + 
  309. + /* If compiled with GNU C, use the built-in alloca.  If not, we're
  310. + using the native (Gwyn/Stallman PD) version.  */
  311. + #ifdef __GNUC__
  312. + #define alloca __builtin_alloca
  313. + #else
  314. + #define USE_C_ALLOCA
  315. + #endif
  316. + 
  317. *** gcc/config/out-mips.c.orig    Mon Feb 12 08:55:48 1990
  318. --- gcc/config/out-mips.c    Tue Dec  5 08:46:57 1989
  319. ***************
  320. *** 38,44 ****
  321.        enum machine_mode mode;
  322.   {
  323.     return (register_operand (op, mode)
  324. !       || (GET_CODE (op) == CONST_INT && SMALL_INT (op)));
  325.   }
  326.   
  327.   /* Return truth value of whether OP can be used as an operand in a two
  328. --- 38,44 ----
  329.        enum machine_mode mode;
  330.   {
  331.     return (register_operand (op, mode)
  332. !       || (GET_CODE (op) == CONST_INT && SMALL_INT_SX (INTVAL (op))));
  333.   }
  334.   
  335.   /* Return truth value of whether OP can be used as an operand in a two
  336. ***************
  337. *** 59,65 ****
  338.        rtx op;
  339.        enum machine_mode mode;
  340.   {
  341. !   return (GET_CODE (op) == CONST_INT && SMALL_INT (op));
  342.   }
  343.   
  344.   
  345. --- 59,65 ----
  346.        rtx op;
  347.        enum machine_mode mode;
  348.   {
  349. !   return (GET_CODE (op) == CONST_INT && SMALL_INT_ZX (INTVAL (op)));
  350.   }
  351.   
  352.   
  353.