OSDN Git Service

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