OSDN Git Service

bc384ee2e14960022a919419ec903483e12988b8
[pf3gnuchains/gcc-fork.git] / gcc / config / c4x / c4x.c
1 /* Subroutines for assembler code output on the TMS320C[34]x
2    Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004
3    Free Software Foundation, Inc.
4
5    Contributed by Michael Hayes (m.hayes@elec.canterbury.ac.nz)
6               and Herman Ten Brugge (Haj.Ten.Brugge@net.HCC.nl).
7
8 This file is part of GCC.
9
10 GCC is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2, or (at your option)
13 any later version.
14
15 GCC is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING.  If not, write to
22 the Free Software Foundation, 59 Temple Place - Suite 330,
23 Boston, MA 02111-1307, USA.  */
24
25 /* Some output-actions in c4x.md need these.  */
26 #include "config.h"
27 #include "system.h"
28 #include "coretypes.h"
29 #include "tm.h"
30 #include "rtl.h"
31 #include "tree.h"
32 #include "regs.h"
33 #include "hard-reg-set.h"
34 #include "basic-block.h"
35 #include "real.h"
36 #include "insn-config.h"
37 #include "insn-attr.h"
38 #include "conditions.h"
39 #include "output.h"
40 #include "function.h"
41 #include "expr.h"
42 #include "optabs.h"
43 #include "libfuncs.h"
44 #include "flags.h"
45 #include "loop.h"
46 #include "recog.h"
47 #include "ggc.h"
48 #include "cpplib.h"
49 #include "toplev.h"
50 #include "tm_p.h"
51 #include "target.h"
52 #include "target-def.h"
53
54 rtx smulhi3_libfunc;
55 rtx umulhi3_libfunc;
56 rtx fix_truncqfhi2_libfunc;
57 rtx fixuns_truncqfhi2_libfunc;
58 rtx fix_trunchfhi2_libfunc;
59 rtx fixuns_trunchfhi2_libfunc;
60 rtx floathiqf2_libfunc;
61 rtx floatunshiqf2_libfunc;
62 rtx floathihf2_libfunc;
63 rtx floatunshihf2_libfunc;
64
65 static int c4x_leaf_function;
66
67 static const char *const float_reg_names[] = FLOAT_REGISTER_NAMES;
68
69 /* Array of the smallest class containing reg number REGNO, indexed by
70    REGNO.  Used by REGNO_REG_CLASS in c4x.h.  We assume that all these
71    registers are available and set the class to NO_REGS for registers 
72    that the target switches say are unavailable.  */
73
74 enum reg_class c4x_regclass_map[FIRST_PSEUDO_REGISTER] =
75 {
76                                 /* Reg          Modes           Saved.  */
77   R0R1_REGS,                    /* R0           QI, QF, HF      No.  */
78   R0R1_REGS,                    /* R1           QI, QF, HF      No.  */
79   R2R3_REGS,                    /* R2           QI, QF, HF      No.  */
80   R2R3_REGS,                    /* R3           QI, QF, HF      No.  */
81   EXT_LOW_REGS,                 /* R4           QI, QF, HF      QI.  */
82   EXT_LOW_REGS,                 /* R5           QI, QF, HF      QI.  */
83   EXT_LOW_REGS,                 /* R6           QI, QF, HF      QF.  */
84   EXT_LOW_REGS,                 /* R7           QI, QF, HF      QF.  */
85   ADDR_REGS,                    /* AR0          QI              No.  */
86   ADDR_REGS,                    /* AR1          QI              No.  */
87   ADDR_REGS,                    /* AR2          QI              No.  */
88   ADDR_REGS,                    /* AR3          QI              QI.  */
89   ADDR_REGS,                    /* AR4          QI              QI.  */
90   ADDR_REGS,                    /* AR5          QI              QI.  */
91   ADDR_REGS,                    /* AR6          QI              QI.  */
92   ADDR_REGS,                    /* AR7          QI              QI.  */
93   DP_REG,                       /* DP           QI              No.  */
94   INDEX_REGS,                   /* IR0          QI              No.  */
95   INDEX_REGS,                   /* IR1          QI              No.  */
96   BK_REG,                       /* BK           QI              QI.  */
97   SP_REG,                       /* SP           QI              No.  */
98   ST_REG,                       /* ST           CC              No.  */
99   NO_REGS,                      /* DIE/IE                       No.  */
100   NO_REGS,                      /* IIE/IF                       No.  */
101   NO_REGS,                      /* IIF/IOF                      No.  */
102   INT_REGS,                     /* RS           QI              No.  */
103   INT_REGS,                     /* RE           QI              No.  */
104   RC_REG,                       /* RC           QI              No.  */
105   EXT_REGS,                     /* R8           QI, QF, HF      QI.  */
106   EXT_REGS,                     /* R9           QI, QF, HF      No.  */
107   EXT_REGS,                     /* R10          QI, QF, HF      No.  */
108   EXT_REGS,                     /* R11          QI, QF, HF      No.  */
109 };
110
111 enum machine_mode c4x_caller_save_map[FIRST_PSEUDO_REGISTER] =
112 {
113                                 /* Reg          Modes           Saved.  */
114   HFmode,                       /* R0           QI, QF, HF      No.  */
115   HFmode,                       /* R1           QI, QF, HF      No.  */
116   HFmode,                       /* R2           QI, QF, HF      No.  */
117   HFmode,                       /* R3           QI, QF, HF      No.  */
118   QFmode,                       /* R4           QI, QF, HF      QI.  */
119   QFmode,                       /* R5           QI, QF, HF      QI.  */
120   QImode,                       /* R6           QI, QF, HF      QF.  */
121   QImode,                       /* R7           QI, QF, HF      QF.  */
122   QImode,                       /* AR0          QI              No.  */
123   QImode,                       /* AR1          QI              No.  */
124   QImode,                       /* AR2          QI              No.  */
125   QImode,                       /* AR3          QI              QI.  */
126   QImode,                       /* AR4          QI              QI.  */
127   QImode,                       /* AR5          QI              QI.  */
128   QImode,                       /* AR6          QI              QI.  */
129   QImode,                       /* AR7          QI              QI.  */
130   VOIDmode,                     /* DP           QI              No.  */
131   QImode,                       /* IR0          QI              No.  */
132   QImode,                       /* IR1          QI              No.  */
133   QImode,                       /* BK           QI              QI.  */
134   VOIDmode,                     /* SP           QI              No.  */
135   VOIDmode,                     /* ST           CC              No.  */
136   VOIDmode,                     /* DIE/IE                       No.  */
137   VOIDmode,                     /* IIE/IF                       No.  */
138   VOIDmode,                     /* IIF/IOF                      No.  */
139   QImode,                       /* RS           QI              No.  */
140   QImode,                       /* RE           QI              No.  */
141   VOIDmode,                     /* RC           QI              No.  */
142   QFmode,                       /* R8           QI, QF, HF      QI.  */
143   HFmode,                       /* R9           QI, QF, HF      No.  */
144   HFmode,                       /* R10          QI, QF, HF      No.  */
145   HFmode,                       /* R11          QI, QF, HF      No.  */
146 };
147
148
149 /* Test and compare insns in c4x.md store the information needed to
150    generate branch and scc insns here.  */
151
152 rtx c4x_compare_op0;
153 rtx c4x_compare_op1;
154
155 const char *c4x_rpts_cycles_string;
156 int c4x_rpts_cycles = 0;        /* Max. cycles for RPTS.  */
157 const char *c4x_cpu_version_string;
158 int c4x_cpu_version = 40;       /* CPU version C30/31/32/33/40/44.  */
159
160 /* Pragma definitions.  */
161
162 tree code_tree = NULL_TREE;
163 tree data_tree = NULL_TREE;
164 tree pure_tree = NULL_TREE;
165 tree noreturn_tree = NULL_TREE;
166 tree interrupt_tree = NULL_TREE;
167 tree naked_tree = NULL_TREE;
168
169 /* Forward declarations */
170 static int c4x_isr_reg_used_p (unsigned int);
171 static int c4x_leaf_function_p (void);
172 static int c4x_naked_function_p (void);
173 static int c4x_immed_float_p (rtx);
174 static int c4x_a_register (rtx);
175 static int c4x_x_register (rtx);
176 static int c4x_immed_int_constant (rtx);
177 static int c4x_immed_float_constant (rtx);
178 static int c4x_K_constant (rtx);
179 static int c4x_N_constant (rtx);
180 static int c4x_O_constant (rtx);
181 static int c4x_R_indirect (rtx);
182 static int c4x_S_indirect (rtx);
183 static void c4x_S_address_parse (rtx , int *, int *, int *, int *);
184 static int c4x_valid_operands (enum rtx_code, rtx *, enum machine_mode, int);
185 static int c4x_arn_reg_operand (rtx, enum machine_mode, unsigned int);
186 static int c4x_arn_mem_operand (rtx, enum machine_mode, unsigned int);
187 static void c4x_file_start (void);
188 static void c4x_file_end (void);
189 static void c4x_check_attribute (const char *, tree, tree, tree *);
190 static int c4x_r11_set_p (rtx);
191 static int c4x_rptb_valid_p (rtx, rtx);
192 static void c4x_reorg (void);
193 static int c4x_label_ref_used_p (rtx, rtx);
194 static tree c4x_handle_fntype_attribute (tree *, tree, tree, int, bool *);
195 const struct attribute_spec c4x_attribute_table[];
196 static void c4x_insert_attributes (tree, tree *);
197 static void c4x_asm_named_section (const char *, unsigned int);
198 static int c4x_adjust_cost (rtx, rtx, rtx, int);
199 static void c4x_globalize_label (FILE *, const char *);
200 static bool c4x_rtx_costs (rtx, int, int, int *);
201 static int c4x_address_cost (rtx);
202 static void c4x_init_libfuncs (void);
203 static void c4x_external_libcall (rtx);
204 static rtx c4x_struct_value_rtx (tree, int);
205 static tree c4x_gimplify_va_arg_expr (tree, tree, tree *, tree *);
206 \f
207 /* Initialize the GCC target structure.  */
208 #undef TARGET_ASM_BYTE_OP
209 #define TARGET_ASM_BYTE_OP "\t.word\t"
210 #undef TARGET_ASM_ALIGNED_HI_OP
211 #define TARGET_ASM_ALIGNED_HI_OP NULL
212 #undef TARGET_ASM_ALIGNED_SI_OP
213 #define TARGET_ASM_ALIGNED_SI_OP NULL
214 #undef TARGET_ASM_FILE_START
215 #define TARGET_ASM_FILE_START c4x_file_start
216 #undef TARGET_ASM_FILE_START_FILE_DIRECTIVE
217 #define TARGET_ASM_FILE_START_FILE_DIRECTIVE true
218 #undef TARGET_ASM_FILE_END
219 #define TARGET_ASM_FILE_END c4x_file_end
220
221 #undef TARGET_ASM_EXTERNAL_LIBCALL
222 #define TARGET_ASM_EXTERNAL_LIBCALL c4x_external_libcall
223
224 #undef TARGET_ATTRIBUTE_TABLE
225 #define TARGET_ATTRIBUTE_TABLE c4x_attribute_table
226
227 #undef TARGET_INSERT_ATTRIBUTES
228 #define TARGET_INSERT_ATTRIBUTES c4x_insert_attributes
229
230 #undef TARGET_INIT_BUILTINS
231 #define TARGET_INIT_BUILTINS c4x_init_builtins
232
233 #undef TARGET_EXPAND_BUILTIN
234 #define TARGET_EXPAND_BUILTIN c4x_expand_builtin
235
236 #undef TARGET_SCHED_ADJUST_COST
237 #define TARGET_SCHED_ADJUST_COST c4x_adjust_cost
238
239 #undef TARGET_SCHED_USE_DFA_PIPELINE_INTERFACE
240 #define TARGET_SCHED_USE_DFA_PIPELINE_INTERFACE hook_int_void_1
241
242 #undef TARGET_ASM_GLOBALIZE_LABEL
243 #define TARGET_ASM_GLOBALIZE_LABEL c4x_globalize_label
244
245 #undef TARGET_RTX_COSTS
246 #define TARGET_RTX_COSTS c4x_rtx_costs
247 #undef TARGET_ADDRESS_COST
248 #define TARGET_ADDRESS_COST c4x_address_cost
249
250 #undef TARGET_MACHINE_DEPENDENT_REORG
251 #define TARGET_MACHINE_DEPENDENT_REORG c4x_reorg
252
253 #undef TARGET_INIT_LIBFUNCS
254 #define TARGET_INIT_LIBFUNCS c4x_init_libfuncs
255
256 #undef TARGET_STRUCT_VALUE_RTX
257 #define TARGET_STRUCT_VALUE_RTX c4x_struct_value_rtx
258
259 #undef TARGET_GIMPLIFY_VA_ARG_EXPR
260 #define TARGET_GIMPLIFY_VA_ARG_EXPR c4x_gimplify_va_arg_expr
261
262 struct gcc_target targetm = TARGET_INITIALIZER;
263 \f
264 /* Override command line options.
265    Called once after all options have been parsed.
266    Mostly we process the processor
267    type and sometimes adjust other TARGET_ options.  */
268
269 void
270 c4x_override_options (void)
271 {
272   if (c4x_rpts_cycles_string)
273     c4x_rpts_cycles = atoi (c4x_rpts_cycles_string);
274   else
275     c4x_rpts_cycles = 0;
276
277   if (TARGET_C30)
278     c4x_cpu_version = 30;
279   else if (TARGET_C31)
280     c4x_cpu_version = 31;
281   else if (TARGET_C32)
282     c4x_cpu_version = 32;
283   else if (TARGET_C33)
284     c4x_cpu_version = 33;
285   else if (TARGET_C40)
286     c4x_cpu_version = 40;
287   else if (TARGET_C44)
288     c4x_cpu_version = 44;
289   else
290     c4x_cpu_version = 40;              
291
292   /* -mcpu=xx overrides -m40 etc.  */
293   if (c4x_cpu_version_string)
294     {
295       const char *p = c4x_cpu_version_string;
296       
297       /* Also allow -mcpu=c30 etc.  */
298       if (*p == 'c' || *p == 'C')
299         p++;
300       c4x_cpu_version = atoi (p);
301     }
302
303   target_flags &= ~(C30_FLAG | C31_FLAG | C32_FLAG | C33_FLAG |
304                     C40_FLAG | C44_FLAG);
305
306   switch (c4x_cpu_version)
307     {
308     case 30: target_flags |= C30_FLAG; break;
309     case 31: target_flags |= C31_FLAG; break;
310     case 32: target_flags |= C32_FLAG; break;
311     case 33: target_flags |= C33_FLAG; break;
312     case 40: target_flags |= C40_FLAG; break;
313     case 44: target_flags |= C44_FLAG; break;
314     default:
315       warning ("unknown CPU version %d, using 40.\n", c4x_cpu_version);
316       c4x_cpu_version = 40;
317       target_flags |= C40_FLAG;
318     }
319
320   if (TARGET_C30 || TARGET_C31 || TARGET_C32 || TARGET_C33)
321     target_flags |= C3X_FLAG;
322   else
323     target_flags &= ~C3X_FLAG;
324
325   /* Convert foo / 8.0 into foo * 0.125, etc.  */
326   set_fast_math_flags (1);
327
328   /* We should phase out the following at some stage.
329      This provides compatibility with the old -mno-aliases option.  */
330   if (! TARGET_ALIASES && ! flag_argument_noalias)
331     flag_argument_noalias = 1;
332 }
333
334
335 /* This is called before c4x_override_options.  */
336
337 void
338 c4x_optimization_options (int level ATTRIBUTE_UNUSED,
339                           int size ATTRIBUTE_UNUSED)
340 {
341   /* Scheduling before register allocation can screw up global
342      register allocation, especially for functions that use MPY||ADD
343      instructions.  The benefit we gain we get by scheduling before
344      register allocation is probably marginal anyhow.  */
345   flag_schedule_insns = 0;
346 }
347
348
349 /* Write an ASCII string.  */
350
351 #define C4X_ASCII_LIMIT 40
352
353 void
354 c4x_output_ascii (FILE *stream, const char *ptr, int len)
355 {
356   char sbuf[C4X_ASCII_LIMIT + 1];
357   int s, l, special, first = 1, onlys;
358
359   if (len)
360       fprintf (stream, "\t.byte\t");
361
362   for (s = l = 0; len > 0; --len, ++ptr)
363     {
364       onlys = 0;
365
366       /* Escape " and \ with a \".  */
367       special = *ptr == '\"' || *ptr == '\\';
368
369       /* If printable - add to buff.  */
370       if ((! TARGET_TI || ! special) && *ptr >= 0x20 && *ptr < 0x7f)
371         {
372           if (special)
373             sbuf[s++] = '\\';
374           sbuf[s++] = *ptr;
375           if (s < C4X_ASCII_LIMIT - 1)
376             continue;
377           onlys = 1;
378         }
379       if (s)
380         {
381           if (first)
382             first = 0;
383           else
384             {
385               fputc (',', stream);
386               l++;
387             }
388
389           sbuf[s] = 0;
390           fprintf (stream, "\"%s\"", sbuf);
391           l += s + 2;
392           if (TARGET_TI && l >= 80 && len > 1)
393             {
394               fprintf (stream, "\n\t.byte\t");
395               first = 1;
396               l = 0;
397             }
398         
399           s = 0;
400         }
401       if (onlys)
402         continue;
403
404       if (first)
405         first = 0;
406       else
407         {
408           fputc (',', stream);
409           l++;
410         }
411
412       fprintf (stream, "%d", *ptr);
413       l += 3;
414       if (TARGET_TI && l >= 80 && len > 1)
415         {
416           fprintf (stream, "\n\t.byte\t");
417           first = 1;
418           l = 0;
419         }
420     }
421   if (s)
422     {
423       if (! first)
424         fputc (',', stream);
425
426       sbuf[s] = 0;
427       fprintf (stream, "\"%s\"", sbuf);
428       s = 0;
429     }
430   fputc ('\n', stream);
431 }
432
433
434 int
435 c4x_hard_regno_mode_ok (unsigned int regno, enum machine_mode mode)
436 {
437   switch (mode)
438     {
439 #if Pmode != QImode
440     case Pmode:                 /* Pointer (24/32 bits).  */
441 #endif
442     case QImode:                /* Integer (32 bits).  */
443       return IS_INT_REGNO (regno);
444
445     case QFmode:                /* Float, Double (32 bits).  */
446     case HFmode:                /* Long Double (40 bits).  */
447       return IS_EXT_REGNO (regno);
448
449     case CCmode:                /* Condition Codes.  */
450     case CC_NOOVmode:           /* Condition Codes.  */
451       return IS_ST_REGNO (regno);
452
453     case HImode:                /* Long Long (64 bits).  */
454       /* We need two registers to store long longs.  Note that 
455          it is much easier to constrain the first register
456          to start on an even boundary.  */
457       return IS_INT_REGNO (regno)
458         && IS_INT_REGNO (regno + 1)
459         && (regno & 1) == 0;
460
461     default:
462       return 0;                 /* We don't support these modes.  */
463     }
464
465   return 0;
466 }
467
468 /* Return nonzero if REGNO1 can be renamed to REGNO2.  */
469 int
470 c4x_hard_regno_rename_ok (unsigned int regno1, unsigned int regno2)
471 {
472   /* We can not copy call saved registers from mode QI into QF or from
473      mode QF into QI.  */
474   if (IS_FLOAT_CALL_SAVED_REGNO (regno1) && IS_INT_CALL_SAVED_REGNO (regno2))
475     return 0;
476   if (IS_INT_CALL_SAVED_REGNO (regno1) && IS_FLOAT_CALL_SAVED_REGNO (regno2))
477     return 0;
478   /* We cannot copy from an extended (40 bit) register to a standard
479      (32 bit) register because we only set the condition codes for
480      extended registers.  */
481   if (IS_EXT_REGNO (regno1) && ! IS_EXT_REGNO (regno2))
482     return 0;
483   if (IS_EXT_REGNO (regno2) && ! IS_EXT_REGNO (regno1))
484     return 0;
485   return 1;
486 }
487
488 /* The TI C3x C compiler register argument runtime model uses 6 registers,
489    AR2, R2, R3, RC, RS, RE.
490
491    The first two floating point arguments (float, double, long double)
492    that are found scanning from left to right are assigned to R2 and R3.
493
494    The remaining integer (char, short, int, long) or pointer arguments
495    are assigned to the remaining registers in the order AR2, R2, R3,
496    RC, RS, RE when scanning left to right, except for the last named
497    argument prior to an ellipsis denoting variable number of
498    arguments.  We don't have to worry about the latter condition since
499    function.c treats the last named argument as anonymous (unnamed).
500
501    All arguments that cannot be passed in registers are pushed onto
502    the stack in reverse order (right to left).  GCC handles that for us.
503
504    c4x_init_cumulative_args() is called at the start, so we can parse
505    the args to see how many floating point arguments and how many
506    integer (or pointer) arguments there are.  c4x_function_arg() is
507    then called (sometimes repeatedly) for each argument (parsed left
508    to right) to obtain the register to pass the argument in, or zero
509    if the argument is to be passed on the stack.  Once the compiler is
510    happy, c4x_function_arg_advance() is called.
511
512    Don't use R0 to pass arguments in, we use 0 to indicate a stack
513    argument.  */
514
515 static const int c4x_int_reglist[3][6] =
516 {
517   {AR2_REGNO, R2_REGNO, R3_REGNO, RC_REGNO, RS_REGNO, RE_REGNO},
518   {AR2_REGNO, R3_REGNO, RC_REGNO, RS_REGNO, RE_REGNO, 0},
519   {AR2_REGNO, RC_REGNO, RS_REGNO, RE_REGNO, 0, 0}
520 };
521
522 static const int c4x_fp_reglist[2] = {R2_REGNO, R3_REGNO};
523
524
525 /* Initialize a variable CUM of type CUMULATIVE_ARGS for a call to a
526    function whose data type is FNTYPE.
527    For a library call, FNTYPE is  0.  */
528
529 void
530 c4x_init_cumulative_args (CUMULATIVE_ARGS *cum, tree fntype, rtx libname)
531 {
532   tree param, next_param;
533
534   cum->floats = cum->ints = 0;
535   cum->init = 0;
536   cum->var = 0;
537   cum->args = 0;
538
539   if (TARGET_DEBUG)
540     {
541       fprintf (stderr, "\nc4x_init_cumulative_args (");
542       if (fntype)
543         {
544           tree ret_type = TREE_TYPE (fntype);
545
546           fprintf (stderr, "fntype code = %s, ret code = %s",
547                    tree_code_name[(int) TREE_CODE (fntype)],
548                    tree_code_name[(int) TREE_CODE (ret_type)]);
549         }
550       else
551         fprintf (stderr, "no fntype");
552
553       if (libname)
554         fprintf (stderr, ", libname = %s", XSTR (libname, 0));
555     }
556
557   cum->prototype = (fntype && TYPE_ARG_TYPES (fntype));
558
559   for (param = fntype ? TYPE_ARG_TYPES (fntype) : 0;
560        param; param = next_param)
561     {
562       tree type;
563
564       next_param = TREE_CHAIN (param);
565
566       type = TREE_VALUE (param);
567       if (type && type != void_type_node)
568         {
569           enum machine_mode mode;
570
571           /* If the last arg doesn't have void type then we have
572              variable arguments.  */
573           if (! next_param)
574             cum->var = 1;
575
576           if ((mode = TYPE_MODE (type)))
577             {
578               if (! targetm.calls.must_pass_in_stack (mode, type))
579                 {
580                   /* Look for float, double, or long double argument.  */
581                   if (mode == QFmode || mode == HFmode)
582                     cum->floats++;
583                   /* Look for integer, enumeral, boolean, char, or pointer
584                      argument.  */
585                   else if (mode == QImode || mode == Pmode)
586                     cum->ints++;
587                 }
588             }
589           cum->args++;
590         }
591     }
592
593   if (TARGET_DEBUG)
594     fprintf (stderr, "%s%s, args = %d)\n",
595              cum->prototype ? ", prototype" : "",
596              cum->var ? ", variable args" : "",
597              cum->args);
598 }
599
600
601 /* Update the data in CUM to advance over an argument
602    of mode MODE and data type TYPE.
603    (TYPE is null for libcalls where that information may not be available.)  */
604
605 void
606 c4x_function_arg_advance (CUMULATIVE_ARGS *cum, enum machine_mode mode,
607                           tree type, int named)
608 {
609   if (TARGET_DEBUG)
610     fprintf (stderr, "c4x_function_adv(mode=%s, named=%d)\n\n",
611              GET_MODE_NAME (mode), named);
612   if (! TARGET_MEMPARM 
613       && named
614       && type
615       && ! targetm.calls.must_pass_in_stack (mode, type))
616     {
617       /* Look for float, double, or long double argument.  */
618       if (mode == QFmode || mode == HFmode)
619         cum->floats++;
620       /* Look for integer, enumeral, boolean, char, or pointer argument.  */
621       else if (mode == QImode || mode == Pmode)
622         cum->ints++;
623     }
624   else if (! TARGET_MEMPARM && ! type)
625     {
626       /* Handle libcall arguments.  */
627       if (mode == QFmode || mode == HFmode)
628         cum->floats++;
629       else if (mode == QImode || mode == Pmode)
630         cum->ints++;
631     }
632   return;
633 }
634
635
636 /* Define where to put the arguments to a function.  Value is zero to
637    push the argument on the stack, or a hard register in which to
638    store the argument.
639
640    MODE is the argument's machine mode.
641    TYPE is the data type of the argument (as a tree).
642    This is null for libcalls where that information may
643    not be available.
644    CUM is a variable of type CUMULATIVE_ARGS which gives info about
645    the preceding args and about the function being called.
646    NAMED is nonzero if this argument is a named parameter
647    (otherwise it is an extra parameter matching an ellipsis).  */
648
649 struct rtx_def *
650 c4x_function_arg (CUMULATIVE_ARGS *cum, enum machine_mode mode,
651                   tree type, int named)
652 {
653   int reg = 0;                  /* Default to passing argument on stack.  */
654
655   if (! cum->init)
656     {
657       /* We can handle at most 2 floats in R2, R3.  */
658       cum->maxfloats = (cum->floats > 2) ? 2 : cum->floats;
659
660       /* We can handle at most 6 integers minus number of floats passed 
661          in registers.  */
662       cum->maxints = (cum->ints > 6 - cum->maxfloats) ? 
663         6 - cum->maxfloats : cum->ints;
664
665       /* If there is no prototype, assume all the arguments are integers.  */
666       if (! cum->prototype)
667         cum->maxints = 6;
668
669       cum->ints = cum->floats = 0;
670       cum->init = 1;
671     }
672
673   /* This marks the last argument.  We don't need to pass this through
674      to the call insn.  */
675   if (type == void_type_node)
676     return 0;
677
678   if (! TARGET_MEMPARM 
679       && named 
680       && type
681       && ! targetm.calls.must_pass_in_stack (mode, type))
682     {
683       /* Look for float, double, or long double argument.  */
684       if (mode == QFmode || mode == HFmode)
685         {
686           if (cum->floats < cum->maxfloats)
687             reg = c4x_fp_reglist[cum->floats];
688         }
689       /* Look for integer, enumeral, boolean, char, or pointer argument.  */
690       else if (mode == QImode || mode == Pmode)
691         {
692           if (cum->ints < cum->maxints)
693             reg = c4x_int_reglist[cum->maxfloats][cum->ints];
694         }
695     }
696   else if (! TARGET_MEMPARM && ! type)
697     {
698       /* We could use a different argument calling model for libcalls,
699          since we're only calling functions in libgcc.  Thus we could
700          pass arguments for long longs in registers rather than on the
701          stack.  In the meantime, use the odd TI format.  We make the
702          assumption that we won't have more than two floating point
703          args, six integer args, and that all the arguments are of the
704          same mode.  */
705       if (mode == QFmode || mode == HFmode)
706         reg = c4x_fp_reglist[cum->floats];
707       else if (mode == QImode || mode == Pmode)
708         reg = c4x_int_reglist[0][cum->ints];
709     }
710
711   if (TARGET_DEBUG)
712     {
713       fprintf (stderr, "c4x_function_arg(mode=%s, named=%d",
714                GET_MODE_NAME (mode), named);
715       if (reg)
716         fprintf (stderr, ", reg=%s", reg_names[reg]);
717       else
718         fprintf (stderr, ", stack");
719       fprintf (stderr, ")\n");
720     }
721   if (reg)
722     return gen_rtx_REG (mode, reg);
723   else
724     return NULL_RTX;
725 }
726
727 /* C[34]x arguments grow in weird ways (downwards) that the standard
728    varargs stuff can't handle..  */
729
730 static tree
731 c4x_gimplify_va_arg_expr (tree valist, tree type,
732                           tree *pre_p ATTRIBUTE_UNUSED,
733                           tree *post_p ATTRIBUTE_UNUSED)
734 {
735   tree t;
736
737   t = build (PREDECREMENT_EXPR, TREE_TYPE (valist), valist,
738              build_int_2 (int_size_in_bytes (type), 0));
739   t = fold_convert (build_pointer_type (type), t);
740   t = build_fold_indirect_ref (t);
741
742   return t;
743 }
744
745
746 static int
747 c4x_isr_reg_used_p (unsigned int regno)
748 {
749   /* Don't save/restore FP or ST, we handle them separately.  */
750   if (regno == FRAME_POINTER_REGNUM
751       || IS_ST_REGNO (regno))
752     return 0;
753
754   /* We could be a little smarter abut saving/restoring DP.
755      We'll only save if for the big memory model or if
756      we're paranoid. ;-)  */
757   if (IS_DP_REGNO (regno))
758     return ! TARGET_SMALL || TARGET_PARANOID;
759
760   /* Only save/restore regs in leaf function that are used.  */
761   if (c4x_leaf_function)
762     return regs_ever_live[regno] && fixed_regs[regno] == 0;
763
764   /* Only save/restore regs that are used by the ISR and regs
765      that are likely to be used by functions the ISR calls
766      if they are not fixed.  */
767   return IS_EXT_REGNO (regno)
768     || ((regs_ever_live[regno] || call_used_regs[regno]) 
769         && fixed_regs[regno] == 0);
770 }
771
772
773 static int
774 c4x_leaf_function_p (void)
775 {
776   /* A leaf function makes no calls, so we only need
777      to save/restore the registers we actually use.
778      For the global variable leaf_function to be set, we need
779      to define LEAF_REGISTERS and all that it entails.
780      Let's check ourselves....  */
781
782   if (lookup_attribute ("leaf_pretend",
783                         TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl))))
784     return 1;
785
786   /* Use the leaf_pretend attribute at your own risk.  This is a hack
787      to speed up ISRs that call a function infrequently where the
788      overhead of saving and restoring the additional registers is not
789      warranted.  You must save and restore the additional registers
790      required by the called function.  Caveat emptor.  Here's enough
791      rope...  */
792
793   if (leaf_function_p ())
794     return 1;
795
796   return 0;
797 }
798
799
800 static int
801 c4x_naked_function_p (void)
802 {
803   tree type;
804
805   type = TREE_TYPE (current_function_decl);
806   return lookup_attribute ("naked", TYPE_ATTRIBUTES (type)) != NULL;
807 }
808
809
810 int
811 c4x_interrupt_function_p (void)
812 {
813   const char *cfun_name;
814   if (lookup_attribute ("interrupt",
815                         TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl))))
816     return 1;
817
818   /* Look for TI style c_intnn.  */
819   cfun_name = current_function_name ();
820   return cfun_name[0] == 'c'
821     && cfun_name[1] == '_'
822     && cfun_name[2] == 'i'
823     && cfun_name[3] == 'n' 
824     && cfun_name[4] == 't'
825     && ISDIGIT (cfun_name[5])
826     && ISDIGIT (cfun_name[6]);
827 }
828
829 void
830 c4x_expand_prologue (void)
831 {
832   unsigned int regno;
833   int size = get_frame_size ();
834   rtx insn;
835
836   /* In functions where ar3 is not used but frame pointers are still
837      specified, frame pointers are not adjusted (if >= -O2) and this
838      is used so it won't needlessly push the frame pointer.  */
839   int dont_push_ar3;
840
841   /* For __naked__ function don't build a prologue.  */
842   if (c4x_naked_function_p ())
843     {
844       return;
845     }
846   
847   /* For __interrupt__ function build specific prologue.  */
848   if (c4x_interrupt_function_p ())
849     {
850       c4x_leaf_function = c4x_leaf_function_p ();
851       
852       insn = emit_insn (gen_push_st ());
853       RTX_FRAME_RELATED_P (insn) = 1;
854       if (size)
855         {
856           insn = emit_insn (gen_pushqi ( gen_rtx_REG (QImode, AR3_REGNO)));
857           RTX_FRAME_RELATED_P (insn) = 1;
858           insn = emit_insn (gen_movqi (gen_rtx_REG (QImode, AR3_REGNO),
859                                        gen_rtx_REG (QImode, SP_REGNO)));
860           RTX_FRAME_RELATED_P (insn) = 1;
861           /* We require that an ISR uses fewer than 32768 words of
862              local variables, otherwise we have to go to lots of
863              effort to save a register, load it with the desired size,
864              adjust the stack pointer, and then restore the modified
865              register.  Frankly, I think it is a poor ISR that
866              requires more than 32767 words of local temporary
867              storage!  */
868           if (size > 32767)
869             error ("ISR %s requires %d words of local vars, max is 32767",
870                    current_function_name (), size);
871
872           insn = emit_insn (gen_addqi3 (gen_rtx_REG (QImode, SP_REGNO),
873                                         gen_rtx_REG (QImode, SP_REGNO),
874                                         GEN_INT (size)));
875           RTX_FRAME_RELATED_P (insn) = 1;
876         }
877       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
878         {
879           if (c4x_isr_reg_used_p (regno))
880             {
881               if (regno == DP_REGNO)
882                 {
883                   insn = emit_insn (gen_push_dp ());
884                   RTX_FRAME_RELATED_P (insn) = 1;
885                 }
886               else
887                 {
888                   insn = emit_insn (gen_pushqi (gen_rtx_REG (QImode, regno)));
889                   RTX_FRAME_RELATED_P (insn) = 1;
890                   if (IS_EXT_REGNO (regno))
891                     {
892                       insn = emit_insn (gen_pushqf
893                                         (gen_rtx_REG (QFmode, regno)));
894                       RTX_FRAME_RELATED_P (insn) = 1;
895                     }
896                 }
897             }
898         }
899       /* We need to clear the repeat mode flag if the ISR is
900          going to use a RPTB instruction or uses the RC, RS, or RE
901          registers.  */
902       if (regs_ever_live[RC_REGNO] 
903           || regs_ever_live[RS_REGNO] 
904           || regs_ever_live[RE_REGNO])
905         {
906           insn = emit_insn (gen_andn_st (GEN_INT(~0x100)));
907           RTX_FRAME_RELATED_P (insn) = 1;
908         }
909
910       /* Reload DP reg if we are paranoid about some turkey
911          violating small memory model rules.  */
912       if (TARGET_SMALL && TARGET_PARANOID)
913         {
914           insn = emit_insn (gen_set_ldp_prologue
915                             (gen_rtx_REG (QImode, DP_REGNO),
916                              gen_rtx_SYMBOL_REF (QImode, "data_sec")));
917           RTX_FRAME_RELATED_P (insn) = 1;
918         }
919     }
920   else
921     {
922       if (frame_pointer_needed)
923         {
924           if ((size != 0)
925               || (current_function_args_size != 0)
926               || (optimize < 2))
927             {
928               insn = emit_insn (gen_pushqi ( gen_rtx_REG (QImode, AR3_REGNO)));
929               RTX_FRAME_RELATED_P (insn) = 1;
930               insn = emit_insn (gen_movqi (gen_rtx_REG (QImode, AR3_REGNO),
931                                            gen_rtx_REG (QImode, SP_REGNO)));
932               RTX_FRAME_RELATED_P (insn) = 1;
933               dont_push_ar3 = 1;
934             }
935           else
936             {
937               /* Since ar3 is not used, we don't need to push it.  */
938               dont_push_ar3 = 1;
939             }
940         }
941       else
942         {
943           /* If we use ar3, we need to push it.  */
944           dont_push_ar3 = 0;
945           if ((size != 0) || (current_function_args_size != 0))
946             {
947               /* If we are omitting the frame pointer, we still have
948                  to make space for it so the offsets are correct
949                  unless we don't use anything on the stack at all.  */
950               size += 1;
951             }
952         }
953       
954       if (size > 32767)
955         {
956           /* Local vars are too big, it will take multiple operations
957              to increment SP.  */
958           if (TARGET_C3X)
959             {
960               insn = emit_insn (gen_movqi (gen_rtx_REG (QImode, R1_REGNO),
961                                            GEN_INT(size >> 16)));
962               RTX_FRAME_RELATED_P (insn) = 1;
963               insn = emit_insn (gen_lshrqi3 (gen_rtx_REG (QImode, R1_REGNO),
964                                              gen_rtx_REG (QImode, R1_REGNO),
965                                              GEN_INT(-16)));
966               RTX_FRAME_RELATED_P (insn) = 1;
967             }
968           else
969             {
970               insn = emit_insn (gen_movqi (gen_rtx_REG (QImode, R1_REGNO),
971                                            GEN_INT(size & ~0xffff)));
972               RTX_FRAME_RELATED_P (insn) = 1;
973             }
974           insn = emit_insn (gen_iorqi3 (gen_rtx_REG (QImode, R1_REGNO),
975                                         gen_rtx_REG (QImode, R1_REGNO),
976                                         GEN_INT(size & 0xffff)));
977           RTX_FRAME_RELATED_P (insn) = 1;
978           insn = emit_insn (gen_addqi3 (gen_rtx_REG (QImode, SP_REGNO),
979                                         gen_rtx_REG (QImode, SP_REGNO),
980                                         gen_rtx_REG (QImode, R1_REGNO)));
981           RTX_FRAME_RELATED_P (insn) = 1;
982         }
983       else if (size != 0)
984         {
985           /* Local vars take up less than 32767 words, so we can directly
986              add the number.  */
987           insn = emit_insn (gen_addqi3 (gen_rtx_REG (QImode, SP_REGNO),
988                                         gen_rtx_REG (QImode, SP_REGNO),
989                                         GEN_INT (size)));
990           RTX_FRAME_RELATED_P (insn) = 1;
991         }
992       
993       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
994         {
995           if (regs_ever_live[regno] && ! call_used_regs[regno])
996             {
997               if (IS_FLOAT_CALL_SAVED_REGNO (regno))
998                 {
999                   if (TARGET_PRESERVE_FLOAT)
1000                     {
1001                       insn = emit_insn (gen_pushqi
1002                                         (gen_rtx_REG (QImode, regno)));
1003                       RTX_FRAME_RELATED_P (insn) = 1;
1004                     }
1005                   insn = emit_insn (gen_pushqf (gen_rtx_REG (QFmode, regno)));
1006                   RTX_FRAME_RELATED_P (insn) = 1;
1007                 }
1008               else if ((! dont_push_ar3) || (regno != AR3_REGNO))
1009                 {
1010                   insn = emit_insn (gen_pushqi ( gen_rtx_REG (QImode, regno)));
1011                   RTX_FRAME_RELATED_P (insn) = 1;
1012                 }
1013             }
1014         }
1015     }
1016 }
1017
1018
1019 void
1020 c4x_expand_epilogue(void)
1021 {
1022   int regno;
1023   int jump = 0;
1024   int dont_pop_ar3;
1025   rtx insn;
1026   int size = get_frame_size ();
1027   
1028   /* For __naked__ function build no epilogue.  */
1029   if (c4x_naked_function_p ())
1030     {
1031       insn = emit_jump_insn (gen_return_from_epilogue ());
1032       RTX_FRAME_RELATED_P (insn) = 1;
1033       return;
1034     }
1035
1036   /* For __interrupt__ function build specific epilogue.  */
1037   if (c4x_interrupt_function_p ())
1038     {
1039       for (regno = FIRST_PSEUDO_REGISTER - 1; regno >= 0; --regno)
1040         {
1041           if (! c4x_isr_reg_used_p (regno))
1042             continue;
1043           if (regno == DP_REGNO)
1044             {
1045               insn = emit_insn (gen_pop_dp ());
1046               RTX_FRAME_RELATED_P (insn) = 1;
1047             }
1048           else
1049             {
1050               /* We have to use unspec because the compiler will delete insns
1051                  that are not call-saved.  */
1052               if (IS_EXT_REGNO (regno))
1053                 {
1054                   insn = emit_insn (gen_popqf_unspec
1055                                     (gen_rtx_REG (QFmode, regno)));
1056                   RTX_FRAME_RELATED_P (insn) = 1;
1057                 }
1058               insn = emit_insn (gen_popqi_unspec (gen_rtx_REG (QImode, regno)));
1059               RTX_FRAME_RELATED_P (insn) = 1;
1060             }
1061         }
1062       if (size)
1063         {
1064           insn = emit_insn (gen_subqi3 (gen_rtx_REG (QImode, SP_REGNO),
1065                                         gen_rtx_REG (QImode, SP_REGNO),
1066                                         GEN_INT(size)));
1067           RTX_FRAME_RELATED_P (insn) = 1;
1068           insn = emit_insn (gen_popqi
1069                             (gen_rtx_REG (QImode, AR3_REGNO)));
1070           RTX_FRAME_RELATED_P (insn) = 1;
1071         }
1072       insn = emit_insn (gen_pop_st ());
1073       RTX_FRAME_RELATED_P (insn) = 1;
1074       insn = emit_jump_insn (gen_return_from_interrupt_epilogue ());
1075       RTX_FRAME_RELATED_P (insn) = 1;
1076     }
1077   else
1078     {
1079       if (frame_pointer_needed)
1080         {
1081           if ((size != 0) 
1082               || (current_function_args_size != 0) 
1083               || (optimize < 2))
1084             {
1085               insn = emit_insn
1086                 (gen_movqi (gen_rtx_REG (QImode, R2_REGNO),
1087                             gen_rtx_MEM (QImode,
1088                                          gen_rtx_PLUS 
1089                                          (QImode, gen_rtx_REG (QImode,
1090                                                                AR3_REGNO),
1091                                           constm1_rtx))));
1092               RTX_FRAME_RELATED_P (insn) = 1;
1093               
1094               /* We already have the return value and the fp,
1095                  so we need to add those to the stack.  */
1096               size += 2;
1097               jump = 1;
1098               dont_pop_ar3 = 1;
1099             }
1100           else
1101             {
1102               /* Since ar3 is not used for anything, we don't need to
1103                  pop it.  */
1104               dont_pop_ar3 = 1;
1105             }
1106         }
1107       else
1108         {
1109           dont_pop_ar3 = 0;     /* If we use ar3, we need to pop it.  */
1110           if (size || current_function_args_size)
1111             {
1112               /* If we are omitting the frame pointer, we still have
1113                  to make space for it so the offsets are correct
1114                  unless we don't use anything on the stack at all.  */
1115               size += 1;
1116             }
1117         }
1118       
1119       /* Now restore the saved registers, putting in the delayed branch
1120          where required.  */
1121       for (regno = FIRST_PSEUDO_REGISTER - 1; regno >= 0; regno--)
1122         {
1123           if (regs_ever_live[regno] && ! call_used_regs[regno])
1124             {
1125               if (regno == AR3_REGNO && dont_pop_ar3)
1126                 continue;
1127               
1128               if (IS_FLOAT_CALL_SAVED_REGNO (regno))
1129                 {
1130                   insn = emit_insn (gen_popqf_unspec
1131                                     (gen_rtx_REG (QFmode, regno)));
1132                   RTX_FRAME_RELATED_P (insn) = 1;
1133                   if (TARGET_PRESERVE_FLOAT)
1134                     {
1135                       insn = emit_insn (gen_popqi_unspec
1136                                         (gen_rtx_REG (QImode, regno)));
1137                       RTX_FRAME_RELATED_P (insn) = 1;
1138                     }
1139                 }
1140               else
1141                 {
1142                   insn = emit_insn (gen_popqi (gen_rtx_REG (QImode, regno)));
1143                   RTX_FRAME_RELATED_P (insn) = 1;
1144                 }
1145             }
1146         }
1147       
1148       if (frame_pointer_needed)
1149         {
1150           if ((size != 0)
1151               || (current_function_args_size != 0)
1152               || (optimize < 2))
1153             {
1154               /* Restore the old FP.  */
1155               insn = emit_insn 
1156                 (gen_movqi 
1157                  (gen_rtx_REG (QImode, AR3_REGNO),
1158                   gen_rtx_MEM (QImode, gen_rtx_REG (QImode, AR3_REGNO))));
1159               
1160               RTX_FRAME_RELATED_P (insn) = 1;
1161             }
1162         }
1163       
1164       if (size > 32767)
1165         {
1166           /* Local vars are too big, it will take multiple operations
1167              to decrement SP.  */
1168           if (TARGET_C3X)
1169             {
1170               insn = emit_insn (gen_movqi (gen_rtx_REG (QImode, R3_REGNO),
1171                                            GEN_INT(size >> 16)));
1172               RTX_FRAME_RELATED_P (insn) = 1;
1173               insn = emit_insn (gen_lshrqi3 (gen_rtx_REG (QImode, R3_REGNO),
1174                                              gen_rtx_REG (QImode, R3_REGNO),
1175                                              GEN_INT(-16)));
1176               RTX_FRAME_RELATED_P (insn) = 1;
1177             }
1178           else
1179             {
1180               insn = emit_insn (gen_movqi (gen_rtx_REG (QImode, R3_REGNO),
1181                                            GEN_INT(size & ~0xffff)));
1182               RTX_FRAME_RELATED_P (insn) = 1;
1183             }
1184           insn = emit_insn (gen_iorqi3 (gen_rtx_REG (QImode, R3_REGNO),
1185                                         gen_rtx_REG (QImode, R3_REGNO),
1186                                         GEN_INT(size & 0xffff)));
1187           RTX_FRAME_RELATED_P (insn) = 1;
1188           insn = emit_insn (gen_subqi3 (gen_rtx_REG (QImode, SP_REGNO),
1189                                         gen_rtx_REG (QImode, SP_REGNO),
1190                                         gen_rtx_REG (QImode, R3_REGNO)));
1191           RTX_FRAME_RELATED_P (insn) = 1;
1192         }
1193       else if (size != 0)
1194         {
1195           /* Local vars take up less than 32768 words, so we can directly
1196              subtract the number.  */
1197           insn = emit_insn (gen_subqi3 (gen_rtx_REG (QImode, SP_REGNO),
1198                                         gen_rtx_REG (QImode, SP_REGNO),
1199                                         GEN_INT(size)));
1200           RTX_FRAME_RELATED_P (insn) = 1;
1201         }
1202       
1203       if (jump)
1204         {
1205           insn = emit_jump_insn (gen_return_indirect_internal
1206                                  (gen_rtx_REG (QImode, R2_REGNO)));
1207           RTX_FRAME_RELATED_P (insn) = 1;
1208         }
1209       else
1210         {
1211           insn = emit_jump_insn (gen_return_from_epilogue ());
1212           RTX_FRAME_RELATED_P (insn) = 1;
1213         }
1214     }
1215 }
1216
1217
1218 int
1219 c4x_null_epilogue_p (void)
1220 {
1221   int regno;
1222
1223   if (reload_completed
1224       && ! c4x_naked_function_p ()
1225       && ! c4x_interrupt_function_p ()
1226       && ! current_function_calls_alloca
1227       && ! current_function_args_size
1228       && ! (optimize < 2)
1229       && ! get_frame_size ())
1230     {
1231       for (regno = FIRST_PSEUDO_REGISTER - 1; regno >= 0; regno--)
1232         if (regs_ever_live[regno] && ! call_used_regs[regno]
1233             && (regno != AR3_REGNO))
1234           return 1;
1235       return 0;
1236     }
1237   return 1;
1238 }
1239
1240
1241 int
1242 c4x_emit_move_sequence (rtx *operands, enum machine_mode mode)
1243 {
1244   rtx op0 = operands[0];
1245   rtx op1 = operands[1];
1246
1247   if (! reload_in_progress
1248       && ! REG_P (op0) 
1249       && ! REG_P (op1)
1250       && ! (stik_const_operand (op1, mode) && ! push_operand (op0, mode)))
1251     op1 = force_reg (mode, op1);
1252
1253   if (GET_CODE (op1) == LO_SUM
1254       && GET_MODE (op1) == Pmode
1255       && dp_reg_operand (XEXP (op1, 0), mode))
1256     {
1257       /* expand_increment will sometimes create a LO_SUM immediate
1258          address.  Undo this silliness.  */
1259       op1 = XEXP (op1, 1);
1260     }
1261   
1262   if (symbolic_address_operand (op1, mode))
1263     {
1264       if (TARGET_LOAD_ADDRESS)
1265         {
1266           /* Alias analysis seems to do a better job if we force
1267              constant addresses to memory after reload.  */
1268           emit_insn (gen_load_immed_address (op0, op1));
1269           return 1;
1270         }
1271       else
1272         {
1273           /* Stick symbol or label address into the constant pool.  */
1274           op1 = force_const_mem (Pmode, op1);
1275         }
1276     }
1277   else if (mode == HFmode && CONSTANT_P (op1) && ! LEGITIMATE_CONSTANT_P (op1))
1278     {
1279       /* We could be a lot smarter about loading some of these
1280          constants...  */
1281       op1 = force_const_mem (mode, op1);
1282     }
1283
1284   /* Convert (MEM (SYMREF)) to a (MEM (LO_SUM (REG) (SYMREF)))
1285      and emit associated (HIGH (SYMREF)) if large memory model.  
1286      c4x_legitimize_address could be used to do this,
1287      perhaps by calling validize_address.  */
1288   if (TARGET_EXPOSE_LDP
1289       && ! (reload_in_progress || reload_completed)
1290       && GET_CODE (op1) == MEM
1291       && symbolic_address_operand (XEXP (op1, 0), Pmode))
1292     {
1293       rtx dp_reg = gen_rtx_REG (Pmode, DP_REGNO);
1294       if (! TARGET_SMALL)
1295         emit_insn (gen_set_ldp (dp_reg, XEXP (op1, 0)));
1296       op1 = change_address (op1, mode,
1297                             gen_rtx_LO_SUM (Pmode, dp_reg, XEXP (op1, 0)));
1298     }
1299
1300   if (TARGET_EXPOSE_LDP
1301       && ! (reload_in_progress || reload_completed)
1302       && GET_CODE (op0) == MEM 
1303       && symbolic_address_operand (XEXP (op0, 0), Pmode))
1304     {
1305       rtx dp_reg = gen_rtx_REG (Pmode, DP_REGNO);
1306       if (! TARGET_SMALL)
1307         emit_insn (gen_set_ldp (dp_reg, XEXP (op0, 0)));
1308       op0 = change_address (op0, mode,
1309                             gen_rtx_LO_SUM (Pmode, dp_reg, XEXP (op0, 0)));
1310     }
1311
1312   if (GET_CODE (op0) == SUBREG
1313       && mixed_subreg_operand (op0, mode))
1314     {
1315       /* We should only generate these mixed mode patterns
1316          during RTL generation.  If we need do it later on
1317          then we'll have to emit patterns that won't clobber CC.  */
1318       if (reload_in_progress || reload_completed)
1319         abort ();
1320       if (GET_MODE (SUBREG_REG (op0)) == QImode)
1321         op0 = SUBREG_REG (op0);
1322       else if (GET_MODE (SUBREG_REG (op0)) == HImode)
1323         {
1324           op0 = copy_rtx (op0);
1325           PUT_MODE (op0, QImode);
1326         }
1327       else
1328         abort ();
1329
1330       if (mode == QFmode)
1331         emit_insn (gen_storeqf_int_clobber (op0, op1));
1332       else
1333         abort ();
1334       return 1;
1335     }
1336
1337   if (GET_CODE (op1) == SUBREG
1338       && mixed_subreg_operand (op1, mode))
1339     {
1340       /* We should only generate these mixed mode patterns
1341          during RTL generation.  If we need do it later on
1342          then we'll have to emit patterns that won't clobber CC.  */
1343       if (reload_in_progress || reload_completed)
1344         abort ();
1345       if (GET_MODE (SUBREG_REG (op1)) == QImode)
1346         op1 = SUBREG_REG (op1);
1347       else if (GET_MODE (SUBREG_REG (op1)) == HImode)
1348         {
1349           op1 = copy_rtx (op1);
1350           PUT_MODE (op1, QImode);
1351         }
1352       else
1353         abort ();
1354
1355       if (mode == QFmode)
1356         emit_insn (gen_loadqf_int_clobber (op0, op1));
1357       else
1358         abort ();
1359       return 1;
1360     }
1361
1362   if (mode == QImode
1363       && reg_operand (op0, mode)
1364       && const_int_operand (op1, mode)
1365       && ! IS_INT16_CONST (INTVAL (op1))
1366       && ! IS_HIGH_CONST (INTVAL (op1)))
1367     {
1368       emit_insn (gen_loadqi_big_constant (op0, op1));
1369       return 1;
1370     }
1371
1372   if (mode == HImode
1373       && reg_operand (op0, mode)
1374       && const_int_operand (op1, mode))
1375     {
1376       emit_insn (gen_loadhi_big_constant (op0, op1));
1377       return 1;
1378     }
1379
1380   /* Adjust operands in case we have modified them.  */
1381   operands[0] = op0;
1382   operands[1] = op1;
1383
1384   /* Emit normal pattern.  */
1385   return 0;
1386 }
1387
1388
1389 void
1390 c4x_emit_libcall (rtx libcall, enum rtx_code code,
1391                   enum machine_mode dmode, enum machine_mode smode,
1392                   int noperands, rtx *operands)
1393 {
1394   rtx ret;
1395   rtx insns;
1396   rtx equiv;
1397
1398   start_sequence ();
1399   switch (noperands)
1400     {
1401     case 2:
1402       ret = emit_library_call_value (libcall, NULL_RTX, 1, dmode, 1,
1403                                      operands[1], smode);
1404       equiv = gen_rtx_fmt_e (code, dmode, operands[1]);
1405       break;
1406
1407     case 3:
1408       ret = emit_library_call_value (libcall, NULL_RTX, 1, dmode, 2,
1409                                      operands[1], smode, operands[2], smode);
1410       equiv = gen_rtx_fmt_ee (code, dmode, operands[1], operands[2]);
1411       break;
1412
1413     default:
1414       abort ();
1415     }
1416
1417   insns = get_insns ();
1418   end_sequence ();
1419   emit_libcall_block (insns, operands[0], ret, equiv);
1420 }
1421
1422
1423 void
1424 c4x_emit_libcall3 (rtx libcall, enum rtx_code code,
1425                    enum machine_mode mode, rtx *operands)
1426 {
1427   c4x_emit_libcall (libcall, code, mode, mode, 3, operands);
1428 }
1429
1430
1431 void
1432 c4x_emit_libcall_mulhi (rtx libcall, enum rtx_code code,
1433                         enum machine_mode mode, rtx *operands)
1434 {
1435   rtx ret;
1436   rtx insns;
1437   rtx equiv;
1438
1439   start_sequence ();
1440   ret = emit_library_call_value (libcall, NULL_RTX, 1, mode, 2,
1441                                  operands[1], mode, operands[2], mode);
1442   equiv = gen_rtx_TRUNCATE (mode,
1443                    gen_rtx_LSHIFTRT (HImode,
1444                             gen_rtx_MULT (HImode,
1445                                      gen_rtx_fmt_e (code, HImode, operands[1]),
1446                                      gen_rtx_fmt_e (code, HImode, operands[2])),
1447                                      GEN_INT (32)));
1448   insns = get_insns ();
1449   end_sequence ();
1450   emit_libcall_block (insns, operands[0], ret, equiv);
1451 }
1452
1453
1454 int
1455 c4x_legitimate_address_p (enum machine_mode mode, rtx addr, int strict)
1456 {
1457   rtx base = NULL_RTX;          /* Base register (AR0-AR7).  */
1458   rtx indx = NULL_RTX;          /* Index register (IR0,IR1).  */
1459   rtx disp = NULL_RTX;          /* Displacement.  */
1460   enum rtx_code code;
1461
1462   code = GET_CODE (addr);
1463   switch (code)
1464     {
1465       /* Register indirect with auto increment/decrement.  We don't
1466          allow SP here---push_operand should recognize an operand
1467          being pushed on the stack.  */
1468
1469     case PRE_DEC:
1470     case PRE_INC:
1471     case POST_DEC:
1472       if (mode != QImode && mode != QFmode)
1473         return 0;
1474
1475     case POST_INC:
1476       base = XEXP (addr, 0);
1477       if (! REG_P (base))
1478         return 0;
1479       break;
1480
1481     case PRE_MODIFY:
1482     case POST_MODIFY:
1483       {
1484         rtx op0 = XEXP (addr, 0);
1485         rtx op1 = XEXP (addr, 1);
1486
1487         if (mode != QImode && mode != QFmode)
1488           return 0;
1489
1490         if (! REG_P (op0) 
1491             || (GET_CODE (op1) != PLUS && GET_CODE (op1) != MINUS))
1492           return 0;
1493         base = XEXP (op1, 0);
1494         if (! REG_P (base))
1495             return 0;
1496         if (REGNO (base) != REGNO (op0))
1497           return 0;
1498         if (REG_P (XEXP (op1, 1)))
1499           indx = XEXP (op1, 1);
1500         else
1501           disp = XEXP (op1, 1);
1502       }
1503       break;
1504         
1505       /* Register indirect.  */
1506     case REG:
1507       base = addr;
1508       break;
1509
1510       /* Register indirect with displacement or index.  */
1511     case PLUS:
1512       {
1513         rtx op0 = XEXP (addr, 0);
1514         rtx op1 = XEXP (addr, 1);
1515         enum rtx_code code0 = GET_CODE (op0);
1516
1517         switch (code0)
1518           {
1519           case REG:
1520             if (REG_P (op1))
1521               {
1522                 base = op0;     /* Base + index.  */
1523                 indx = op1;
1524                 if (IS_INDEX_REG (base) || IS_ADDR_REG (indx))
1525                   {
1526                     base = op1;
1527                     indx = op0;
1528                   }
1529               }
1530             else
1531               {
1532                 base = op0;     /* Base + displacement.  */
1533                 disp = op1;
1534               }
1535             break;
1536
1537           default:
1538             return 0;
1539           }
1540       }
1541       break;
1542
1543       /* Direct addressing with DP register.  */
1544     case LO_SUM:
1545       {
1546         rtx op0 = XEXP (addr, 0);
1547         rtx op1 = XEXP (addr, 1);
1548
1549         /* HImode and HFmode direct memory references aren't truly
1550            offsettable (consider case at end of data page).  We
1551            probably get better code by loading a pointer and using an
1552            indirect memory reference.  */
1553         if (mode == HImode || mode == HFmode)
1554           return 0;
1555
1556         if (!REG_P (op0) || REGNO (op0) != DP_REGNO)
1557           return 0;
1558
1559         if ((GET_CODE (op1) == SYMBOL_REF || GET_CODE (op1) == LABEL_REF))
1560           return 1;
1561
1562         if (GET_CODE (op1) == CONST)
1563           return 1;
1564         return 0;
1565       }
1566       break;
1567
1568       /* Direct addressing with some work for the assembler...  */
1569     case CONST:
1570       /* Direct addressing.  */
1571     case LABEL_REF:
1572     case SYMBOL_REF:
1573       if (! TARGET_EXPOSE_LDP && ! strict && mode != HFmode && mode != HImode)
1574         return 1;
1575       /* These need to be converted to a LO_SUM (...). 
1576          LEGITIMIZE_RELOAD_ADDRESS will do this during reload.  */
1577       return 0;
1578
1579       /* Do not allow direct memory access to absolute addresses.
1580          This is more pain than it's worth, especially for the
1581          small memory model where we can't guarantee that
1582          this address is within the data page---we don't want
1583          to modify the DP register in the small memory model,
1584          even temporarily, since an interrupt can sneak in....  */
1585     case CONST_INT:
1586       return 0;
1587
1588       /* Indirect indirect addressing.  */
1589     case MEM:
1590       return 0;
1591
1592     case CONST_DOUBLE:
1593       fatal_insn ("using CONST_DOUBLE for address", addr);
1594
1595     default:
1596       return 0;
1597     }
1598
1599   /* Validate the base register.  */
1600   if (base)
1601     {
1602       /* Check that the address is offsettable for HImode and HFmode.  */
1603       if (indx && (mode == HImode || mode == HFmode))
1604         return 0;
1605
1606       /* Handle DP based stuff.  */
1607       if (REGNO (base) == DP_REGNO)
1608         return 1;
1609       if (strict && ! REGNO_OK_FOR_BASE_P (REGNO (base)))
1610         return 0;
1611       else if (! strict && ! IS_ADDR_OR_PSEUDO_REG (base))
1612         return 0;
1613     }
1614
1615   /* Now validate the index register.  */
1616   if (indx)
1617     {
1618       if (GET_CODE (indx) != REG)
1619         return 0;
1620       if (strict && ! REGNO_OK_FOR_INDEX_P (REGNO (indx)))
1621         return 0;
1622       else if (! strict && ! IS_INDEX_OR_PSEUDO_REG (indx))
1623         return 0;
1624     }
1625
1626   /* Validate displacement.  */
1627   if (disp)
1628     {
1629       if (GET_CODE (disp) != CONST_INT)
1630         return 0;
1631       if (mode == HImode || mode == HFmode)
1632         {
1633           /* The offset displacement must be legitimate.  */
1634           if (! IS_DISP8_OFF_CONST (INTVAL (disp)))
1635             return 0;
1636         }
1637       else
1638         {
1639           if (! IS_DISP8_CONST (INTVAL (disp)))
1640             return 0;
1641         }
1642       /* Can't add an index with a disp.  */
1643       if (indx)
1644         return 0;               
1645     }
1646   return 1;
1647 }
1648
1649
1650 rtx
1651 c4x_legitimize_address (rtx orig ATTRIBUTE_UNUSED,
1652                         enum machine_mode mode ATTRIBUTE_UNUSED)
1653 {
1654   if (GET_CODE (orig) == SYMBOL_REF
1655       || GET_CODE (orig) == LABEL_REF)
1656     {
1657       if (mode == HImode || mode == HFmode)
1658         {
1659           /* We need to force the address into
1660              a register so that it is offsettable.  */
1661           rtx addr_reg = gen_reg_rtx (Pmode);
1662           emit_move_insn (addr_reg, orig);
1663           return addr_reg;
1664         }
1665       else
1666         {
1667           rtx dp_reg = gen_rtx_REG (Pmode, DP_REGNO);
1668           
1669           if (! TARGET_SMALL)
1670             emit_insn (gen_set_ldp (dp_reg, orig));
1671           
1672           return gen_rtx_LO_SUM (Pmode, dp_reg, orig);
1673         }
1674     }
1675
1676   return NULL_RTX;
1677 }
1678
1679
1680 /* Provide the costs of an addressing mode that contains ADDR.
1681    If ADDR is not a valid address, its cost is irrelevant.  
1682    This is used in cse and loop optimization to determine
1683    if it is worthwhile storing a common address into a register. 
1684    Unfortunately, the C4x address cost depends on other operands.  */
1685
1686 static int 
1687 c4x_address_cost (rtx addr)
1688 {
1689   switch (GET_CODE (addr))
1690     {
1691     case REG:
1692       return 1;
1693
1694     case POST_INC:
1695     case POST_DEC:
1696     case PRE_INC:
1697     case PRE_DEC:
1698       return 1;
1699       
1700       /* These shouldn't be directly generated.  */
1701     case SYMBOL_REF:
1702     case LABEL_REF:
1703     case CONST:
1704       return 10;
1705
1706     case LO_SUM:
1707       {
1708         rtx op1 = XEXP (addr, 1);
1709
1710         if (GET_CODE (op1) == LABEL_REF || GET_CODE (op1) == SYMBOL_REF)
1711           return TARGET_SMALL ? 3 : 4;
1712         
1713         if (GET_CODE (op1) == CONST)
1714           {
1715             rtx offset = const0_rtx;
1716             
1717             op1 = eliminate_constant_term (op1, &offset);
1718             
1719             /* ??? These costs need rethinking...  */
1720             if (GET_CODE (op1) == LABEL_REF)
1721               return 3;
1722             
1723             if (GET_CODE (op1) != SYMBOL_REF)
1724               return 4;
1725             
1726             if (INTVAL (offset) == 0)
1727               return 3;
1728
1729             return 4;
1730           }
1731         fatal_insn ("c4x_address_cost: Invalid addressing mode", addr);
1732       }
1733       break;
1734       
1735     case PLUS:
1736       {
1737         register rtx op0 = XEXP (addr, 0);
1738         register rtx op1 = XEXP (addr, 1);
1739         
1740         if (GET_CODE (op0) != REG)
1741           break;
1742         
1743         switch (GET_CODE (op1))
1744           {
1745           default:
1746             break;
1747
1748           case REG:
1749             /* This cost for REG+REG must be greater than the cost
1750                for REG if we want autoincrement addressing modes.  */
1751             return 2;
1752
1753           case CONST_INT:
1754             /* The following tries to improve GIV combination
1755                in strength reduce but appears not to help.  */
1756             if (TARGET_DEVEL && IS_UINT5_CONST (INTVAL (op1)))
1757               return 1;
1758
1759             if (IS_DISP1_CONST (INTVAL (op1)))
1760               return 1;
1761
1762             if (! TARGET_C3X && IS_UINT5_CONST (INTVAL (op1)))
1763               return 2;
1764
1765             return 3;
1766           }
1767       }
1768     default:
1769       break;
1770     }
1771   
1772   return 4;
1773 }
1774
1775
1776 rtx
1777 c4x_gen_compare_reg (enum rtx_code code, rtx x, rtx y)
1778 {
1779   enum machine_mode mode = SELECT_CC_MODE (code, x, y);
1780   rtx cc_reg;
1781
1782   if (mode == CC_NOOVmode
1783       && (code == LE || code == GE || code == LT || code == GT))
1784     return NULL_RTX;
1785
1786   cc_reg = gen_rtx_REG (mode, ST_REGNO);
1787   emit_insn (gen_rtx_SET (VOIDmode, cc_reg,
1788                           gen_rtx_COMPARE (mode, x, y)));
1789   return cc_reg;
1790 }
1791
1792 char *
1793 c4x_output_cbranch (const char *form, rtx seq)
1794 {
1795   int delayed = 0;
1796   int annultrue = 0;
1797   int annulfalse = 0;
1798   rtx delay;
1799   char *cp;
1800   static char str[100];
1801   
1802   if (final_sequence)
1803     {
1804       delay = XVECEXP (final_sequence, 0, 1);
1805       delayed = ! INSN_ANNULLED_BRANCH_P (seq);
1806       annultrue = INSN_ANNULLED_BRANCH_P (seq) && ! INSN_FROM_TARGET_P (delay);
1807       annulfalse = INSN_ANNULLED_BRANCH_P (seq) && INSN_FROM_TARGET_P (delay);
1808     }
1809   strcpy (str, form);
1810   cp = &str [strlen (str)];
1811   if (delayed)
1812     {
1813       *cp++ = '%';
1814       *cp++ = '#';
1815     }
1816   if (annultrue)
1817     {
1818       *cp++ = 'a';
1819       *cp++ = 't';
1820     }
1821   if (annulfalse)
1822     {
1823       *cp++ = 'a'; 
1824       *cp++ = 'f';
1825     }
1826   *cp++ = '\t';
1827   *cp++ = '%'; 
1828   *cp++ = 'l';
1829   *cp++ = '1';
1830   *cp = 0;
1831   return str;
1832 }
1833
1834 void
1835 c4x_print_operand (FILE *file, rtx op, int letter)
1836 {
1837   rtx op1;
1838   enum rtx_code code;
1839
1840   switch (letter)
1841     {
1842     case '#':                   /* Delayed.  */
1843       if (final_sequence)
1844         fprintf (file, "d");
1845       return;
1846     }
1847
1848   code = GET_CODE (op);
1849   switch (letter)
1850     {
1851     case 'A':                   /* Direct address.  */
1852       if (code == CONST_INT || code == SYMBOL_REF || code == CONST)
1853         fprintf (file, "@");
1854       break;
1855
1856     case 'H':                   /* Sethi.  */
1857       output_addr_const (file, op);
1858       return;
1859
1860     case 'I':                   /* Reversed condition.  */
1861       code = reverse_condition (code);
1862       break;
1863
1864     case 'L':                   /* Log 2 of constant.  */
1865       if (code != CONST_INT)
1866         fatal_insn ("c4x_print_operand: %%L inconsistency", op);
1867       fprintf (file, "%d", exact_log2 (INTVAL (op)));
1868       return;
1869
1870     case 'N':                   /* Ones complement of small constant.  */
1871       if (code != CONST_INT)
1872         fatal_insn ("c4x_print_operand: %%N inconsistency", op);
1873       fprintf (file, HOST_WIDE_INT_PRINT_DEC, ~INTVAL (op));
1874       return;
1875
1876     case 'K':                   /* Generate ldp(k) if direct address.  */
1877       if (! TARGET_SMALL
1878           && code == MEM
1879           && GET_CODE (XEXP (op, 0)) == LO_SUM
1880           && GET_CODE (XEXP (XEXP (op, 0), 0)) == REG
1881           && REGNO (XEXP (XEXP (op, 0), 0)) == DP_REGNO)
1882         {
1883           op1 = XEXP (XEXP (op, 0), 1);
1884           if (GET_CODE(op1) == CONST_INT || GET_CODE(op1) == SYMBOL_REF)
1885             {
1886               fprintf (file, "\t%s\t@", TARGET_C3X ? "ldp" : "ldpk");
1887               output_address (XEXP (adjust_address (op, VOIDmode, 1), 0));
1888               fprintf (file, "\n");
1889             }
1890         }
1891       return;
1892
1893     case 'M':                   /* Generate ldp(k) if direct address.  */
1894       if (! TARGET_SMALL        /* Only used in asm statements.  */
1895           && code == MEM
1896           && (GET_CODE (XEXP (op, 0)) == CONST
1897               || GET_CODE (XEXP (op, 0)) == SYMBOL_REF))
1898         {
1899           fprintf (file, "%s\t@", TARGET_C3X ? "ldp" : "ldpk");
1900           output_address (XEXP (op, 0));
1901           fprintf (file, "\n\t");
1902         }
1903       return;
1904
1905     case 'O':                   /* Offset address.  */
1906       if (code == MEM && c4x_autoinc_operand (op, Pmode))
1907         break;
1908       else if (code == MEM)
1909         output_address (XEXP (adjust_address (op, VOIDmode, 1), 0));
1910       else if (code == REG)
1911         fprintf (file, "%s", reg_names[REGNO (op) + 1]);
1912       else
1913         fatal_insn ("c4x_print_operand: %%O inconsistency", op);
1914       return;
1915
1916     case 'C':                   /* Call.  */
1917       break;
1918
1919     case 'U':                   /* Call/callu.  */
1920       if (code != SYMBOL_REF)
1921         fprintf (file, "u");
1922       return;
1923
1924     default:
1925       break;
1926     }
1927   
1928   switch (code)
1929     {
1930     case REG:
1931       if (GET_MODE_CLASS (GET_MODE (op)) == MODE_FLOAT
1932           && ! TARGET_TI)
1933         fprintf (file, "%s", float_reg_names[REGNO (op)]);
1934       else
1935         fprintf (file, "%s", reg_names[REGNO (op)]);
1936       break;
1937       
1938     case MEM:
1939       output_address (XEXP (op, 0));
1940       break;
1941       
1942     case CONST_DOUBLE:
1943       {
1944         char str[64];
1945         
1946         real_to_decimal (str, CONST_DOUBLE_REAL_VALUE (op),
1947                          sizeof (str), 0, 1);
1948         fprintf (file, "%s", str);
1949       }
1950       break;
1951       
1952     case CONST_INT:
1953       fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (op));
1954       break;
1955       
1956     case NE:
1957       fprintf (file, "ne");
1958       break;
1959       
1960     case EQ:
1961       fprintf (file, "eq");
1962       break;
1963       
1964     case GE:
1965       fprintf (file, "ge");
1966       break;
1967
1968     case GT:
1969       fprintf (file, "gt");
1970       break;
1971
1972     case LE:
1973       fprintf (file, "le");
1974       break;
1975
1976     case LT:
1977       fprintf (file, "lt");
1978       break;
1979
1980     case GEU:
1981       fprintf (file, "hs");
1982       break;
1983
1984     case GTU:
1985       fprintf (file, "hi");
1986       break;
1987
1988     case LEU:
1989       fprintf (file, "ls");
1990       break;
1991
1992     case LTU:
1993       fprintf (file, "lo");
1994       break;
1995
1996     case SYMBOL_REF:
1997       output_addr_const (file, op);
1998       break;
1999
2000     case CONST:
2001       output_addr_const (file, XEXP (op, 0));
2002       break;
2003
2004     case CODE_LABEL:
2005       break;
2006
2007     default:
2008       fatal_insn ("c4x_print_operand: Bad operand case", op);
2009       break;
2010     }
2011 }
2012
2013
2014 void
2015 c4x_print_operand_address (FILE *file, rtx addr)
2016 {
2017   switch (GET_CODE (addr))
2018     {
2019     case REG:
2020       fprintf (file, "*%s", reg_names[REGNO (addr)]);
2021       break;
2022
2023     case PRE_DEC:
2024       fprintf (file, "*--%s", reg_names[REGNO (XEXP (addr, 0))]);
2025       break;
2026
2027     case POST_INC:
2028       fprintf (file, "*%s++", reg_names[REGNO (XEXP (addr, 0))]);
2029       break;
2030
2031     case POST_MODIFY:
2032       {
2033         rtx op0 = XEXP (XEXP (addr, 1), 0);
2034         rtx op1 = XEXP (XEXP (addr, 1), 1);
2035         
2036         if (GET_CODE (XEXP (addr, 1)) == PLUS && REG_P (op1))
2037           fprintf (file, "*%s++(%s)", reg_names[REGNO (op0)],
2038                    reg_names[REGNO (op1)]);
2039         else if (GET_CODE (XEXP (addr, 1)) == PLUS && INTVAL (op1) > 0)
2040           fprintf (file, "*%s++(" HOST_WIDE_INT_PRINT_DEC ")",
2041                    reg_names[REGNO (op0)], INTVAL (op1));
2042         else if (GET_CODE (XEXP (addr, 1)) == PLUS && INTVAL (op1) < 0)
2043           fprintf (file, "*%s--(" HOST_WIDE_INT_PRINT_DEC ")",
2044                    reg_names[REGNO (op0)], -INTVAL (op1));
2045         else if (GET_CODE (XEXP (addr, 1)) == MINUS && REG_P (op1))
2046           fprintf (file, "*%s--(%s)", reg_names[REGNO (op0)],
2047                    reg_names[REGNO (op1)]);
2048         else
2049           fatal_insn ("c4x_print_operand_address: Bad post_modify", addr);
2050       }
2051       break;
2052       
2053     case PRE_MODIFY:
2054       {
2055         rtx op0 = XEXP (XEXP (addr, 1), 0);
2056         rtx op1 = XEXP (XEXP (addr, 1), 1);
2057         
2058         if (GET_CODE (XEXP (addr, 1)) == PLUS && REG_P (op1))
2059           fprintf (file, "*++%s(%s)", reg_names[REGNO (op0)],
2060                    reg_names[REGNO (op1)]);
2061         else if (GET_CODE (XEXP (addr, 1)) == PLUS && INTVAL (op1) > 0)
2062           fprintf (file, "*++%s(" HOST_WIDE_INT_PRINT_DEC ")",
2063                    reg_names[REGNO (op0)], INTVAL (op1));
2064         else if (GET_CODE (XEXP (addr, 1)) == PLUS && INTVAL (op1) < 0)
2065           fprintf (file, "*--%s(" HOST_WIDE_INT_PRINT_DEC ")",
2066                    reg_names[REGNO (op0)], -INTVAL (op1));
2067         else if (GET_CODE (XEXP (addr, 1)) == MINUS && REG_P (op1))
2068           fprintf (file, "*--%s(%s)", reg_names[REGNO (op0)],
2069                    reg_names[REGNO (op1)]);
2070         else
2071           fatal_insn ("c4x_print_operand_address: Bad pre_modify", addr);
2072       }
2073       break;
2074       
2075     case PRE_INC:
2076       fprintf (file, "*++%s", reg_names[REGNO (XEXP (addr, 0))]);
2077       break;
2078
2079     case POST_DEC:
2080       fprintf (file, "*%s--", reg_names[REGNO (XEXP (addr, 0))]);
2081       break;
2082
2083     case PLUS:                  /* Indirect with displacement.  */
2084       {
2085         rtx op0 = XEXP (addr, 0);
2086         rtx op1 = XEXP (addr, 1);
2087
2088         if (REG_P (op0))
2089           {
2090             if (REG_P (op1))
2091               {
2092                 if (IS_INDEX_REG (op0))
2093                   {
2094                     fprintf (file, "*+%s(%s)",
2095                              reg_names[REGNO (op1)],
2096                              reg_names[REGNO (op0)]);   /* Index + base.  */
2097                   }
2098                 else
2099                   {
2100                     fprintf (file, "*+%s(%s)",
2101                              reg_names[REGNO (op0)],
2102                              reg_names[REGNO (op1)]);   /* Base + index.  */
2103                   }
2104               }
2105             else if (INTVAL (op1) < 0)
2106               {
2107                 fprintf (file, "*-%s(" HOST_WIDE_INT_PRINT_DEC ")",
2108                          reg_names[REGNO (op0)],
2109                          -INTVAL (op1));        /* Base - displacement.  */
2110               }
2111             else
2112               {
2113                 fprintf (file, "*+%s(" HOST_WIDE_INT_PRINT_DEC ")",
2114                          reg_names[REGNO (op0)],
2115                          INTVAL (op1)); /* Base + displacement.  */
2116               }
2117           }
2118         else
2119           fatal_insn ("c4x_print_operand_address: Bad operand case", addr);
2120       }
2121       break;
2122
2123     case LO_SUM:
2124       {
2125         rtx op0 = XEXP (addr, 0);
2126         rtx op1 = XEXP (addr, 1);
2127           
2128         if (REG_P (op0) && REGNO (op0) == DP_REGNO)
2129           c4x_print_operand_address (file, op1);
2130         else
2131           fatal_insn ("c4x_print_operand_address: Bad operand case", addr);
2132       }
2133       break;
2134
2135     case CONST:
2136     case SYMBOL_REF:
2137     case LABEL_REF:
2138       fprintf (file, "@");
2139       output_addr_const (file, addr);
2140       break;
2141
2142       /* We shouldn't access CONST_INT addresses.  */
2143     case CONST_INT:
2144
2145     default:
2146       fatal_insn ("c4x_print_operand_address: Bad operand case", addr);
2147       break;
2148     }
2149 }
2150
2151
2152 /* Return nonzero if the floating point operand will fit
2153    in the immediate field.  */
2154
2155 static int
2156 c4x_immed_float_p (rtx op)
2157 {
2158   long convval[2];
2159   int exponent;
2160   REAL_VALUE_TYPE r;
2161
2162   REAL_VALUE_FROM_CONST_DOUBLE (r, op);
2163   if (GET_MODE (op) == HFmode)
2164     REAL_VALUE_TO_TARGET_DOUBLE (r, convval);
2165   else
2166     {
2167       REAL_VALUE_TO_TARGET_SINGLE (r, convval[0]);
2168       convval[1] = 0;
2169     }
2170
2171   /* Sign extend exponent.  */
2172   exponent = (((convval[0] >> 24) & 0xff) ^ 0x80) - 0x80;
2173   if (exponent == -128)
2174     return 1;                   /* 0.0  */
2175   if ((convval[0] & 0x00000fff) != 0 || convval[1] != 0)
2176     return 0;                   /* Precision doesn't fit.  */
2177   return (exponent <= 7)        /* Positive exp.  */
2178     && (exponent >= -7);        /* Negative exp.  */
2179 }
2180
2181
2182 /* The last instruction in a repeat block cannot be a Bcond, DBcound,
2183    CALL, CALLCond, TRAPcond, RETIcond, RETScond, IDLE, RPTB or RPTS.
2184
2185    None of the last four instructions from the bottom of the block can
2186    be a BcondD, BRD, DBcondD, RPTBD, LAJ, LAJcond, LATcond, BcondAF,
2187    BcondAT or RETIcondD.
2188
2189    This routine scans the four previous insns for a jump insn, and if
2190    one is found, returns 1 so that we bung in a nop instruction.
2191    This simple minded strategy will add a nop, when it may not
2192    be required.  Say when there is a JUMP_INSN near the end of the
2193    block that doesn't get converted into a delayed branch.
2194
2195    Note that we cannot have a call insn, since we don't generate
2196    repeat loops with calls in them (although I suppose we could, but
2197    there's no benefit.)  
2198
2199    !!! FIXME.  The rptb_top insn may be sucked into a SEQUENCE.  */
2200
2201 int
2202 c4x_rptb_nop_p (rtx insn)
2203 {
2204   rtx start_label;
2205   int i;
2206
2207   /* Extract the start label from the jump pattern (rptb_end).  */
2208   start_label = XEXP (XEXP (SET_SRC (XVECEXP (PATTERN (insn), 0, 0)), 1), 0);
2209
2210   /* If there is a label at the end of the loop we must insert
2211      a NOP.  */
2212   do {
2213     insn = previous_insn (insn);
2214   } while (GET_CODE (insn) == NOTE
2215            || GET_CODE (insn) == USE
2216            || GET_CODE (insn) == CLOBBER);
2217   if (GET_CODE (insn) == CODE_LABEL)
2218     return 1;
2219
2220   for (i = 0; i < 4; i++)
2221     {
2222       /* Search back for prev non-note and non-label insn.  */
2223       while (GET_CODE (insn) == NOTE || GET_CODE (insn) == CODE_LABEL
2224              || GET_CODE (insn) == USE || GET_CODE (insn) == CLOBBER)
2225         {
2226           if (insn == start_label)
2227             return i == 0;
2228
2229           insn = previous_insn (insn);
2230         };
2231
2232       /* If we have a jump instruction we should insert a NOP. If we
2233          hit repeat block top we should only insert a NOP if the loop
2234          is empty.  */
2235       if (GET_CODE (insn) == JUMP_INSN)
2236         return 1;
2237       insn = previous_insn (insn);
2238     }
2239   return 0;
2240 }
2241
2242
2243 /* The C4x looping instruction needs to be emitted at the top of the
2244   loop.  Emitting the true RTL for a looping instruction at the top of
2245   the loop can cause problems with flow analysis.  So instead, a dummy
2246   doloop insn is emitted at the end of the loop.  This routine checks
2247   for the presence of this doloop insn and then searches back to the
2248   top of the loop, where it inserts the true looping insn (provided
2249   there are no instructions in the loop which would cause problems).
2250   Any additional labels can be emitted at this point.  In addition, if
2251   the desired loop count register was not allocated, this routine does
2252   nothing. 
2253
2254   Before we can create a repeat block looping instruction we have to
2255   verify that there are no jumps outside the loop and no jumps outside
2256   the loop go into this loop. This can happen in the basic blocks reorder
2257   pass. The C4x cpu can not handle this.  */
2258
2259 static int
2260 c4x_label_ref_used_p (rtx x, rtx code_label)
2261 {
2262   enum rtx_code code;
2263   int i, j;
2264   const char *fmt;
2265
2266   if (x == 0)
2267     return 0;
2268
2269   code = GET_CODE (x);
2270   if (code == LABEL_REF)
2271     return INSN_UID (XEXP (x,0)) == INSN_UID (code_label);
2272
2273   fmt = GET_RTX_FORMAT (code);
2274   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2275     {
2276       if (fmt[i] == 'e')
2277         {
2278           if (c4x_label_ref_used_p (XEXP (x, i), code_label))
2279             return 1;
2280         }
2281       else if (fmt[i] == 'E')
2282         for (j = XVECLEN (x, i) - 1; j >= 0; j--)
2283           if (c4x_label_ref_used_p (XVECEXP (x, i, j), code_label))
2284             return 1;
2285     }
2286   return 0;
2287 }
2288
2289
2290 static int
2291 c4x_rptb_valid_p (rtx insn, rtx start_label)
2292 {
2293   rtx end = insn;
2294   rtx start;
2295   rtx tmp;
2296
2297   /* Find the start label.  */
2298   for (; insn; insn = PREV_INSN (insn))
2299     if (insn == start_label)
2300       break;
2301
2302   /* Note found then we can not use a rptb or rpts.  The label was
2303      probably moved by the basic block reorder pass.  */
2304   if (! insn)
2305     return 0;
2306
2307   start = insn;
2308   /* If any jump jumps inside this block then we must fail.  */
2309   for (insn = PREV_INSN (start); insn; insn = PREV_INSN (insn))
2310     {
2311       if (GET_CODE (insn) == CODE_LABEL)
2312         {
2313           for (tmp = NEXT_INSN (start); tmp != end; tmp = NEXT_INSN(tmp))
2314             if (GET_CODE (tmp) == JUMP_INSN
2315                 && c4x_label_ref_used_p (tmp, insn))
2316               return 0;
2317         }
2318     }
2319   for (insn = NEXT_INSN (end); insn; insn = NEXT_INSN (insn))
2320     {
2321       if (GET_CODE (insn) == CODE_LABEL)
2322         {
2323           for (tmp = NEXT_INSN (start); tmp != end; tmp = NEXT_INSN(tmp))
2324             if (GET_CODE (tmp) == JUMP_INSN
2325                 && c4x_label_ref_used_p (tmp, insn))
2326               return 0;
2327         }
2328     }
2329   /* If any jump jumps outside this block then we must fail.  */
2330   for (insn = NEXT_INSN (start); insn != end; insn = NEXT_INSN (insn))
2331     {
2332       if (GET_CODE (insn) == CODE_LABEL)
2333         {
2334           for (tmp = NEXT_INSN (end); tmp; tmp = NEXT_INSN(tmp))
2335             if (GET_CODE (tmp) == JUMP_INSN
2336                 && c4x_label_ref_used_p (tmp, insn))
2337               return 0;
2338           for (tmp = PREV_INSN (start); tmp; tmp = PREV_INSN(tmp))
2339             if (GET_CODE (tmp) == JUMP_INSN
2340                 && c4x_label_ref_used_p (tmp, insn))
2341               return 0;
2342         }
2343     }
2344
2345   /* All checks OK.  */
2346   return 1;
2347 }
2348
2349
2350 void
2351 c4x_rptb_insert (rtx insn)
2352 {
2353   rtx end_label;
2354   rtx start_label;
2355   rtx new_start_label;
2356   rtx count_reg;
2357
2358   /* If the count register has not been allocated to RC, say if
2359      there is a movmem pattern in the loop, then do not insert a
2360      RPTB instruction.  Instead we emit a decrement and branch
2361      at the end of the loop.  */
2362   count_reg = XEXP (XEXP (SET_SRC (XVECEXP (PATTERN (insn), 0, 0)), 0), 0);
2363   if (REGNO (count_reg) != RC_REGNO)
2364     return;
2365
2366   /* Extract the start label from the jump pattern (rptb_end).  */
2367   start_label = XEXP (XEXP (SET_SRC (XVECEXP (PATTERN (insn), 0, 0)), 1), 0);
2368   
2369   if (! c4x_rptb_valid_p (insn, start_label))
2370     {
2371       /* We can not use the rptb insn.  Replace it so reorg can use
2372          the delay slots of the jump insn.  */
2373       emit_insn_before (gen_addqi3 (count_reg, count_reg, constm1_rtx), insn);
2374       emit_insn_before (gen_cmpqi (count_reg, const0_rtx), insn);
2375       emit_insn_before (gen_bge (start_label), insn);
2376       LABEL_NUSES (start_label)++;
2377       delete_insn (insn);
2378       return;
2379     }
2380
2381   end_label = gen_label_rtx ();
2382   LABEL_NUSES (end_label)++;
2383   emit_label_after (end_label, insn);
2384
2385   new_start_label = gen_label_rtx ();
2386   LABEL_NUSES (new_start_label)++;
2387
2388   for (; insn; insn = PREV_INSN (insn))
2389     {
2390       if (insn == start_label)
2391          break;
2392       if (GET_CODE (insn) == JUMP_INSN &&
2393           JUMP_LABEL (insn) == start_label)
2394         redirect_jump (insn, new_start_label, 0);
2395     }
2396   if (! insn)
2397     fatal_insn ("c4x_rptb_insert: Cannot find start label", start_label);
2398
2399   emit_label_after (new_start_label, insn);
2400
2401   if (TARGET_RPTS && c4x_rptb_rpts_p (PREV_INSN (insn), 0))
2402     emit_insn_after (gen_rpts_top (new_start_label, end_label), insn);
2403   else
2404     emit_insn_after (gen_rptb_top (new_start_label, end_label), insn);
2405   if (LABEL_NUSES (start_label) == 0)
2406     delete_insn (start_label);
2407 }
2408
2409
2410 /* We need to use direct addressing for large constants and addresses
2411    that cannot fit within an instruction.  We must check for these
2412    after after the final jump optimization pass, since this may
2413    introduce a local_move insn for a SYMBOL_REF.  This pass
2414    must come before delayed branch slot filling since it can generate
2415    additional instructions.
2416
2417    This function also fixes up RTPB style loops that didn't get RC
2418    allocated as the loop counter.  */
2419
2420 static void
2421 c4x_reorg (void)
2422 {
2423   rtx insn;
2424
2425   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
2426     {
2427       /* Look for insn.  */
2428       if (INSN_P (insn))
2429         {
2430           int insn_code_number;
2431           rtx old;
2432
2433           insn_code_number = recog_memoized (insn);
2434
2435           if (insn_code_number < 0)
2436             continue;
2437
2438           /* Insert the RTX for RPTB at the top of the loop
2439              and a label at the end of the loop.  */
2440           if (insn_code_number == CODE_FOR_rptb_end)
2441             c4x_rptb_insert(insn);
2442
2443           /* We need to split the insn here. Otherwise the calls to
2444              force_const_mem will not work for load_immed_address.  */
2445           old = insn;
2446
2447           /* Don't split the insn if it has been deleted.  */
2448           if (! INSN_DELETED_P (old))
2449             insn = try_split (PATTERN(old), old, 1);
2450
2451           /* When not optimizing, the old insn will be still left around
2452              with only the 'deleted' bit set.  Transform it into a note
2453              to avoid confusion of subsequent processing.  */
2454           if (INSN_DELETED_P (old))
2455             {
2456               PUT_CODE (old, NOTE);
2457               NOTE_LINE_NUMBER (old) = NOTE_INSN_DELETED;
2458               NOTE_SOURCE_FILE (old) = 0;
2459             }
2460         }
2461     }
2462 }
2463
2464
2465 static int
2466 c4x_a_register (rtx op)
2467 {
2468   return REG_P (op) && IS_ADDR_OR_PSEUDO_REG (op);
2469 }
2470
2471
2472 static int
2473 c4x_x_register (rtx op)
2474 {
2475   return REG_P (op) && IS_INDEX_OR_PSEUDO_REG (op);
2476 }
2477
2478
2479 static int
2480 c4x_immed_int_constant (rtx op)
2481 {
2482   if (GET_CODE (op) != CONST_INT)
2483     return 0;
2484
2485   return GET_MODE (op) == VOIDmode
2486     || GET_MODE_CLASS (GET_MODE (op)) == MODE_INT
2487     || GET_MODE_CLASS (GET_MODE (op)) == MODE_PARTIAL_INT;
2488 }
2489
2490
2491 static int
2492 c4x_immed_float_constant (rtx op)
2493 {
2494   if (GET_CODE (op) != CONST_DOUBLE)
2495     return 0;
2496
2497   /* Do not check if the CONST_DOUBLE is in memory. If there is a MEM
2498      present this only means that a MEM rtx has been generated. It does
2499      not mean the rtx is really in memory.  */
2500
2501   return GET_MODE (op) == QFmode || GET_MODE (op) == HFmode;
2502 }
2503
2504
2505 int
2506 c4x_shiftable_constant (rtx op)
2507 {
2508   int i;
2509   int mask;
2510   int val = INTVAL (op);
2511
2512   for (i = 0; i < 16; i++)
2513     {
2514       if (val & (1 << i))
2515         break;
2516     }
2517   mask = ((0xffff >> i) << 16) | 0xffff;
2518   if (IS_INT16_CONST (val & (1 << 31) ? (val >> i) | ~mask
2519                                       : (val >> i) & mask))
2520     return i;
2521   return -1;
2522
2523
2524
2525 int
2526 c4x_H_constant (rtx op)
2527 {
2528   return c4x_immed_float_constant (op) && c4x_immed_float_p (op);
2529 }
2530
2531
2532 int
2533 c4x_I_constant (rtx op)
2534 {
2535   return c4x_immed_int_constant (op) && IS_INT16_CONST (INTVAL (op));
2536 }
2537
2538
2539 int
2540 c4x_J_constant (rtx op)
2541 {
2542   if (TARGET_C3X)
2543     return 0;
2544   return c4x_immed_int_constant (op) && IS_INT8_CONST (INTVAL (op));
2545 }
2546
2547
2548 static int
2549 c4x_K_constant (rtx op)
2550 {
2551   if (TARGET_C3X || ! c4x_immed_int_constant (op))
2552     return 0;
2553   return IS_INT5_CONST (INTVAL (op));
2554 }
2555
2556
2557 int
2558 c4x_L_constant (rtx op)
2559 {
2560   return c4x_immed_int_constant (op) && IS_UINT16_CONST (INTVAL (op));
2561 }
2562
2563
2564 static int
2565 c4x_N_constant (rtx op)
2566 {
2567   return c4x_immed_int_constant (op) && IS_NOT_UINT16_CONST (INTVAL (op));
2568 }
2569
2570
2571 static int
2572 c4x_O_constant (rtx op)
2573 {
2574   return c4x_immed_int_constant (op) && IS_HIGH_CONST (INTVAL (op));
2575 }
2576
2577
2578 /* The constraints do not have to check the register class,
2579    except when needed to discriminate between the constraints.
2580    The operand has been checked by the predicates to be valid.  */
2581
2582 /* ARx + 9-bit signed const or IRn
2583    *ARx, *+ARx(n), *-ARx(n), *+ARx(IRn), *-Arx(IRn) for -256 < n < 256
2584    We don't include the pre/post inc/dec forms here since
2585    they are handled by the <> constraints.  */
2586
2587 int
2588 c4x_Q_constraint (rtx op)
2589 {
2590   enum machine_mode mode = GET_MODE (op);
2591
2592   if (GET_CODE (op) != MEM)
2593     return 0;
2594   op = XEXP (op, 0);
2595   switch (GET_CODE (op))
2596     {
2597     case REG:
2598       return 1;
2599
2600     case PLUS:
2601       {
2602         rtx op0 = XEXP (op, 0);
2603         rtx op1 = XEXP (op, 1);
2604
2605         if (! REG_P (op0))
2606           return 0;
2607
2608         if (REG_P (op1))
2609           return 1;
2610
2611         if (GET_CODE (op1) != CONST_INT)
2612           return 0;
2613
2614         /* HImode and HFmode must be offsettable.  */
2615         if (mode == HImode || mode == HFmode)
2616           return IS_DISP8_OFF_CONST (INTVAL (op1));
2617         
2618         return IS_DISP8_CONST (INTVAL (op1));
2619       }
2620       break;
2621
2622     default:
2623       break;
2624     }
2625   return 0;
2626 }
2627
2628
2629 /* ARx + 5-bit unsigned const
2630    *ARx, *+ARx(n) for n < 32.  */
2631
2632 int
2633 c4x_R_constraint (rtx op)
2634 {
2635   enum machine_mode mode = GET_MODE (op);
2636
2637   if (TARGET_C3X)
2638     return 0;
2639   if (GET_CODE (op) != MEM)
2640     return 0;
2641   op = XEXP (op, 0);
2642   switch (GET_CODE (op))
2643     {
2644     case REG:
2645       return 1;
2646
2647     case PLUS:
2648       {
2649         rtx op0 = XEXP (op, 0);
2650         rtx op1 = XEXP (op, 1);
2651
2652         if (! REG_P (op0))
2653           return 0;
2654
2655         if (GET_CODE (op1) != CONST_INT)
2656           return 0;
2657
2658         /* HImode and HFmode must be offsettable.  */
2659         if (mode == HImode || mode == HFmode)
2660           return IS_UINT5_CONST (INTVAL (op1) + 1);
2661         
2662         return IS_UINT5_CONST (INTVAL (op1));
2663       }
2664       break;
2665
2666     default:
2667       break;
2668     }
2669   return 0;
2670 }
2671
2672
2673 static int
2674 c4x_R_indirect (rtx op)
2675 {
2676   enum machine_mode mode = GET_MODE (op);
2677
2678   if (TARGET_C3X || GET_CODE (op) != MEM)
2679     return 0;
2680
2681   op = XEXP (op, 0);
2682   switch (GET_CODE (op))
2683     {
2684     case REG:
2685       return IS_ADDR_OR_PSEUDO_REG (op);
2686
2687     case PLUS:
2688       {
2689         rtx op0 = XEXP (op, 0);
2690         rtx op1 = XEXP (op, 1);
2691
2692         /* HImode and HFmode must be offsettable.  */
2693         if (mode == HImode || mode == HFmode)
2694           return IS_ADDR_OR_PSEUDO_REG (op0)
2695             && GET_CODE (op1) == CONST_INT 
2696             && IS_UINT5_CONST (INTVAL (op1) + 1);
2697
2698         return REG_P (op0)
2699           && IS_ADDR_OR_PSEUDO_REG (op0)
2700           && GET_CODE (op1) == CONST_INT
2701           && IS_UINT5_CONST (INTVAL (op1));
2702       }
2703       break;
2704
2705     default:
2706       break;
2707     }
2708   return 0;
2709 }
2710
2711
2712 /* ARx + 1-bit unsigned const or IRn
2713    *ARx, *+ARx(1), *-ARx(1), *+ARx(IRn), *-Arx(IRn)
2714    We don't include the pre/post inc/dec forms here since
2715    they are handled by the <> constraints.  */
2716
2717 int
2718 c4x_S_constraint (rtx op)
2719 {
2720   enum machine_mode mode = GET_MODE (op);
2721   if (GET_CODE (op) != MEM)
2722     return 0;
2723   op = XEXP (op, 0);
2724   switch (GET_CODE (op))
2725     {
2726     case REG:
2727       return 1;
2728
2729     case PRE_MODIFY:
2730     case POST_MODIFY:
2731       {
2732         rtx op0 = XEXP (op, 0);
2733         rtx op1 = XEXP (op, 1);
2734         
2735         if ((GET_CODE (op1) != PLUS && GET_CODE (op1) != MINUS)
2736             || (op0 != XEXP (op1, 0)))
2737           return 0;
2738         
2739         op0 = XEXP (op1, 0);
2740         op1 = XEXP (op1, 1);
2741         return REG_P (op0) && REG_P (op1);
2742         /* Pre or post_modify with a displacement of 0 or 1 
2743            should not be generated.  */
2744       }
2745       break;
2746
2747     case PLUS:
2748       {
2749         rtx op0 = XEXP (op, 0);
2750         rtx op1 = XEXP (op, 1);
2751
2752         if (!REG_P (op0))
2753           return 0;
2754
2755         if (REG_P (op1))
2756           return 1;
2757
2758         if (GET_CODE (op1) != CONST_INT)
2759           return 0;
2760         
2761         /* HImode and HFmode must be offsettable.  */
2762         if (mode == HImode || mode == HFmode)
2763           return IS_DISP1_OFF_CONST (INTVAL (op1));
2764         
2765         return IS_DISP1_CONST (INTVAL (op1));
2766       }
2767       break;
2768
2769     default:
2770       break;
2771     }
2772   return 0;
2773 }
2774
2775
2776 static int
2777 c4x_S_indirect (rtx op)
2778 {
2779   enum machine_mode mode = GET_MODE (op);
2780   if (GET_CODE (op) != MEM)
2781     return 0;
2782
2783   op = XEXP (op, 0);
2784   switch (GET_CODE (op))
2785     {
2786     case PRE_DEC:
2787     case POST_DEC:
2788       if (mode != QImode && mode != QFmode)
2789         return 0;
2790     case PRE_INC:
2791     case POST_INC:
2792       op = XEXP (op, 0);
2793
2794     case REG:
2795       return IS_ADDR_OR_PSEUDO_REG (op);
2796
2797     case PRE_MODIFY:
2798     case POST_MODIFY:
2799       {
2800         rtx op0 = XEXP (op, 0);
2801         rtx op1 = XEXP (op, 1);
2802         
2803         if (mode != QImode && mode != QFmode)
2804           return 0;
2805
2806         if ((GET_CODE (op1) != PLUS && GET_CODE (op1) != MINUS)
2807             || (op0 != XEXP (op1, 0)))
2808           return 0;
2809         
2810         op0 = XEXP (op1, 0);
2811         op1 = XEXP (op1, 1);
2812         return REG_P (op0) && IS_ADDR_OR_PSEUDO_REG (op0)
2813           && REG_P (op1) && IS_INDEX_OR_PSEUDO_REG (op1);
2814         /* Pre or post_modify with a displacement of 0 or 1 
2815            should not be generated.  */
2816       }
2817
2818     case PLUS:
2819       {
2820         rtx op0 = XEXP (op, 0);
2821         rtx op1 = XEXP (op, 1);
2822
2823         if (REG_P (op0))
2824           {
2825             /* HImode and HFmode must be offsettable.  */
2826             if (mode == HImode || mode == HFmode)
2827               return IS_ADDR_OR_PSEUDO_REG (op0)
2828                 && GET_CODE (op1) == CONST_INT 
2829                 && IS_DISP1_OFF_CONST (INTVAL (op1));
2830
2831             if (REG_P (op1))
2832               return (IS_INDEX_OR_PSEUDO_REG (op1)
2833                       && IS_ADDR_OR_PSEUDO_REG (op0))
2834                 || (IS_ADDR_OR_PSEUDO_REG (op1)
2835                     && IS_INDEX_OR_PSEUDO_REG (op0));
2836             
2837             return IS_ADDR_OR_PSEUDO_REG (op0)
2838               && GET_CODE (op1) == CONST_INT 
2839               && IS_DISP1_CONST (INTVAL (op1));
2840           }
2841       }
2842       break;
2843
2844     default:
2845       break;
2846     }
2847   return 0;
2848 }
2849
2850
2851 /* Direct memory operand.  */
2852
2853 int
2854 c4x_T_constraint (rtx op)
2855 {
2856   if (GET_CODE (op) != MEM)
2857     return 0;
2858   op = XEXP (op, 0);
2859
2860   if (GET_CODE (op) != LO_SUM)
2861     {
2862       /* Allow call operands.  */
2863       return GET_CODE (op) == SYMBOL_REF
2864         && GET_MODE (op) == Pmode
2865         && SYMBOL_REF_FUNCTION_P (op);
2866     }
2867
2868   /* HImode and HFmode are not offsettable.  */
2869   if (GET_MODE (op) == HImode || GET_CODE (op) == HFmode)
2870     return 0;
2871
2872   if ((GET_CODE (XEXP (op, 0)) == REG)
2873       && (REGNO (XEXP (op, 0)) == DP_REGNO))
2874     return c4x_U_constraint (XEXP (op, 1));
2875   
2876   return 0;
2877 }
2878
2879
2880 /* Symbolic operand.  */
2881
2882 int
2883 c4x_U_constraint (rtx op)
2884 {
2885   /* Don't allow direct addressing to an arbitrary constant.  */
2886   return GET_CODE (op) == CONST
2887          || GET_CODE (op) == SYMBOL_REF
2888          || GET_CODE (op) == LABEL_REF;
2889 }
2890
2891
2892 int
2893 c4x_autoinc_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2894 {
2895   if (GET_CODE (op) == MEM)
2896     {
2897       enum rtx_code code = GET_CODE (XEXP (op, 0));
2898       
2899       if (code == PRE_INC
2900           || code == PRE_DEC
2901           || code == POST_INC
2902           || code == POST_DEC
2903           || code == PRE_MODIFY
2904           || code == POST_MODIFY
2905           )
2906         return 1;
2907     }
2908   return 0;
2909 }
2910
2911
2912 /* Match any operand.  */
2913
2914 int
2915 any_operand (register rtx op ATTRIBUTE_UNUSED,
2916              enum machine_mode mode ATTRIBUTE_UNUSED)
2917 {
2918   return 1;
2919 }
2920
2921
2922 /* Nonzero if OP is a floating point value with value 0.0.  */
2923
2924 int
2925 fp_zero_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2926 {
2927   REAL_VALUE_TYPE r;
2928
2929   if (GET_CODE (op) != CONST_DOUBLE)
2930     return 0;
2931   REAL_VALUE_FROM_CONST_DOUBLE (r, op);
2932   return REAL_VALUES_EQUAL (r, dconst0);
2933 }
2934
2935
2936 int
2937 const_operand (register rtx op, register enum machine_mode mode)
2938 {
2939   switch (mode)
2940     {
2941     case QFmode:
2942     case HFmode:
2943       if (GET_CODE (op) != CONST_DOUBLE
2944           || GET_MODE (op) != mode
2945           || GET_MODE_CLASS (mode) != MODE_FLOAT)
2946         return 0;
2947
2948       return c4x_immed_float_p (op);
2949
2950 #if Pmode != QImode
2951     case Pmode:
2952 #endif
2953     case QImode:
2954       if (GET_CODE (op) != CONST_INT
2955           || (GET_MODE (op) != VOIDmode && GET_MODE (op) != mode)
2956           || GET_MODE_CLASS (mode) != MODE_INT)
2957         return 0;
2958
2959       return IS_HIGH_CONST (INTVAL (op)) || IS_INT16_CONST (INTVAL (op));
2960
2961     case HImode:
2962       return 0;
2963
2964     default:
2965       return 0;
2966     }
2967 }
2968
2969
2970 int
2971 stik_const_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2972 {
2973   return c4x_K_constant (op);
2974 }
2975
2976
2977 int
2978 not_const_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2979 {
2980   return c4x_N_constant (op);
2981 }
2982
2983
2984 int
2985 reg_operand (rtx op, enum machine_mode mode)
2986 {
2987   if (GET_CODE (op) == SUBREG
2988       && GET_MODE (op) == QFmode)
2989     return 0;
2990   return register_operand (op, mode);
2991 }
2992
2993
2994 int
2995 mixed_subreg_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2996 {
2997   /* Allow (subreg:HF (reg:HI)) that be generated for a union of an
2998      int and a long double.  */
2999   if (GET_CODE (op) == SUBREG
3000       && (GET_MODE (op) == QFmode)
3001       && (GET_MODE (SUBREG_REG (op)) == QImode
3002           || GET_MODE (SUBREG_REG (op)) == HImode))
3003     return 1;
3004   return 0;
3005 }
3006
3007
3008 int
3009 reg_imm_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
3010 {
3011   if (REG_P (op) || CONSTANT_P (op))
3012     return 1;
3013   return 0;
3014 }
3015
3016
3017 int
3018 not_modify_reg (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
3019 {
3020   if (REG_P (op) || CONSTANT_P (op))
3021     return 1;
3022   if (GET_CODE (op) != MEM)
3023     return 0;
3024   op = XEXP (op, 0);
3025   switch (GET_CODE (op))
3026     {
3027     case REG:
3028       return 1;
3029
3030     case PLUS:
3031       {
3032         rtx op0 = XEXP (op, 0);
3033         rtx op1 = XEXP (op, 1);
3034
3035         if (! REG_P (op0))
3036           return 0;
3037         
3038         if (REG_P (op1) || GET_CODE (op1) == CONST_INT)
3039           return 1;
3040       }
3041
3042     case LO_SUM:
3043       {
3044         rtx op0 = XEXP (op, 0);
3045           
3046         if (REG_P (op0) && REGNO (op0) == DP_REGNO)
3047           return 1;
3048       }
3049       break;
3050      
3051     case CONST:
3052     case SYMBOL_REF:
3053     case LABEL_REF:
3054       return 1;
3055
3056     default:
3057       break;
3058     }
3059   return 0;
3060 }
3061
3062
3063 int
3064 not_rc_reg (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
3065 {
3066   if (REG_P (op) && REGNO (op) == RC_REGNO)
3067     return 0;
3068   return 1;
3069 }
3070
3071
3072 /* Extended precision register R0-R1.  */
3073
3074 int
3075 r0r1_reg_operand (rtx op, enum machine_mode mode)
3076 {
3077   if (! reg_operand (op, mode))
3078     return 0;
3079   if (GET_CODE (op) == SUBREG)
3080     op = SUBREG_REG (op);
3081   return REG_P (op) && IS_R0R1_OR_PSEUDO_REG (op);
3082 }
3083
3084
3085 /* Extended precision register R2-R3.  */
3086
3087 int
3088 r2r3_reg_operand (rtx op, enum machine_mode mode)
3089 {
3090   if (! reg_operand (op, mode))
3091     return 0;
3092   if (GET_CODE (op) == SUBREG)
3093     op = SUBREG_REG (op);
3094   return REG_P (op) && IS_R2R3_OR_PSEUDO_REG (op);
3095 }
3096
3097
3098 /* Low extended precision register R0-R7.  */
3099
3100 int
3101 ext_low_reg_operand (rtx op, enum machine_mode mode)
3102 {
3103   if (! reg_operand (op, mode))
3104     return 0;
3105   if (GET_CODE (op) == SUBREG)
3106     op = SUBREG_REG (op);
3107   return REG_P (op) && IS_EXT_LOW_OR_PSEUDO_REG (op);
3108 }
3109
3110
3111 /* Extended precision register.  */
3112
3113 int
3114 ext_reg_operand (rtx op, enum machine_mode mode)
3115 {
3116   if (! reg_operand (op, mode))
3117     return 0;
3118   if (GET_CODE (op) == SUBREG)
3119     op = SUBREG_REG (op);
3120   if (! REG_P (op))
3121     return 0;
3122   return IS_EXT_OR_PSEUDO_REG (op);
3123 }
3124
3125
3126 /* Standard precision register.  */
3127
3128 int
3129 std_reg_operand (rtx op, enum machine_mode mode)
3130 {
3131   if (! reg_operand (op, mode))
3132     return 0;
3133   if (GET_CODE (op) == SUBREG)
3134     op = SUBREG_REG (op);
3135   return REG_P (op) && IS_STD_OR_PSEUDO_REG (op);
3136 }
3137
3138 /* Standard precision or normal register.  */
3139
3140 int
3141 std_or_reg_operand (rtx op, enum machine_mode mode)
3142 {
3143   if (reload_in_progress)
3144     return std_reg_operand (op, mode);
3145   return reg_operand (op, mode);
3146 }
3147
3148 /* Address register.  */
3149
3150 int
3151 addr_reg_operand (rtx op, enum machine_mode mode)
3152 {
3153   if (! reg_operand (op, mode))
3154     return 0;
3155   return c4x_a_register (op);
3156 }
3157
3158
3159 /* Index register.  */
3160
3161 int
3162 index_reg_operand (rtx op, enum machine_mode mode)
3163 {
3164   if (! reg_operand (op, mode))
3165     return 0;
3166   if (GET_CODE (op) == SUBREG)
3167     op = SUBREG_REG (op);
3168   return c4x_x_register (op);
3169 }
3170
3171
3172 /* DP register.  */
3173
3174 int
3175 dp_reg_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
3176 {
3177   return REG_P (op) && IS_DP_OR_PSEUDO_REG (op);
3178 }
3179
3180
3181 /* SP register.  */
3182
3183 int
3184 sp_reg_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
3185 {
3186   return REG_P (op) && IS_SP_OR_PSEUDO_REG (op);
3187 }
3188
3189
3190 /* ST register.  */
3191
3192 int
3193 st_reg_operand (register rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
3194 {
3195   return REG_P (op) && IS_ST_OR_PSEUDO_REG (op);
3196 }
3197
3198
3199 /* RC register.  */
3200
3201 int
3202 rc_reg_operand (register rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
3203 {
3204   return REG_P (op) && IS_RC_OR_PSEUDO_REG (op);
3205 }
3206
3207
3208 int
3209 call_address_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
3210 {
3211   return (REG_P (op) || symbolic_address_operand (op, mode));
3212 }
3213
3214
3215 /* Symbolic address operand.  */
3216
3217 int
3218 symbolic_address_operand (register rtx op,
3219                           enum machine_mode mode ATTRIBUTE_UNUSED)
3220 {
3221   switch (GET_CODE (op))
3222     {
3223     case CONST:
3224     case SYMBOL_REF:
3225     case LABEL_REF:
3226       return 1;
3227     default:
3228       return 0;
3229     }
3230 }
3231
3232
3233 /* Check dst operand of a move instruction.  */
3234
3235 int
3236 dst_operand (rtx op, enum machine_mode mode)
3237 {
3238   if (GET_CODE (op) == SUBREG
3239       && mixed_subreg_operand (op, mode))
3240     return 0;
3241
3242   if (REG_P (op))
3243     return reg_operand (op, mode);
3244
3245   return nonimmediate_operand (op, mode);
3246 }
3247
3248
3249 /* Check src operand of two operand arithmetic instructions.  */
3250
3251 int
3252 src_operand (rtx op, enum machine_mode mode)
3253 {
3254   if (GET_CODE (op) == SUBREG
3255       && mixed_subreg_operand (op, mode))
3256     return 0;
3257
3258   if (REG_P (op))
3259     return reg_operand (op, mode);
3260
3261   if (mode == VOIDmode)
3262     mode = GET_MODE (op);
3263
3264   if (GET_CODE (op) == CONST_INT)
3265     return (mode == QImode || mode == Pmode || mode == HImode)
3266       && c4x_I_constant (op);
3267
3268   /* We don't like CONST_DOUBLE integers.  */
3269   if (GET_CODE (op) == CONST_DOUBLE)
3270     return c4x_H_constant (op);
3271
3272   /* Disallow symbolic addresses.  Only the predicate
3273      symbolic_address_operand will match these.  */
3274   if (GET_CODE (op) == SYMBOL_REF
3275       || GET_CODE (op) == LABEL_REF
3276       || GET_CODE (op) == CONST)
3277     return 0;
3278
3279   /* If TARGET_LOAD_DIRECT_MEMS is nonzero, disallow direct memory
3280      access to symbolic addresses.  These operands will get forced
3281      into a register and the movqi expander will generate a
3282      HIGH/LO_SUM pair if TARGET_EXPOSE_LDP is nonzero.  */
3283   if (GET_CODE (op) == MEM
3284       && ((GET_CODE (XEXP (op, 0)) == SYMBOL_REF
3285            || GET_CODE (XEXP (op, 0)) == LABEL_REF
3286            || GET_CODE (XEXP (op, 0)) == CONST)))
3287     return !TARGET_EXPOSE_LDP && 
3288       ! TARGET_LOAD_DIRECT_MEMS && GET_MODE (op) == mode;
3289
3290   return general_operand (op, mode);
3291 }
3292
3293
3294 int
3295 src_hi_operand (rtx op, enum machine_mode mode)
3296 {
3297   if (c4x_O_constant (op))
3298     return 1;
3299   return src_operand (op, mode);
3300 }
3301
3302
3303 /* Check src operand of two operand logical instructions.  */
3304
3305 int
3306 lsrc_operand (rtx op, enum machine_mode mode)
3307 {
3308   if (mode == VOIDmode)
3309     mode = GET_MODE (op);
3310
3311   if (mode != QImode && mode != Pmode)
3312     fatal_insn ("mode not QImode", op);
3313
3314   if (GET_CODE (op) == CONST_INT)
3315     return c4x_L_constant (op) || c4x_J_constant (op);
3316
3317   return src_operand (op, mode);
3318 }
3319
3320
3321 /* Check src operand of two operand tricky instructions.  */
3322
3323 int
3324 tsrc_operand (rtx op, enum machine_mode mode)
3325 {
3326   if (mode == VOIDmode)
3327     mode = GET_MODE (op);
3328
3329   if (mode != QImode && mode != Pmode)
3330     fatal_insn ("mode not QImode", op);
3331
3332   if (GET_CODE (op) == CONST_INT)
3333     return c4x_L_constant (op) || c4x_N_constant (op) || c4x_J_constant (op);
3334
3335   return src_operand (op, mode);
3336 }
3337
3338
3339 /* Check src operand of two operand non immedidate instructions.  */
3340
3341 int
3342 nonimmediate_src_operand (rtx op, enum machine_mode mode)
3343 {
3344   if (GET_CODE (op) == CONST_INT || GET_CODE (op) == CONST_DOUBLE)
3345     return 0;
3346
3347   return src_operand (op, mode);
3348 }
3349
3350
3351 /* Check logical src operand of two operand non immedidate instructions.  */
3352
3353 int
3354 nonimmediate_lsrc_operand (rtx op, enum machine_mode mode)
3355 {
3356   if (GET_CODE (op) == CONST_INT || GET_CODE (op) == CONST_DOUBLE)
3357     return 0;
3358
3359   return lsrc_operand (op, mode);
3360 }
3361
3362
3363 int
3364 reg_or_const_operand (rtx op, enum machine_mode mode)
3365 {
3366   return reg_operand (op, mode) || const_operand (op, mode);
3367 }
3368
3369
3370 /* Check for indirect operands allowable in parallel instruction.  */
3371
3372 int
3373 par_ind_operand (rtx op, enum machine_mode mode)
3374 {
3375   if (mode != VOIDmode && mode != GET_MODE (op))
3376     return 0;
3377
3378   return c4x_S_indirect (op);
3379 }
3380
3381
3382 /* Check for operands allowable in parallel instruction.  */
3383
3384 int
3385 parallel_operand (rtx op, enum machine_mode mode)
3386 {
3387   return ext_low_reg_operand (op, mode) || par_ind_operand (op, mode);
3388 }
3389
3390
3391 static void 
3392 c4x_S_address_parse (rtx op, int *base, int *incdec, int *index, int *disp)
3393 {
3394   *base = 0;
3395   *incdec = 0;
3396   *index = 0;
3397   *disp = 0;
3398        
3399   if (GET_CODE (op) != MEM)
3400     fatal_insn ("invalid indirect memory address", op);
3401   
3402   op = XEXP (op, 0);
3403   switch (GET_CODE (op))
3404     {
3405     case PRE_DEC:
3406       *base = REGNO (XEXP (op, 0));
3407       *incdec = 1;
3408       *disp = -1;
3409       return;
3410
3411     case POST_DEC:
3412       *base = REGNO (XEXP (op, 0));
3413       *incdec = 1;
3414       *disp = 0;
3415       return;
3416
3417     case PRE_INC:
3418       *base = REGNO (XEXP (op, 0));
3419       *incdec = 1;
3420       *disp = 1;
3421       return;
3422
3423     case POST_INC:
3424       *base = REGNO (XEXP (op, 0));
3425       *incdec = 1;
3426       *disp = 0;
3427       return;
3428
3429     case POST_MODIFY:
3430       *base = REGNO (XEXP (op, 0));
3431       if (REG_P (XEXP (XEXP (op, 1), 1)))
3432         {
3433           *index = REGNO (XEXP (XEXP (op, 1), 1));
3434           *disp = 0;            /* ??? */
3435         }
3436       else
3437           *disp = INTVAL (XEXP (XEXP (op, 1), 1));
3438       *incdec = 1;
3439       return;
3440
3441     case PRE_MODIFY:
3442       *base = REGNO (XEXP (op, 0));
3443       if (REG_P (XEXP (XEXP (op, 1), 1)))
3444         {
3445           *index = REGNO (XEXP (XEXP (op, 1), 1));
3446           *disp = 1;            /* ??? */
3447         }
3448       else
3449           *disp = INTVAL (XEXP (XEXP (op, 1), 1));
3450       *incdec = 1;
3451
3452       return;
3453
3454     case REG:
3455       *base = REGNO (op);
3456       return;
3457
3458     case PLUS:
3459       {
3460         rtx op0 = XEXP (op, 0);
3461         rtx op1 = XEXP (op, 1);
3462
3463         if (c4x_a_register (op0))
3464           {
3465             if (c4x_x_register (op1))
3466               {
3467                 *base = REGNO (op0);
3468                 *index = REGNO (op1);
3469                 return;
3470               }
3471             else if ((GET_CODE (op1) == CONST_INT 
3472                       && IS_DISP1_CONST (INTVAL (op1))))
3473               {
3474                 *base = REGNO (op0);
3475                 *disp = INTVAL (op1);
3476                 return;
3477               }
3478           }
3479         else if (c4x_x_register (op0) && c4x_a_register (op1))
3480           {
3481             *base = REGNO (op1);
3482             *index = REGNO (op0);
3483             return;
3484           }
3485       }
3486       /* Fall through.  */
3487
3488     default:
3489       fatal_insn ("invalid indirect (S) memory address", op);
3490     }
3491 }
3492
3493
3494 int
3495 c4x_address_conflict (rtx op0, rtx op1, int store0, int store1)
3496 {
3497   int base0;
3498   int base1;
3499   int incdec0;
3500   int incdec1;
3501   int index0;
3502   int index1;
3503   int disp0;
3504   int disp1;
3505   
3506   if (MEM_VOLATILE_P (op0) && MEM_VOLATILE_P (op1))
3507     return 1;
3508
3509   c4x_S_address_parse (op0, &base0, &incdec0, &index0, &disp0);
3510   c4x_S_address_parse (op1, &base1, &incdec1, &index1, &disp1);
3511
3512   if (store0 && store1)
3513     {
3514       /* If we have two stores in parallel to the same address, then
3515          the C4x only executes one of the stores.  This is unlikely to
3516          cause problems except when writing to a hardware device such
3517          as a FIFO since the second write will be lost.  The user
3518          should flag the hardware location as being volatile so that
3519          we don't do this optimization.  While it is unlikely that we
3520          have an aliased address if both locations are not marked
3521          volatile, it is probably safer to flag a potential conflict
3522          if either location is volatile.  */
3523       if (! flag_argument_noalias)
3524         {
3525           if (MEM_VOLATILE_P (op0) || MEM_VOLATILE_P (op1))
3526             return 1;
3527         }
3528     }
3529
3530   /* If have a parallel load and a store to the same address, the load
3531      is performed first, so there is no conflict.  Similarly, there is
3532      no conflict if have parallel loads from the same address.  */
3533
3534   /* Cannot use auto increment or auto decrement twice for same
3535      base register.  */
3536   if (base0 == base1 && incdec0 && incdec0)
3537     return 1;
3538
3539   /* It might be too confusing for GCC if we have use a base register
3540      with a side effect and a memory reference using the same register
3541      in parallel.  */
3542   if (! TARGET_DEVEL && base0 == base1 && (incdec0 || incdec1))
3543     return 1;
3544
3545   /* We can not optimize the case where op1 and op2 refer to the same
3546      address.  */
3547   if (base0 == base1 && disp0 == disp1 && index0 == index1)
3548     return 1;
3549
3550   /* No conflict.  */
3551   return 0;
3552 }
3553
3554
3555 /* Check for while loop inside a decrement and branch loop.  */
3556
3557 int
3558 c4x_label_conflict (rtx insn, rtx jump, rtx db)
3559 {
3560   while (insn)
3561     {
3562       if (GET_CODE (insn) == CODE_LABEL)
3563         {
3564           if (CODE_LABEL_NUMBER (jump) == CODE_LABEL_NUMBER (insn))
3565             return 1;
3566           if (CODE_LABEL_NUMBER (db) == CODE_LABEL_NUMBER (insn))
3567             return 0;
3568         }
3569       insn = PREV_INSN (insn);
3570     }
3571   return 1;
3572 }
3573
3574
3575 /* Validate combination of operands for parallel load/store instructions.  */
3576
3577 int
3578 valid_parallel_load_store (rtx *operands,
3579                            enum machine_mode mode ATTRIBUTE_UNUSED)
3580 {
3581   rtx op0 = operands[0];
3582   rtx op1 = operands[1];
3583   rtx op2 = operands[2];
3584   rtx op3 = operands[3];
3585
3586   if (GET_CODE (op0) == SUBREG)
3587     op0 = SUBREG_REG (op0);
3588   if (GET_CODE (op1) == SUBREG)
3589     op1 = SUBREG_REG (op1);
3590   if (GET_CODE (op2) == SUBREG)
3591     op2 = SUBREG_REG (op2);
3592   if (GET_CODE (op3) == SUBREG)
3593     op3 = SUBREG_REG (op3);
3594
3595   /* The patterns should only allow ext_low_reg_operand() or
3596      par_ind_operand() operands.  Thus of the 4 operands, only 2
3597      should be REGs and the other 2 should be MEMs.  */
3598
3599   /* This test prevents the multipack pass from using this pattern if
3600      op0 is used as an index or base register in op2 or op3, since
3601      this combination will require reloading.  */
3602   if (GET_CODE (op0) == REG
3603       && ((GET_CODE (op2) == MEM && reg_mentioned_p (op0, XEXP (op2, 0)))
3604           || (GET_CODE (op3) == MEM && reg_mentioned_p (op0, XEXP (op3, 0)))))
3605     return 0;
3606
3607   /* LDI||LDI.  */
3608   if (GET_CODE (op0) == REG && GET_CODE (op2) == REG)
3609     return (REGNO (op0) != REGNO (op2))
3610       && GET_CODE (op1) == MEM && GET_CODE (op3) == MEM
3611       && ! c4x_address_conflict (op1, op3, 0, 0);
3612
3613   /* STI||STI.  */
3614   if (GET_CODE (op1) == REG && GET_CODE (op3) == REG)
3615     return GET_CODE (op0) == MEM && GET_CODE (op2) == MEM
3616       && ! c4x_address_conflict (op0, op2, 1, 1);
3617
3618   /* LDI||STI.  */
3619   if (GET_CODE (op0) == REG && GET_CODE (op3) == REG)
3620     return GET_CODE (op1) == MEM && GET_CODE (op2) == MEM
3621       && ! c4x_address_conflict (op1, op2, 0, 1);
3622
3623   /* STI||LDI.  */
3624   if (GET_CODE (op1) == REG && GET_CODE (op2) == REG)
3625     return GET_CODE (op0) == MEM && GET_CODE (op3) == MEM
3626       && ! c4x_address_conflict (op0, op3, 1, 0);
3627
3628   return 0;
3629 }
3630
3631
3632 int
3633 valid_parallel_operands_4 (rtx *operands,
3634                            enum machine_mode mode ATTRIBUTE_UNUSED)
3635 {
3636   rtx op0 = operands[0];
3637   rtx op2 = operands[2];
3638
3639   if (GET_CODE (op0) == SUBREG)
3640     op0 = SUBREG_REG (op0);
3641   if (GET_CODE (op2) == SUBREG)
3642     op2 = SUBREG_REG (op2);
3643
3644   /* This test prevents the multipack pass from using this pattern if
3645      op0 is used as an index or base register in op2, since this combination
3646      will require reloading.  */
3647   if (GET_CODE (op0) == REG
3648       && GET_CODE (op2) == MEM
3649       && reg_mentioned_p (op0, XEXP (op2, 0)))
3650     return 0;
3651
3652   return 1;
3653 }
3654
3655
3656 int
3657 valid_parallel_operands_5 (rtx *operands,
3658                            enum machine_mode mode ATTRIBUTE_UNUSED)
3659 {
3660   int regs = 0;
3661   rtx op0 = operands[0];
3662   rtx op1 = operands[1];
3663   rtx op2 = operands[2];
3664   rtx op3 = operands[3];
3665
3666   if (GET_CODE (op0) == SUBREG)
3667     op0 = SUBREG_REG (op0);
3668   if (GET_CODE (op1) == SUBREG)
3669     op1 = SUBREG_REG (op1);
3670   if (GET_CODE (op2) == SUBREG)
3671     op2 = SUBREG_REG (op2);
3672
3673   /* The patterns should only allow ext_low_reg_operand() or
3674      par_ind_operand() operands.  Operands 1 and 2 may be commutative
3675      but only one of them can be a register.  */
3676   if (GET_CODE (op1) == REG)
3677     regs++;
3678   if (GET_CODE (op2) == REG)
3679     regs++;
3680
3681   if (regs != 1)
3682     return 0;
3683
3684   /* This test prevents the multipack pass from using this pattern if
3685      op0 is used as an index or base register in op3, since this combination
3686      will require reloading.  */
3687   if (GET_CODE (op0) == REG
3688       && GET_CODE (op3) == MEM
3689       && reg_mentioned_p (op0, XEXP (op3, 0)))
3690     return 0;
3691
3692   return 1;
3693 }
3694
3695
3696 int
3697 valid_parallel_operands_6 (rtx *operands,
3698                            enum machine_mode mode ATTRIBUTE_UNUSED)
3699 {
3700   int regs = 0;
3701   rtx op0 = operands[0];
3702   rtx op1 = operands[1];
3703   rtx op2 = operands[2];
3704   rtx op4 = operands[4];
3705   rtx op5 = operands[5];
3706
3707   if (GET_CODE (op1) == SUBREG)
3708     op1 = SUBREG_REG (op1);
3709   if (GET_CODE (op2) == SUBREG)
3710     op2 = SUBREG_REG (op2);
3711   if (GET_CODE (op4) == SUBREG)
3712     op4 = SUBREG_REG (op4);
3713   if (GET_CODE (op5) == SUBREG)
3714     op5 = SUBREG_REG (op5);
3715
3716   /* The patterns should only allow ext_low_reg_operand() or
3717      par_ind_operand() operands.  Thus of the 4 input operands, only 2
3718      should be REGs and the other 2 should be MEMs.  */
3719
3720   if (GET_CODE (op1) == REG)
3721     regs++;
3722   if (GET_CODE (op2) == REG)
3723     regs++;
3724   if (GET_CODE (op4) == REG)
3725     regs++;
3726   if (GET_CODE (op5) == REG)
3727     regs++;
3728
3729   /* The new C30/C40 silicon dies allow 3 regs of the 4 input operands. 
3730      Perhaps we should count the MEMs as well?  */
3731   if (regs != 2)
3732     return 0;
3733
3734   /* This test prevents the multipack pass from using this pattern if
3735      op0 is used as an index or base register in op4 or op5, since
3736      this combination will require reloading.  */
3737   if (GET_CODE (op0) == REG
3738       && ((GET_CODE (op4) == MEM && reg_mentioned_p (op0, XEXP (op4, 0)))
3739           || (GET_CODE (op5) == MEM && reg_mentioned_p (op0, XEXP (op5, 0)))))
3740     return 0;
3741
3742   return 1;
3743 }
3744
3745
3746 /* Validate combination of src operands.  Note that the operands have
3747    been screened by the src_operand predicate.  We just have to check
3748    that the combination of operands is valid.  If FORCE is set, ensure
3749    that the destination regno is valid if we have a 2 operand insn.  */
3750
3751 static int
3752 c4x_valid_operands (enum rtx_code code, rtx *operands,
3753                     enum machine_mode mode ATTRIBUTE_UNUSED,
3754                     int force)
3755 {
3756   rtx op0;
3757   rtx op1;
3758   rtx op2;
3759   enum rtx_code code1;
3760   enum rtx_code code2;
3761
3762
3763   /* FIXME, why can't we tighten the operands for IF_THEN_ELSE?  */
3764   if (code == IF_THEN_ELSE)
3765       return 1 || (operands[0] == operands[2] || operands[0] == operands[3]);
3766
3767   if (code == COMPARE)
3768     {
3769       op1 = operands[0];
3770       op2 = operands[1];
3771     }
3772   else
3773     {
3774       op1 = operands[1];
3775       op2 = operands[2];
3776     }
3777
3778   op0 = operands[0];
3779
3780   if (GET_CODE (op0) == SUBREG)
3781     op0 = SUBREG_REG (op0);
3782   if (GET_CODE (op1) == SUBREG)
3783     op1 = SUBREG_REG (op1);
3784   if (GET_CODE (op2) == SUBREG)
3785     op2 = SUBREG_REG (op2);
3786
3787   code1 = GET_CODE (op1);
3788   code2 = GET_CODE (op2);
3789
3790   
3791   if (code1 == REG && code2 == REG)
3792     return 1;
3793
3794   if (code1 == MEM && code2 == MEM)
3795     {
3796       if (c4x_S_indirect (op1) && c4x_S_indirect (op2))
3797         return 1;
3798       return c4x_R_indirect (op1) && c4x_R_indirect (op2);
3799     }
3800
3801   /* We cannot handle two MEMs or two CONSTS, etc.  */
3802   if (code1 == code2)
3803     return 0;
3804
3805   if (code1 == REG)
3806     {
3807       switch (code2)
3808         {
3809         case CONST_INT:
3810           if (c4x_J_constant (op2) && c4x_R_indirect (op1))
3811             return 1;
3812           break;
3813           
3814         case CONST_DOUBLE:
3815           if (! c4x_H_constant (op2))
3816             return 0;
3817           break;
3818
3819           /* Any valid memory operand screened by src_operand is OK.  */
3820         case MEM:
3821           break;
3822           
3823         default:
3824           fatal_insn ("c4x_valid_operands: Internal error", op2);
3825           break;
3826         }
3827       
3828       if (GET_CODE (op0) == SCRATCH)
3829           return 1;
3830
3831       if (!REG_P (op0))
3832           return 0;
3833
3834       /* Check that we have a valid destination register for a two operand
3835          instruction.  */
3836       return ! force || code == COMPARE || REGNO (op1) == REGNO (op0);
3837     }
3838
3839
3840   /* Check non-commutative operators.  */
3841   if (code == ASHIFTRT || code == LSHIFTRT
3842       || code == ASHIFT || code == COMPARE)
3843     return code2 == REG
3844       && (c4x_S_indirect (op1) || c4x_R_indirect (op1));
3845
3846
3847   /* Assume MINUS is commutative since the subtract patterns
3848      also support the reverse subtract instructions.  Since op1
3849      is not a register, and op2 is a register, op1 can only
3850      be a restricted memory operand for a shift instruction.  */
3851   if (code2 == REG)
3852     {
3853       switch (code1)
3854         {
3855         case CONST_INT:
3856           break;
3857       
3858         case CONST_DOUBLE:
3859           if (! c4x_H_constant (op1))
3860             return 0;
3861           break;
3862
3863           /* Any valid memory operand screened by src_operand is OK.  */      
3864         case MEM:
3865           break;
3866           
3867         default:
3868           abort ();
3869           break;
3870         }
3871
3872       if (GET_CODE (op0) == SCRATCH)
3873           return 1;
3874
3875       if (!REG_P (op0))
3876           return 0;
3877
3878       /* Check that we have a valid destination register for a two operand
3879          instruction.  */
3880       return ! force || REGNO (op1) == REGNO (op0);
3881     }
3882       
3883   if (c4x_J_constant (op1) && c4x_R_indirect (op2))
3884     return 1;
3885
3886   return 0;
3887 }
3888
3889
3890 int valid_operands (enum rtx_code code, rtx *operands, enum machine_mode mode)
3891 {
3892
3893   /* If we are not optimizing then we have to let anything go and let
3894      reload fix things up.  instantiate_decl in function.c can produce
3895      invalid insns by changing the offset of a memory operand from a
3896      valid one into an invalid one, when the second operand is also a
3897      memory operand.  The alternative is not to allow two memory
3898      operands for an insn when not optimizing.  The problem only rarely
3899      occurs, for example with the C-torture program DFcmp.c.  */
3900
3901   return ! optimize || c4x_valid_operands (code, operands, mode, 0);
3902 }
3903
3904
3905 int
3906 legitimize_operands (enum rtx_code code, rtx *operands, enum machine_mode mode)
3907 {
3908   /* Compare only has 2 operands.  */
3909   if (code == COMPARE)
3910     {
3911       /* During RTL generation, force constants into pseudos so that
3912          they can get hoisted out of loops.  This will tie up an extra
3913          register but can save an extra cycle.  Only do this if loop
3914          optimization enabled.  (We cannot pull this trick for add and
3915          sub instructions since the flow pass won't find
3916          autoincrements etc.)  This allows us to generate compare
3917          instructions like CMPI R0, *AR0++ where R0 = 42, say, instead
3918          of LDI *AR0++, R0; CMPI 42, R0. 
3919
3920          Note that expand_binops will try to load an expensive constant
3921          into a register if it is used within a loop.  Unfortunately,
3922          the cost mechanism doesn't allow us to look at the other
3923          operand to decide whether the constant is expensive.  */
3924       
3925       if (! reload_in_progress
3926           && TARGET_HOIST
3927           && optimize > 0
3928           && GET_CODE (operands[1]) == CONST_INT 
3929           && preserve_subexpressions_p ()
3930           && rtx_cost (operands[1], code) > 1)
3931         operands[1] = force_reg (mode, operands[1]);
3932       
3933       if (! reload_in_progress
3934           && ! c4x_valid_operands (code, operands, mode, 0))
3935         operands[0] = force_reg (mode, operands[0]);
3936       return 1;
3937     }
3938   
3939   /* We cannot do this for ADDI/SUBI insns since we will
3940      defeat the flow pass from finding autoincrement addressing
3941      opportunities.  */
3942   if (! reload_in_progress
3943       && ! ((code == PLUS || code == MINUS) && mode == Pmode)
3944       && TARGET_HOIST
3945       && optimize > 1
3946       && GET_CODE (operands[2]) == CONST_INT
3947       && preserve_subexpressions_p ()
3948       && rtx_cost (operands[2], code) > 1)
3949     operands[2] = force_reg (mode, operands[2]);
3950
3951   /* We can get better code on a C30 if we force constant shift counts
3952      into a register.  This way they can get hoisted out of loops,
3953      tying up a register but saving an instruction.  The downside is
3954      that they may get allocated to an address or index register, and
3955      thus we will get a pipeline conflict if there is a nearby
3956      indirect address using an address register. 
3957
3958      Note that expand_binops will not try to load an expensive constant
3959      into a register if it is used within a loop for a shift insn.  */
3960   
3961   if (! reload_in_progress
3962       && ! c4x_valid_operands (code, operands, mode, TARGET_FORCE))
3963     {
3964       /* If the operand combination is invalid, we force operand1 into a
3965          register, preventing reload from having doing to do this at a
3966          later stage.  */
3967       operands[1] = force_reg (mode, operands[1]);
3968       if (TARGET_FORCE)
3969         {
3970           emit_move_insn (operands[0], operands[1]);
3971           operands[1] = copy_rtx (operands[0]);
3972         }
3973       else
3974         {
3975           /* Just in case...  */
3976           if (! c4x_valid_operands (code, operands, mode, 0))
3977             operands[2] = force_reg (mode, operands[2]);
3978         }
3979     }
3980
3981   /* Right shifts require a negative shift count, but GCC expects
3982      a positive count, so we emit a NEG.  */
3983   if ((code == ASHIFTRT || code == LSHIFTRT)
3984       && (GET_CODE (operands[2]) != CONST_INT))
3985     operands[2] = gen_rtx_NEG (mode, negate_rtx (mode, operands[2]));
3986   
3987
3988   /* When the shift count is greater than 32 then the result 
3989      can be implementation dependent.  We truncate the result to
3990      fit in 5 bits so that we do not emit invalid code when
3991      optimizing---such as trying to generate lhu2 with 20021124-1.c.  */
3992   if (((code == ASHIFTRT || code == LSHIFTRT || code == ASHIFT)
3993       && (GET_CODE (operands[2]) == CONST_INT))
3994       && INTVAL (operands[2]) > (GET_MODE_BITSIZE (mode) - 1))
3995       operands[2]
3996           = GEN_INT (INTVAL (operands[2]) & (GET_MODE_BITSIZE (mode) - 1));
3997
3998   return 1;
3999 }
4000
4001
4002 /* The following predicates are used for instruction scheduling.  */
4003
4004 int
4005 group1_reg_operand (rtx op, enum machine_mode mode)
4006 {
4007   if (mode != VOIDmode && mode != GET_MODE (op))
4008     return 0;
4009   if (GET_CODE (op) == SUBREG)
4010     op = SUBREG_REG (op);
4011   return REG_P (op) && (! reload_completed || IS_GROUP1_REG (op));
4012 }
4013
4014
4015 int
4016 group1_mem_operand (rtx op, enum machine_mode mode)
4017 {
4018   if (mode != VOIDmode && mode != GET_MODE (op))
4019     return 0;
4020
4021   if (GET_CODE (op) == MEM)
4022     {
4023       op = XEXP (op, 0);
4024       if (GET_CODE (op) == PLUS)
4025         {
4026           rtx op0 = XEXP (op, 0);
4027           rtx op1 = XEXP (op, 1);
4028
4029           if ((REG_P (op0) && (! reload_completed || IS_GROUP1_REG (op0)))
4030               || (REG_P (op1) && (! reload_completed || IS_GROUP1_REG (op1))))
4031             return 1;
4032         }
4033       else if ((REG_P (op)) && (! reload_completed || IS_GROUP1_REG (op)))
4034         return 1;
4035     }
4036
4037   return 0;
4038 }
4039
4040
4041 /* Return true if any one of the address registers.  */
4042
4043 int
4044 arx_reg_operand (rtx op, enum machine_mode mode)
4045 {
4046   if (mode != VOIDmode && mode != GET_MODE (op))
4047     return 0;
4048   if (GET_CODE (op) == SUBREG)
4049     op = SUBREG_REG (op);
4050   return REG_P (op) && (! reload_completed || IS_ADDR_REG (op));
4051 }
4052
4053
4054 static int
4055 c4x_arn_reg_operand (rtx op, enum machine_mode mode, unsigned int regno)
4056 {
4057   if (mode != VOIDmode && mode != GET_MODE (op))
4058     return 0;
4059   if (GET_CODE (op) == SUBREG)
4060     op = SUBREG_REG (op);
4061   return REG_P (op) && (! reload_completed || (REGNO (op) == regno));
4062 }
4063
4064
4065 static int
4066 c4x_arn_mem_operand (rtx op, enum machine_mode mode, unsigned int regno)
4067 {
4068   if (mode != VOIDmode && mode != GET_MODE (op))
4069     return 0;
4070
4071   if (GET_CODE (op) == MEM)
4072     {
4073       op = XEXP (op, 0);
4074       switch (GET_CODE (op))
4075         {
4076         case PRE_DEC:
4077         case POST_DEC:
4078         case PRE_INC:
4079         case POST_INC:
4080           op = XEXP (op, 0);
4081
4082         case REG:
4083           return REG_P (op) && (! reload_completed || (REGNO (op) == regno));
4084
4085         case PRE_MODIFY:
4086         case POST_MODIFY:
4087           if (REG_P (XEXP (op, 0)) && (! reload_completed 
4088                                        || (REGNO (XEXP (op, 0)) == regno)))
4089             return 1;
4090           if (REG_P (XEXP (XEXP (op, 1), 1))
4091               && (! reload_completed
4092                   || (REGNO (XEXP (XEXP (op, 1), 1)) == regno)))
4093             return 1;
4094           break;
4095
4096         case PLUS:
4097           {
4098             rtx op0 = XEXP (op, 0);
4099             rtx op1 = XEXP (op, 1);
4100
4101             if ((REG_P (op0) && (! reload_completed
4102                                  || (REGNO (op0) == regno)))
4103                 || (REG_P (op1) && (! reload_completed
4104                                     || (REGNO (op1) == regno))))
4105               return 1;
4106           }
4107           break;
4108
4109         default:
4110           break;
4111         }
4112     }
4113   return 0;
4114 }
4115
4116
4117 int
4118 ar0_reg_operand (rtx op, enum machine_mode mode)
4119 {
4120   return c4x_arn_reg_operand (op, mode, AR0_REGNO);
4121 }
4122
4123
4124 int
4125 ar0_mem_operand (rtx op, enum machine_mode mode)
4126 {
4127   return c4x_arn_mem_operand (op, mode, AR0_REGNO);
4128 }
4129
4130
4131 int
4132 ar1_reg_operand (rtx op, enum machine_mode mode)
4133 {
4134   return c4x_arn_reg_operand (op, mode, AR1_REGNO);
4135 }
4136
4137
4138 int
4139 ar1_mem_operand (rtx op, enum machine_mode mode)
4140 {
4141   return c4x_arn_mem_operand (op, mode, AR1_REGNO);
4142 }
4143