OSDN Git Service

Replace calls to abort in CRIS port.
[pf3gnuchains/gcc-fork.git] / gcc / config / cris / cris.c
1 /* Definitions for GCC.  Part of the machine description for CRIS.
2    Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
3    Free Software Foundation, Inc.
4    Contributed by Axis Communications.  Written by Hans-Peter Nilsson.
5
6 This file is part of GCC.
7
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
11 any later version.
12
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING.  If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA.  */
22
23 #include "config.h"
24 #include "system.h"
25 #include "coretypes.h"
26 #include "tm.h"
27 #include "rtl.h"
28 #include "regs.h"
29 #include "hard-reg-set.h"
30 #include "real.h"
31 #include "insn-config.h"
32 #include "conditions.h"
33 #include "insn-attr.h"
34 #include "flags.h"
35 #include "tree.h"
36 #include "expr.h"
37 #include "except.h"
38 #include "function.h"
39 #include "toplev.h"
40 #include "recog.h"
41 #include "tm_p.h"
42 #include "debug.h"
43 #include "output.h"
44 #include "target.h"
45 #include "target-def.h"
46 #include "ggc.h"
47 #include "optabs.h"
48
49 /* Usable when we have an amount to add or subtract, and want the
50    optimal size of the insn.  */
51 #define ADDITIVE_SIZE_MODIFIER(size) \
52  ((size) <= 63 ? "q" : (size) <= 255 ? "u.b" : (size) <= 65535 ? "u.w" : ".d")
53
54 #define ASSERT_PLT_UNSPEC(x)                                            \
55   CRIS_ASSERT (XINT (x, 1) == CRIS_UNSPEC_PLT                           \
56                && ((GET_CODE (XVECEXP (x, 0, 0)) == SYMBOL_REF)         \
57                    || GET_CODE (XVECEXP (x, 0, 0)) == LABEL_REF))
58
59 #define LOSE_AND_RETURN(msgid, x)                       \
60   do                                            \
61     {                                           \
62       cris_operand_lossage (msgid, x);          \
63       return;                                   \
64     } while (0)
65
66 enum cris_retinsn_type
67  { CRIS_RETINSN_UNKNOWN = 0, CRIS_RETINSN_RET, CRIS_RETINSN_JUMP };
68
69 /* Per-function machine data.  */
70 struct machine_function GTY(())
71  {
72    int needs_return_address_on_stack;
73
74    /* This is the number of registers we save in the prologue due to
75       stdarg.  */
76    int stdarg_regs;
77
78    enum cris_retinsn_type return_type;
79  };
80
81 /* This little fix suppresses the 'u' or 's' when '%e' in assembly
82    pattern.  */
83 static char cris_output_insn_is_bound = 0;
84
85 /* This one suppresses printing out the "rPIC+" in
86    "rPIC+sym:GOTOFF+offset" when doing PIC.  For a PLT symbol, it
87    suppresses outputting it as [rPIC+sym:GOTPLT] and outputs similarly
88    just the "sym:GOTOFF" part.  */
89 static int cris_pic_sympart_only = 0;
90
91 /* In code for output macros, this is how we know whether e.g. constant
92    goes in code or in a static initializer.  */
93 static int in_code = 0;
94
95 /* Fix for reg_overlap_mentioned_p.  */
96 static int cris_reg_overlap_mentioned_p (rtx, rtx);
97
98 static void cris_print_base (rtx, FILE *);
99
100 static void cris_print_index (rtx, FILE *);
101
102 static void cris_output_addr_const (FILE *, rtx);
103
104 static struct machine_function * cris_init_machine_status (void);
105
106 static rtx cris_struct_value_rtx (tree, int);
107
108 static void cris_setup_incoming_varargs (CUMULATIVE_ARGS *, enum machine_mode,
109                                          tree type, int *, int);
110
111 static int cris_initial_frame_pointer_offset (void);
112
113 static int saved_regs_mentioned (rtx);
114
115 static void cris_operand_lossage (const char *, rtx);
116
117 static int cris_reg_saved_in_regsave_area  (unsigned int, bool);
118
119 static void cris_asm_output_mi_thunk
120   (FILE *, tree, HOST_WIDE_INT, HOST_WIDE_INT, tree);
121
122 static void cris_file_start (void);
123 static void cris_init_libfuncs (void);
124
125 static bool cris_rtx_costs (rtx, int, int, int *);
126 static int cris_address_cost (rtx);
127 static bool cris_pass_by_reference (CUMULATIVE_ARGS *, enum machine_mode,
128                                     tree, bool);
129 static int cris_arg_partial_bytes (CUMULATIVE_ARGS *, enum machine_mode,
130                                    tree, bool);
131 static tree cris_md_asm_clobbers (tree, tree, tree);
132
133 static bool cris_handle_option (size_t, const char *, int);
134
135 /* This is the argument from the "-max-stack-stackframe=" option.  */
136 const char *cris_max_stackframe_str;
137
138 /* This is the argument from the "-march=" option.  */
139 const char *cris_cpu_str;
140
141 /* This is the argument from the "-mtune=" option.  */
142 const char *cris_tune_str;
143
144 /* This is the argument from the "-melinux-stacksize=" option.  */
145 const char *cris_elinux_stacksize_str;
146
147 /* This is the parsed result of the "-max-stack-stackframe=" option.  If
148    it (still) is zero, then there was no such option given.  */
149 int cris_max_stackframe = 0;
150
151 /* This is the parsed result of the "-march=" option, if given.  */
152 int cris_cpu_version = CRIS_DEFAULT_CPU_VERSION;
153
154 #undef TARGET_ASM_ALIGNED_HI_OP
155 #define TARGET_ASM_ALIGNED_HI_OP "\t.word\t"
156 #undef TARGET_ASM_ALIGNED_SI_OP
157 #define TARGET_ASM_ALIGNED_SI_OP "\t.dword\t"
158 #undef TARGET_ASM_ALIGNED_DI_OP
159 #define TARGET_ASM_ALIGNED_DI_OP "\t.quad\t"
160
161 /* We need to define these, since the 2byte, 4byte, 8byte op:s are only
162    available in ELF.  These "normal" pseudos do not have any alignment
163    constraints or side-effects.  */
164 #undef TARGET_ASM_UNALIGNED_HI_OP
165 #define TARGET_ASM_UNALIGNED_HI_OP TARGET_ASM_ALIGNED_HI_OP
166
167 #undef TARGET_ASM_UNALIGNED_SI_OP
168 #define TARGET_ASM_UNALIGNED_SI_OP TARGET_ASM_ALIGNED_SI_OP
169
170 #undef TARGET_ASM_UNALIGNED_DI_OP
171 #define TARGET_ASM_UNALIGNED_DI_OP TARGET_ASM_ALIGNED_DI_OP
172
173 #undef TARGET_ASM_OUTPUT_MI_THUNK
174 #define TARGET_ASM_OUTPUT_MI_THUNK cris_asm_output_mi_thunk
175 #undef TARGET_ASM_CAN_OUTPUT_MI_THUNK
176 #define TARGET_ASM_CAN_OUTPUT_MI_THUNK default_can_output_mi_thunk_no_vcall
177
178 #undef TARGET_ASM_FILE_START
179 #define TARGET_ASM_FILE_START cris_file_start
180
181 #undef TARGET_INIT_LIBFUNCS
182 #define TARGET_INIT_LIBFUNCS cris_init_libfuncs
183
184 #undef TARGET_RTX_COSTS
185 #define TARGET_RTX_COSTS cris_rtx_costs
186 #undef TARGET_ADDRESS_COST
187 #define TARGET_ADDRESS_COST cris_address_cost
188
189 #undef TARGET_PROMOTE_FUNCTION_ARGS
190 #define TARGET_PROMOTE_FUNCTION_ARGS hook_bool_tree_true
191 #undef TARGET_STRUCT_VALUE_RTX
192 #define TARGET_STRUCT_VALUE_RTX cris_struct_value_rtx
193 #undef TARGET_SETUP_INCOMING_VARARGS
194 #define TARGET_SETUP_INCOMING_VARARGS cris_setup_incoming_varargs
195 #undef TARGET_PASS_BY_REFERENCE
196 #define TARGET_PASS_BY_REFERENCE cris_pass_by_reference
197 #undef TARGET_ARG_PARTIAL_BYTES
198 #define TARGET_ARG_PARTIAL_BYTES cris_arg_partial_bytes
199 #undef TARGET_MD_ASM_CLOBBERS
200 #define TARGET_MD_ASM_CLOBBERS cris_md_asm_clobbers
201 #undef TARGET_DEFAULT_TARGET_FLAGS
202 #define TARGET_DEFAULT_TARGET_FLAGS (TARGET_DEFAULT | CRIS_SUBTARGET_DEFAULT)
203 #undef TARGET_HANDLE_OPTION
204 #define TARGET_HANDLE_OPTION cris_handle_option
205
206 struct gcc_target targetm = TARGET_INITIALIZER;
207
208 /* Helper for cris_load_multiple_op and cris_ret_movem_op.  */
209
210 bool
211 cris_movem_load_rest_p (rtx op, int offs)
212 {
213   unsigned int reg_count = XVECLEN (op, 0) - offs;
214   rtx src_addr;
215   int i;
216   rtx elt;
217   int setno;
218   int regno_dir = 1;
219   unsigned int regno = 0;
220
221   /* Perform a quick check so we don't blow up below.  FIXME: Adjust for
222      other than (MEM reg).  */
223   if (reg_count <= 1
224       || GET_CODE (XVECEXP (op, 0, offs)) != SET
225       || GET_CODE (SET_DEST (XVECEXP (op, 0, offs))) != REG
226       || GET_CODE (SET_SRC (XVECEXP (op, 0, offs))) != MEM)
227     return false;
228
229   /* Check a possible post-inc indicator.  */
230   if (GET_CODE (SET_SRC (XVECEXP (op, 0, offs + 1))) == PLUS)
231     {
232       rtx reg = XEXP (SET_SRC (XVECEXP (op, 0, offs + 1)), 0);
233       rtx inc = XEXP (SET_SRC (XVECEXP (op, 0, offs + 1)), 1);
234
235       reg_count--;
236
237       if (reg_count == 1
238           || !REG_P (reg)
239           || !REG_P (SET_DEST (XVECEXP (op, 0, offs + 1)))
240           || REGNO (reg) != REGNO (SET_DEST (XVECEXP (op, 0, offs + 1)))
241           || GET_CODE (inc) != CONST_INT
242           || INTVAL (inc) != (HOST_WIDE_INT) reg_count * 4)
243         return false;
244       i = offs + 2;
245     }
246   else
247     i = offs + 1;
248
249   /* FIXME: These two only for pre-v32.  */
250   regno_dir = -1;
251   regno = reg_count - 1;
252
253   elt = XVECEXP (op, 0, offs);
254   src_addr = XEXP (SET_SRC (elt), 0);
255
256   if (GET_CODE (elt) != SET
257       || GET_CODE (SET_DEST (elt)) != REG
258       || GET_MODE (SET_DEST (elt)) != SImode
259       || REGNO (SET_DEST (elt)) != regno
260       || GET_CODE (SET_SRC (elt)) != MEM
261       || GET_MODE (SET_SRC (elt)) != SImode
262       || !memory_address_p (SImode, src_addr))
263     return false;
264
265   for (setno = 1; i < XVECLEN (op, 0); setno++, i++)
266     {
267       rtx elt = XVECEXP (op, 0, i);
268       regno += regno_dir;
269
270       if (GET_CODE (elt) != SET
271           || GET_CODE (SET_DEST (elt)) != REG
272           || GET_MODE (SET_DEST (elt)) != SImode
273           || REGNO (SET_DEST (elt)) != regno
274           || GET_CODE (SET_SRC (elt)) != MEM
275           || GET_MODE (SET_SRC (elt)) != SImode
276           || GET_CODE (XEXP (SET_SRC (elt), 0)) != PLUS
277           || ! rtx_equal_p (XEXP (XEXP (SET_SRC (elt), 0), 0), src_addr)
278           || GET_CODE (XEXP (XEXP (SET_SRC (elt), 0), 1)) != CONST_INT
279           || INTVAL (XEXP (XEXP (SET_SRC (elt), 0), 1)) != setno * 4)
280         return false;
281     }
282
283   return true;
284 }
285
286 /* Worker function for predicate for the parallel contents in a movem
287    to-memory.  */
288
289 bool
290 cris_store_multiple_op_p (rtx op)
291 {
292   int reg_count = XVECLEN (op, 0);
293   rtx dest;
294   rtx dest_addr;
295   rtx dest_base;
296   int i;
297   rtx elt;
298   int setno;
299   int regno_dir = 1;
300   int regno = 0;
301   int offset = 0;
302
303   /* Perform a quick check so we don't blow up below.  FIXME: Adjust for
304      other than (MEM reg) and (MEM (PLUS reg const)).  */
305   if (reg_count <= 1)
306     return false;
307
308   elt = XVECEXP (op, 0, 0);
309
310   if (GET_CODE (elt) != SET)
311     return  false;
312
313   dest = SET_DEST (elt);
314
315   if (GET_CODE (SET_SRC (elt)) != REG
316       || GET_CODE (dest) != MEM)
317     return false;
318
319   dest_addr = XEXP (dest, 0);
320
321   /* Check a possible post-inc indicator.  */
322   if (GET_CODE (SET_SRC (XVECEXP (op, 0, 1))) == PLUS)
323     {
324       rtx reg = XEXP (SET_SRC (XVECEXP (op, 0, 1)), 0);
325       rtx inc = XEXP (SET_SRC (XVECEXP (op, 0, 1)), 1);
326
327       reg_count--;
328
329       if (reg_count == 1
330           || !REG_P (reg)
331           || !REG_P (SET_DEST (XVECEXP (op, 0, 1)))
332           || REGNO (reg) != REGNO (SET_DEST (XVECEXP (op, 0, 1)))
333           || GET_CODE (inc) != CONST_INT
334           /* Support increment by number of registers, and by the offset
335              of the destination, if it has the form (MEM (PLUS reg
336              offset)).  */
337           || !((REG_P (dest_addr)
338                 && REGNO (dest_addr) == REGNO (reg)
339                 && INTVAL (inc) == (HOST_WIDE_INT) reg_count * 4)
340                || (GET_CODE (dest_addr) == PLUS
341                    && REG_P (XEXP (dest_addr, 0))
342                    && REGNO (XEXP (dest_addr, 0)) == REGNO (reg)
343                    && GET_CODE (XEXP (dest_addr, 1)) == CONST_INT
344                    && INTVAL (XEXP (dest_addr, 1)) == INTVAL (inc))))
345         return false;
346
347       i = 2;
348     }
349   else
350     i = 1;
351
352   /* FIXME: These two only for pre-v32.  */
353   regno_dir = -1;
354   regno = reg_count - 1;
355
356   if (GET_CODE (elt) != SET
357       || GET_CODE (SET_SRC (elt)) != REG
358       || GET_MODE (SET_SRC (elt)) != SImode
359       || REGNO (SET_SRC (elt)) != (unsigned int) regno
360       || GET_CODE (SET_DEST (elt)) != MEM
361       || GET_MODE (SET_DEST (elt)) != SImode)
362     return false;
363
364   if (REG_P (dest_addr))
365     {
366       dest_base = dest_addr;
367       offset = 0;
368     }
369   else if (GET_CODE (dest_addr) == PLUS
370            && REG_P (XEXP (dest_addr, 0))
371            && GET_CODE (XEXP (dest_addr, 1)) == CONST_INT)
372     {
373       dest_base = XEXP (dest_addr, 0);
374       offset = INTVAL (XEXP (dest_addr, 1));
375     }
376   else
377     return false;
378
379   for (setno = 1; i < XVECLEN (op, 0); setno++, i++)
380     {
381       rtx elt = XVECEXP (op, 0, i);
382       regno += regno_dir;
383
384       if (GET_CODE (elt) != SET
385           || GET_CODE (SET_SRC (elt)) != REG
386           || GET_MODE (SET_SRC (elt)) != SImode
387           || REGNO (SET_SRC (elt)) != (unsigned int) regno
388           || GET_CODE (SET_DEST (elt)) != MEM
389           || GET_MODE (SET_DEST (elt)) != SImode
390           || GET_CODE (XEXP (SET_DEST (elt), 0)) != PLUS
391           || ! rtx_equal_p (XEXP (XEXP (SET_DEST (elt), 0), 0), dest_base)
392           || GET_CODE (XEXP (XEXP (SET_DEST (elt), 0), 1)) != CONST_INT
393           || INTVAL (XEXP (XEXP (SET_DEST (elt), 0), 1)) != setno * 4 + offset)
394         return false;
395     }
396
397   return true;
398 }
399
400 /* The CONDITIONAL_REGISTER_USAGE worker.  */
401
402 void
403 cris_conditional_register_usage (void)
404 {
405   /* FIXME: This isn't nice.  We should be able to use that register for
406      something else if the PIC table isn't needed.  */
407   if (flag_pic)
408     fixed_regs[PIC_OFFSET_TABLE_REGNUM]
409       = call_used_regs[PIC_OFFSET_TABLE_REGNUM] = 1;
410
411   if (TARGET_HAS_MUL_INSNS)
412     fixed_regs[CRIS_MOF_REGNUM] = 0;
413 }
414
415 /* Return current_function_uses_pic_offset_table.  For use in cris.md,
416    since some generated files do not include function.h.  */
417
418 int
419 cris_cfun_uses_pic_table (void)
420 {
421   return current_function_uses_pic_offset_table;
422 }
423
424 /* Given an rtx, return the text string corresponding to the CODE of X.
425    Intended for use in the assembly language output section of a
426    define_insn.  */
427
428 const char *
429 cris_op_str (rtx x)
430 {
431   cris_output_insn_is_bound = 0;
432   switch (GET_CODE (x))
433     {
434     case PLUS:
435       return "add";
436       break;
437
438     case MINUS:
439       return "sub";
440       break;
441
442     case MULT:
443       /* This function is for retrieving a part of an instruction name for
444          an operator, for immediate output.  If that ever happens for
445          MULT, we need to apply TARGET_MUL_BUG in the caller.  Make sure
446          we notice.  */
447       internal_error ("MULT case in cris_op_str");
448       break;
449
450     case DIV:
451       return "div";
452       break;
453
454     case AND:
455       return "and";
456       break;
457
458     case IOR:
459       return "or";
460       break;
461
462     case XOR:
463       return "xor";
464       break;
465
466     case NOT:
467       return "not";
468       break;
469
470     case ASHIFT:
471       return "lsl";
472       break;
473
474     case LSHIFTRT:
475       return "lsr";
476       break;
477
478     case ASHIFTRT:
479       return "asr";
480       break;
481
482     case UMIN:
483       /* Used to control the sign/zero-extend character for the 'e' modifier.
484          BOUND has none.  */
485       cris_output_insn_is_bound = 1;
486       return "bound";
487       break;
488
489     default:
490       return "Unknown operator";
491       break;
492   }
493 }
494
495 /* Emit an error message when we're in an asm, and a fatal error for
496    "normal" insns.  Formatted output isn't easily implemented, since we
497    use output_operand_lossage to output the actual message and handle the
498    categorization of the error.  */
499
500 static void
501 cris_operand_lossage (const char *msgid, rtx op)
502 {
503   debug_rtx (op);
504   output_operand_lossage ("%s", msgid);
505 }
506
507 /* Print an index part of an address to file.  */
508
509 static void
510 cris_print_index (rtx index, FILE *file)
511 {
512   rtx inner = XEXP (index, 0);
513
514   /* Make the index "additive" unless we'll output a negative number, in
515      which case the sign character is free (as in free beer).  */
516   if (GET_CODE (index) != CONST_INT || INTVAL (index) >= 0)
517     putc ('+', file);
518
519   if (REG_P (index))
520     fprintf (file, "$%s.b", reg_names[REGNO (index)]);
521   else if (CONSTANT_P (index))
522     cris_output_addr_const (file, index);
523   else if (GET_CODE (index) == MULT)
524     {
525       fprintf (file, "$%s.",
526                reg_names[REGNO (XEXP (index, 0))]);
527
528       putc (INTVAL (XEXP (index, 1)) == 2 ? 'w' : 'd', file);
529     }
530   else if (GET_CODE (index) == SIGN_EXTEND &&
531            GET_CODE (inner) == MEM)
532     {
533       rtx inner_inner = XEXP (inner, 0);
534
535       if (GET_CODE (inner_inner) == POST_INC)
536         {
537           fprintf (file, "[$%s+].",
538                    reg_names[REGNO (XEXP (inner_inner, 0))]);
539           putc (GET_MODE (inner) == HImode ? 'w' : 'b', file);
540         }
541       else
542         {
543           fprintf (file, "[$%s].", reg_names[REGNO (inner_inner)]);
544
545           putc (GET_MODE (inner) == HImode ? 'w' : 'b', file);
546         }
547     }
548   else if (GET_CODE (index) == MEM)
549     {
550       if (GET_CODE (inner) == POST_INC)
551         fprintf (file, "[$%s+].d", reg_names[REGNO (XEXP (inner, 0))]);
552       else
553         fprintf (file, "[$%s].d", reg_names[REGNO (inner)]);
554     }
555   else
556     cris_operand_lossage ("unexpected index-type in cris_print_index",
557                           index);
558 }
559
560 /* Print a base rtx of an address to file.  */
561
562 static void
563 cris_print_base (rtx base, FILE *file)
564 {
565   if (REG_P (base))
566     fprintf (file, "$%s", reg_names[REGNO (base)]);
567   else if (GET_CODE (base) == POST_INC)
568     fprintf (file, "$%s+", reg_names[REGNO (XEXP (base, 0))]);
569   else
570     cris_operand_lossage ("unexpected base-type in cris_print_base",
571                           base);
572 }
573
574 /* Usable as a guard in expressions.  */
575
576 int
577 cris_fatal (char *arg)
578 {
579   internal_error (arg);
580
581   /* We'll never get here; this is just to appease compilers.  */
582   return 0;
583 }
584
585 /* Return nonzero if REGNO is an ordinary register that *needs* to be
586    saved together with other registers, possibly by a MOVEM instruction,
587    or is saved for target-independent reasons.  There may be
588    target-dependent reasons to save the register anyway; this is just a
589    wrapper for a complicated conditional.  */
590
591 static int
592 cris_reg_saved_in_regsave_area (unsigned int regno, bool got_really_used)
593 {
594   return
595     (((regs_ever_live[regno]
596        && !call_used_regs[regno])
597       || (regno == PIC_OFFSET_TABLE_REGNUM
598           && (got_really_used
599               /* It is saved anyway, if there would be a gap.  */
600               || (flag_pic
601                   && regs_ever_live[regno + 1]
602                   && !call_used_regs[regno + 1]))))
603      && (regno != FRAME_POINTER_REGNUM || !frame_pointer_needed)
604      && regno != CRIS_SRP_REGNUM)
605     || (current_function_calls_eh_return
606         && (regno == EH_RETURN_DATA_REGNO (0)
607             || regno == EH_RETURN_DATA_REGNO (1)
608             || regno == EH_RETURN_DATA_REGNO (2)
609             || regno == EH_RETURN_DATA_REGNO (3)));
610 }
611
612 /* Return nonzero if there are regs mentioned in the insn that are not all
613    in the call_used regs.  This is part of the decision whether an insn
614    can be put in the epilogue.  */
615
616 static int
617 saved_regs_mentioned (rtx x)
618 {
619   int i;
620   const char *fmt;
621   RTX_CODE code;
622
623   /* Mainly stolen from refers_to_regno_p in rtlanal.c.  */
624
625   code = GET_CODE (x);
626
627   switch (code)
628     {
629     case REG:
630       i = REGNO (x);
631       return !call_used_regs[i];
632
633     case SUBREG:
634       /* If this is a SUBREG of a hard reg, we can see exactly which
635          registers are being modified.  Otherwise, handle normally.  */
636       i = REGNO (SUBREG_REG (x));
637       return !call_used_regs[i];
638
639     default:
640       ;
641     }
642
643   fmt = GET_RTX_FORMAT (code);
644   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
645     {
646       if (fmt[i] == 'e')
647         {
648           if (saved_regs_mentioned (XEXP (x, i)))
649             return 1;
650         }
651       else if (fmt[i] == 'E')
652         {
653           int j;
654           for (j = XVECLEN (x, i) - 1; j >=0; j--)
655             if (saved_regs_mentioned (XEXP (x, i)))
656               return 1;
657         }
658     }
659
660   return 0;
661 }
662
663 /* The PRINT_OPERAND worker.  */
664
665 void
666 cris_print_operand (FILE *file, rtx x, int code)
667 {
668   rtx operand = x;
669
670   /* Size-strings corresponding to MULT expressions.  */
671   static const char *const mults[] = { "BAD:0", ".b", ".w", "BAD:3", ".d" };
672
673   /* New code entries should just be added to the switch below.  If
674      handling is finished, just return.  If handling was just a
675      modification of the operand, the modified operand should be put in
676      "operand", and then do a break to let default handling
677      (zero-modifier) output the operand.  */
678
679   switch (code)
680     {
681     case 'b':
682       /* Print the unsigned supplied integer as if it were signed
683          and < 0, i.e print 255 or 65535 as -1, 254, 65534 as -2, etc.  */
684       if (GET_CODE (x) != CONST_INT
685           || ! CONST_OK_FOR_LETTER_P (INTVAL (x), 'O'))
686         LOSE_AND_RETURN ("invalid operand for 'b' modifier", x);
687       fprintf (file, HOST_WIDE_INT_PRINT_DEC,
688                INTVAL (x)| (INTVAL (x) <= 255 ? ~255 : ~65535));
689       return;
690
691     case 'x':
692       /* Print assembler code for operator.  */
693       fprintf (file, "%s", cris_op_str (operand));
694       return;
695
696     case 'v':
697       /* Print the operand without the PIC register.  */
698       if (! flag_pic || ! CONSTANT_P (x) || ! cris_gotless_symbol (x))
699         LOSE_AND_RETURN ("invalid operand for 'v' modifier", x);
700       cris_pic_sympart_only++;
701       cris_output_addr_const (file, x);
702       cris_pic_sympart_only--;
703       return;
704
705     case 'o':
706       {
707         /* A movem modifier working on a parallel; output the register
708            name.  */
709         int regno;
710
711         if (GET_CODE (x) != PARALLEL)
712           LOSE_AND_RETURN ("invalid operand for 'o' modifier", x);
713
714         /* The second item can be (set reg (plus reg const)) to denote a
715            postincrement.  */
716         regno
717           = (GET_CODE (SET_SRC (XVECEXP (x, 0, 1))) == PLUS
718              ? XVECLEN (x, 0) - 2
719              : XVECLEN (x, 0) - 1);
720
721         fprintf (file, "$%s", reg_names [regno]);
722       }
723       return;
724
725     case 'O':
726       {
727         /* A similar movem modifier; output the memory operand.  */
728         rtx addr;
729
730         if (GET_CODE (x) != PARALLEL)
731           LOSE_AND_RETURN ("invalid operand for 'O' modifier", x);
732
733         /* The lowest mem operand is in the first item, but perhaps it
734            needs to be output as postincremented.  */
735         addr = GET_CODE (SET_SRC (XVECEXP (x, 0, 0))) == MEM
736           ? XEXP (SET_SRC (XVECEXP (x, 0, 0)), 0)
737           : XEXP (SET_DEST (XVECEXP (x, 0, 0)), 0);
738
739         /* The second item can be a (set reg (plus reg const)) to denote
740            a modification.  */
741         if (GET_CODE (SET_SRC (XVECEXP (x, 0, 1))) == PLUS)
742           {
743             /* It's a post-increment, if the address is a naked (reg).  */
744             if (REG_P (addr))
745               addr = gen_rtx_POST_INC (SImode, addr);
746             else
747               {
748                 /* Otherwise, it's a side-effect; RN=RN+M.  */
749                 fprintf (file, "[$%s=$%s%s%d]",
750                          reg_names [REGNO (SET_DEST (XVECEXP (x, 0, 1)))],
751                          reg_names [REGNO (XEXP (addr, 0))],
752                          INTVAL (XEXP (addr, 1)) < 0 ? "" : "+",
753                          (int) INTVAL (XEXP (addr, 1)));
754                 return;
755               }
756           }
757         output_address (addr);
758       }
759       return;
760
761     case 'P':
762       /* Print the PIC register.  Applied to a GOT-less PIC symbol for
763          sanity.  */
764       if (! flag_pic || ! CONSTANT_P (x) || ! cris_gotless_symbol (x))
765         LOSE_AND_RETURN ("invalid operand for 'P' modifier", x);
766       fprintf (file, "$%s", reg_names [PIC_OFFSET_TABLE_REGNUM]);
767       return;
768
769     case 'p':
770       /* Adjust a power of two to its log2.  */
771       if (GET_CODE (x) != CONST_INT || exact_log2 (INTVAL (x)) < 0 )
772         LOSE_AND_RETURN ("invalid operand for 'p' modifier", x);
773       fprintf (file, "%d", exact_log2 (INTVAL (x)));
774       return;
775
776     case 's':
777       /* For an integer, print 'b' or 'w' if <= 255 or <= 65535
778          respectively.  This modifier also terminates the inhibiting
779          effects of the 'x' modifier.  */
780       cris_output_insn_is_bound = 0;
781       if (GET_MODE (x) == VOIDmode && GET_CODE (x) == CONST_INT)
782         {
783           if (INTVAL (x) >= 0)
784             {
785               if (INTVAL (x) <= 255)
786                 putc ('b', file);
787               else if (INTVAL (x) <= 65535)
788                 putc ('w', file);
789               else
790                 putc ('d', file);
791             }
792           else
793             putc ('d', file);
794           return;
795         }
796
797       /* For a non-integer, print the size of the operand.  */
798       putc ((GET_MODE (x) == SImode || GET_MODE (x) == SFmode)
799             ? 'd' : GET_MODE (x) == HImode ? 'w'
800             : GET_MODE (x) == QImode ? 'b'
801             /* If none of the above, emit an erroneous size letter.  */
802             : 'X',
803             file);
804       return;
805
806     case 'z':
807       /* Const_int: print b for -127 <= x <= 255,
808          w for -32768 <= x <= 65535, else die.  */
809       if (GET_CODE (x) != CONST_INT
810           || INTVAL (x) < -32768 || INTVAL (x) > 65535)
811         LOSE_AND_RETURN ("invalid operand for 'z' modifier", x);
812       putc (INTVAL (x) >= -128 && INTVAL (x) <= 255 ? 'b' : 'w', file);
813       return;
814
815     case '#':
816       /* Output a 'nop' if there's nothing for the delay slot.
817          This method stolen from the sparc files.  */
818       if (dbr_sequence_length () == 0)
819         fputs ("\n\tnop", file);
820       return;
821
822     case '!':
823       /* Output directive for alignment padded with "nop" insns.
824          Optimizing for size, it's plain 4-byte alignment, otherwise we
825          align the section to a cache-line (32 bytes) and skip at max 2
826          bytes, i.e. we skip if it's the last insn on a cache-line.  The
827          latter is faster by a small amount (for two test-programs 99.6%
828          and 99.9%) and larger by a small amount (ditto 100.1% and
829          100.2%).  This is supposed to be the simplest yet performance-
830          wise least intrusive way to make sure the immediately following
831          (supposed) muls/mulu insn isn't located at the end of a
832          cache-line.  */
833       if (TARGET_MUL_BUG)
834         fputs (optimize_size
835                ? ".p2alignw 2,0x050f\n\t"
836                : ".p2alignw 5,0x050f,2\n\t", file);
837       return;
838
839     case 'H':
840       /* Print high (most significant) part of something.  */
841       switch (GET_CODE (operand))
842         {
843         case CONST_INT:
844           /* If we're having 64-bit HOST_WIDE_INTs, the whole (DImode)
845              value is kept here, and so may be other than 0 or -1.  */
846           fprintf (file, HOST_WIDE_INT_PRINT_DEC,
847                    INTVAL (operand_subword (operand, 1, 0, DImode)));
848           return;
849
850         case CONST_DOUBLE:
851           /* High part of a long long constant.  */
852           if (GET_MODE (operand) == VOIDmode)
853             {
854               fprintf (file, HOST_WIDE_INT_PRINT_HEX, CONST_DOUBLE_HIGH (x));
855               return;
856             }
857           else
858             LOSE_AND_RETURN ("invalid operand for 'H' modifier", x);
859
860         case REG:
861           /* Print reg + 1.  Check that there's not an attempt to print
862              high-parts of registers like stack-pointer or higher.  */
863           if (REGNO (operand) > STACK_POINTER_REGNUM - 2)
864             LOSE_AND_RETURN ("bad register", operand);
865           fprintf (file, "$%s", reg_names[REGNO (operand) + 1]);
866           return;
867
868         case MEM:
869           /* Adjust memory address to high part.  */
870           {
871             rtx adj_mem = operand;
872             int size
873               = GET_MODE_BITSIZE (GET_MODE (operand)) / BITS_PER_UNIT;
874
875             /* Adjust so we can use two SImode in DImode.
876                Calling adj_offsettable_operand will make sure it is an
877                offsettable address.  Don't do this for a postincrement
878                though; it should remain as it was.  */
879             if (GET_CODE (XEXP (adj_mem, 0)) != POST_INC)
880               adj_mem
881                 = adjust_address (adj_mem, GET_MODE (adj_mem), size / 2);
882
883             output_address (XEXP (adj_mem, 0));
884             return;
885           }
886
887         default:
888           LOSE_AND_RETURN ("invalid operand for 'H' modifier", x);
889         }
890
891     case 'L':
892       /* Strip the MEM expression.  */
893       operand = XEXP (operand, 0);
894       break;
895
896     case 'e':
897       /* Print 's' if operand is SIGN_EXTEND or 'u' if ZERO_EXTEND unless
898          cris_output_insn_is_bound is nonzero.  */
899       if (GET_CODE (operand) != SIGN_EXTEND
900           && GET_CODE (operand) != ZERO_EXTEND
901           && GET_CODE (operand) != CONST_INT)
902         LOSE_AND_RETURN ("invalid operand for 'e' modifier", x);
903
904       if (cris_output_insn_is_bound)
905         {
906           cris_output_insn_is_bound = 0;
907           return;
908         }
909
910       putc (GET_CODE (operand) == SIGN_EXTEND
911             || (GET_CODE (operand) == CONST_INT && INTVAL (operand) < 0)
912             ? 's' : 'u', file);
913       return;
914
915     case 'm':
916       /* Print the size letter of the inner element.  We can do it by
917          calling ourselves with the 's' modifier.  */
918       if (GET_CODE (operand) != SIGN_EXTEND && GET_CODE (operand) != ZERO_EXTEND)
919         LOSE_AND_RETURN ("invalid operand for 'm' modifier", x);
920       cris_print_operand (file, XEXP (operand, 0), 's');
921       return;
922
923     case 'M':
924       /* Print the least significant part of operand.  */
925       if (GET_CODE (operand) == CONST_DOUBLE)
926         {
927           fprintf (file, HOST_WIDE_INT_PRINT_HEX, CONST_DOUBLE_LOW (x));
928           return;
929         }
930       else if (HOST_BITS_PER_WIDE_INT > 32 && GET_CODE (operand) == CONST_INT)
931         {
932           fprintf (file, HOST_WIDE_INT_PRINT_HEX,
933                    INTVAL (x) & ((unsigned int) 0x7fffffff * 2 + 1));
934           return;
935         }
936       /* Otherwise the least significant part equals the normal part,
937          so handle it normally.  */
938       break;
939
940     case 'A':
941       /* When emitting an add for the high part of a DImode constant, we
942          want to use addq for 0 and adds.w for -1.  */
943       if (GET_CODE (operand) != CONST_INT)
944         LOSE_AND_RETURN ("invalid operand for 'A' modifier", x);
945       fprintf (file, INTVAL (operand) < 0 ? "adds.w" : "addq");
946       return;
947
948     case 'd':
949       /* If this is a GOT symbol, print it as :GOT regardless of -fpic.  */
950       if (flag_pic && CONSTANT_P (operand) && cris_got_symbol (operand))
951         {
952           cris_output_addr_const (file, operand);
953           fprintf (file, ":GOT");
954           return;
955         }
956       break;
957
958     case 'D':
959       /* When emitting an sub for the high part of a DImode constant, we
960          want to use subq for 0 and subs.w for -1.  */
961       if (GET_CODE (operand) != CONST_INT)
962         LOSE_AND_RETURN ("invalid operand for 'D' modifier", x);
963       fprintf (file, INTVAL (operand) < 0 ? "subs.w" : "subq");
964       return;
965
966     case 'S':
967       /* Print the operand as the index-part of an address.
968          Easiest way out is to use cris_print_index.  */
969       cris_print_index (operand, file);
970       return;
971
972     case 'T':
973       /* Print the size letter for an operand to a MULT, which must be a
974          const_int with a suitable value.  */
975       if (GET_CODE (operand) != CONST_INT || INTVAL (operand) > 4)
976         LOSE_AND_RETURN ("invalid operand for 'T' modifier", x);
977       fprintf (file, "%s", mults[INTVAL (operand)]);
978       return;
979
980     case 0:
981       /* No code, print as usual.  */
982       break;
983
984     default:
985       LOSE_AND_RETURN ("invalid operand modifier letter", x);
986     }
987
988   /* Print an operand as without a modifier letter.  */
989   switch (GET_CODE (operand))
990     {
991     case REG:
992       if (REGNO (operand) > 15
993           && REGNO (operand) != CRIS_MOF_REGNUM
994           && REGNO (operand) != CRIS_SRP_REGNUM)
995         internal_error ("internal error: bad register: %d", REGNO (operand));
996       fprintf (file, "$%s", reg_names[REGNO (operand)]);
997       return;
998
999     case MEM:
1000       output_address (XEXP (operand, 0));
1001       return;
1002
1003     case CONST_DOUBLE:
1004       if (GET_MODE (operand) == VOIDmode)
1005         /* A long long constant.  */
1006         output_addr_const (file, operand);
1007       else
1008         {
1009           /* Only single precision is allowed as plain operands the
1010              moment.  FIXME:  REAL_VALUE_FROM_CONST_DOUBLE isn't
1011              documented.  */
1012           REAL_VALUE_TYPE r;
1013           long l;
1014
1015           /* FIXME:  Perhaps check overflow of the "single".  */
1016           REAL_VALUE_FROM_CONST_DOUBLE (r, operand);
1017           REAL_VALUE_TO_TARGET_SINGLE (r, l);
1018
1019           fprintf (file, "0x%lx", l);
1020         }
1021       return;
1022
1023     case UNSPEC:
1024       ASSERT_PLT_UNSPEC (operand);
1025       /* Fall through.  */
1026
1027     case CONST:
1028       cris_output_addr_const (file, operand);
1029       return;
1030
1031     case MULT:
1032     case ASHIFT:
1033       {
1034         /* For a (MULT (reg X) const_int) we output "rX.S".  */
1035         int i = GET_CODE (XEXP (operand, 1)) == CONST_INT
1036           ? INTVAL (XEXP (operand, 1)) : INTVAL (XEXP (operand, 0));
1037         rtx reg = GET_CODE (XEXP (operand, 1)) == CONST_INT
1038           ? XEXP (operand, 0) : XEXP (operand, 1);
1039
1040         if (GET_CODE (reg) != REG
1041             || (GET_CODE (XEXP (operand, 0)) != CONST_INT
1042                 && GET_CODE (XEXP (operand, 1)) != CONST_INT))
1043           LOSE_AND_RETURN ("unexpected multiplicative operand", x);
1044
1045         cris_print_base (reg, file);
1046         fprintf (file, ".%c",
1047                  i == 0 || (i == 1 && GET_CODE (operand) == MULT) ? 'b'
1048                  : i == 4 ? 'd'
1049                  : (i == 2 && GET_CODE (operand) == MULT) || i == 1 ? 'w'
1050                  : 'd');
1051         return;
1052       }
1053
1054     default:
1055       /* No need to handle all strange variants, let output_addr_const
1056          do it for us.  */
1057       if (CONSTANT_P (operand))
1058         {
1059           cris_output_addr_const (file, operand);
1060           return;
1061         }
1062
1063       LOSE_AND_RETURN ("unexpected operand", x);
1064     }
1065 }
1066
1067 /* The PRINT_OPERAND_ADDRESS worker.  */
1068
1069 void
1070 cris_print_operand_address (FILE *file, rtx x)
1071 {
1072   /* All these were inside MEM:s so output indirection characters.  */
1073   putc ('[', file);
1074
1075   if (CONSTANT_ADDRESS_P (x))
1076     cris_output_addr_const (file, x);
1077   else if (BASE_OR_AUTOINCR_P (x))
1078     cris_print_base (x, file);
1079   else if (GET_CODE (x) == PLUS)
1080     {
1081       rtx x1, x2;
1082
1083       x1 = XEXP (x, 0);
1084       x2 = XEXP (x, 1);
1085       if (BASE_P (x1))
1086         {
1087           cris_print_base (x1, file);
1088           cris_print_index (x2, file);
1089         }
1090       else if (BASE_P (x2))
1091         {
1092           cris_print_base (x2, file);
1093           cris_print_index (x1, file);
1094         }
1095       else
1096         LOSE_AND_RETURN ("unrecognized address", x);
1097     }
1098   else if (GET_CODE (x) == MEM)
1099     {
1100       /* A DIP.  Output more indirection characters.  */
1101       putc ('[', file);
1102       cris_print_base (XEXP (x, 0), file);
1103       putc (']', file);
1104     }
1105   else
1106     LOSE_AND_RETURN ("unrecognized address", x);
1107
1108   putc (']', file);
1109 }
1110
1111 /* The RETURN_ADDR_RTX worker.
1112    We mark that the return address is used, either by EH or
1113    __builtin_return_address, for use by the function prologue and
1114    epilogue.  FIXME: This isn't optimal; we just use the mark in the
1115    prologue and epilogue to say that the return address is to be stored
1116    in the stack frame.  We could return SRP for leaf-functions and use the
1117    initial-value machinery.  */
1118
1119 rtx
1120 cris_return_addr_rtx (int count, rtx frameaddr ATTRIBUTE_UNUSED)
1121 {
1122   cfun->machine->needs_return_address_on_stack = 1;
1123
1124   /* The return-address is stored just above the saved frame-pointer (if
1125      present).  Apparently we can't eliminate from the frame-pointer in
1126      that direction, so use the incoming args (maybe pretended) pointer.  */
1127   return count == 0
1128     ? gen_rtx_MEM (Pmode, plus_constant (virtual_incoming_args_rtx, -4))
1129     : NULL_RTX;
1130 }
1131
1132 /* Accessor used in cris.md:return because cfun->machine isn't available
1133    there.  */
1134
1135 bool
1136 cris_return_address_on_stack (void)
1137 {
1138   return regs_ever_live[CRIS_SRP_REGNUM]
1139     || cfun->machine->needs_return_address_on_stack;
1140 }
1141
1142 /* Accessor used in cris.md:return because cfun->machine isn't available
1143    there.  */
1144
1145 bool
1146 cris_return_address_on_stack_for_return (void)
1147 {
1148   return cfun->machine->return_type == CRIS_RETINSN_RET ? false
1149     : cris_return_address_on_stack ();
1150 }
1151
1152 /* This used to be the INITIAL_FRAME_POINTER_OFFSET worker; now only
1153    handles FP -> SP elimination offset.  */
1154
1155 static int
1156 cris_initial_frame_pointer_offset (void)
1157 {
1158   int regno;
1159
1160   /* Initial offset is 0 if we don't have a frame pointer.  */
1161   int offs = 0;
1162   bool got_really_used = current_function_uses_pic_offset_table;
1163
1164   /* And 4 for each register pushed.  */
1165   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1166     if (cris_reg_saved_in_regsave_area (regno, got_really_used))
1167       offs += 4;
1168
1169   /* And then, last, we add the locals allocated.  */
1170   offs += get_frame_size ();
1171
1172   /* And more; the accumulated args size.  */
1173   offs += current_function_outgoing_args_size;
1174
1175   /* Then round it off, in case we use aligned stack.  */
1176   if (TARGET_STACK_ALIGN)
1177     offs = TARGET_ALIGN_BY_32 ? (offs + 3) & ~3 : (offs + 1) & ~1;
1178
1179   return offs;
1180 }
1181
1182 /* The INITIAL_ELIMINATION_OFFSET worker.
1183    Calculate the difference between imaginary registers such as frame
1184    pointer and the stack pointer.  Used to eliminate the frame pointer
1185    and imaginary arg pointer.  */
1186
1187 int
1188 cris_initial_elimination_offset (int fromreg, int toreg)
1189 {
1190   int fp_sp_offset
1191     = cris_initial_frame_pointer_offset ();
1192
1193   /* We should be able to use regs_ever_live and related prologue
1194      information here, or alpha should not as well.  */
1195   bool return_address_on_stack = cris_return_address_on_stack ();
1196
1197   /* Here we act as if the frame-pointer were needed.  */
1198   int ap_fp_offset = 4 + (return_address_on_stack ? 4 : 0);
1199
1200   if (fromreg == ARG_POINTER_REGNUM
1201       && toreg == FRAME_POINTER_REGNUM)
1202     return ap_fp_offset;
1203
1204   /* Between the frame pointer and the stack are only "normal" stack
1205      variables and saved registers.  */
1206   if (fromreg == FRAME_POINTER_REGNUM
1207       && toreg == STACK_POINTER_REGNUM)
1208     return fp_sp_offset;
1209
1210   /* We need to balance out the frame pointer here.  */
1211   if (fromreg == ARG_POINTER_REGNUM
1212       && toreg == STACK_POINTER_REGNUM)
1213     return ap_fp_offset + fp_sp_offset - 4;
1214
1215   gcc_unreachable ();
1216 }
1217
1218 /*  This function looks into the pattern to see how this insn affects
1219     condition codes.
1220
1221     Used when to eliminate test insns before a condition-code user,
1222     such as a "scc" insn or a conditional branch.  This includes
1223     checking if the entities that cc was updated by, are changed by the
1224     operation.
1225
1226     Currently a jumble of the old peek-inside-the-insn and the newer
1227     check-cc-attribute methods.  */
1228
1229 void
1230 cris_notice_update_cc (rtx exp, rtx insn)
1231 {
1232   /* Check if user specified "-mcc-init" as a bug-workaround.  FIXME:
1233      TARGET_CCINIT does not work; we must set CC_REVERSED as below.
1234      Several testcases will otherwise fail, for example
1235      gcc.c-torture/execute/20000217-1.c -O0 and -O1.  */
1236   if (TARGET_CCINIT)
1237     {
1238       CC_STATUS_INIT;
1239       return;
1240     }
1241
1242   /* Slowly, we're converting to using attributes to control the setting
1243      of condition-code status.  */
1244   switch (get_attr_cc (insn))
1245     {
1246     case CC_NONE:
1247       /* Even if it is "none", a setting may clobber a previous
1248          cc-value, so check.  */
1249       if (GET_CODE (exp) == SET)
1250         {
1251           if (cc_status.value1
1252               && modified_in_p (cc_status.value1, insn))
1253             cc_status.value1 = 0;
1254
1255           if (cc_status.value2
1256               && modified_in_p (cc_status.value2, insn))
1257             cc_status.value2 = 0;
1258         }
1259       return;
1260
1261     case CC_CLOBBER:
1262       CC_STATUS_INIT;
1263       break;
1264
1265     case CC_NORMAL:
1266       /* Which means, for:
1267          (set (cc0) (...)):
1268          CC is (...).
1269
1270          (set (reg) (...)):
1271          CC is (reg) and (...) - unless (...) is 0, then CC does not change.
1272          CC_NO_OVERFLOW unless (...) is reg or mem.
1273
1274          (set (mem) (...)):
1275          CC does not change.
1276
1277          (set (pc) (...)):
1278          CC does not change.
1279
1280          (parallel
1281           (set (reg1) (mem (bdap/biap)))
1282           (set (reg2) (bdap/biap))):
1283          CC is (reg1) and (mem (reg2))
1284
1285          (parallel
1286           (set (mem (bdap/biap)) (reg1)) [or 0]
1287           (set (reg2) (bdap/biap))):
1288          CC does not change.
1289
1290          (where reg and mem includes strict_low_parts variants thereof)
1291
1292          For all others, assume CC is clobbered.
1293          Note that we do not have to care about setting CC_NO_OVERFLOW,
1294          since the overflow flag is set to 0 (i.e. right) for
1295          instructions where it does not have any sane sense, but where
1296          other flags have meanings.  (This includes shifts; the carry is
1297          not set by them).
1298
1299          Note that there are other parallel constructs we could match,
1300          but we don't do that yet.  */
1301
1302       if (GET_CODE (exp) == SET)
1303         {
1304           /* FIXME: Check when this happens.  It looks like we should
1305              actually do a CC_STATUS_INIT here to be safe.  */
1306           if (SET_DEST (exp) == pc_rtx)
1307             return;
1308
1309           /* Record CC0 changes, so we do not have to output multiple
1310              test insns.  */
1311           if (SET_DEST (exp) == cc0_rtx)
1312             {
1313               cc_status.value1 = SET_SRC (exp);
1314               cc_status.value2 = 0;
1315
1316               /* Handle flags for the special btstq on one bit.  */
1317               if (GET_CODE (SET_SRC (exp)) == ZERO_EXTRACT
1318                   && XEXP (SET_SRC (exp), 1) == const1_rtx)
1319                 {
1320                   if (GET_CODE (XEXP (SET_SRC (exp), 0)) == CONST_INT)
1321                     /* Using cmpq.  */
1322                     cc_status.flags = CC_INVERTED;
1323                   else
1324                     /* A one-bit btstq.  */
1325                     cc_status.flags = CC_Z_IN_NOT_N;
1326                 }
1327               else
1328                 cc_status.flags = 0;
1329
1330               if (GET_CODE (SET_SRC (exp)) == COMPARE)
1331                 {
1332                   if (!REG_P (XEXP (SET_SRC (exp), 0))
1333                       && XEXP (SET_SRC (exp), 1) != const0_rtx)
1334                     /* For some reason gcc will not canonicalize compare
1335                        operations, reversing the sign by itself if
1336                        operands are in wrong order.  */
1337                     /* (But NOT inverted; eq is still eq.) */
1338                     cc_status.flags = CC_REVERSED;
1339
1340                   /* This seems to be overlooked by gcc.  FIXME: Check again.
1341                      FIXME:  Is it really safe?  */
1342                   cc_status.value2
1343                     = gen_rtx_MINUS (GET_MODE (SET_SRC (exp)),
1344                                      XEXP (SET_SRC (exp), 0),
1345                                      XEXP (SET_SRC (exp), 1));
1346                 }
1347               return;
1348             }
1349           else if (REG_P (SET_DEST (exp))
1350                    || (GET_CODE (SET_DEST (exp)) == STRICT_LOW_PART
1351                        && REG_P (XEXP (SET_DEST (exp), 0))))
1352             {
1353               /* A register is set; normally CC is set to show that no
1354                  test insn is needed.  Catch the exceptions.  */
1355
1356               /* If not to cc0, then no "set"s in non-natural mode give
1357                  ok cc0...  */
1358               if (GET_MODE_SIZE (GET_MODE (SET_DEST (exp))) > UNITS_PER_WORD
1359                   || GET_MODE_CLASS (GET_MODE (SET_DEST (exp))) == MODE_FLOAT)
1360                 {
1361                   /* ... except add:s and sub:s in DImode.  */
1362                   if (GET_MODE (SET_DEST (exp)) == DImode
1363                       && (GET_CODE (SET_SRC (exp)) == PLUS
1364                           || GET_CODE (SET_SRC (exp)) == MINUS))
1365                     {
1366                       cc_status.flags = 0;
1367                       cc_status.value1 = SET_DEST (exp);
1368                       cc_status.value2 = SET_SRC (exp);
1369
1370                       if (cris_reg_overlap_mentioned_p (cc_status.value1,
1371                                                         cc_status.value2))
1372                         cc_status.value2 = 0;
1373
1374                       /* Add and sub may set V, which gets us
1375                          unoptimizable results in "gt" and "le" condition
1376                          codes.  */
1377                       cc_status.flags |= CC_NO_OVERFLOW;
1378
1379                       return;
1380                     }
1381                 }
1382               else if (SET_SRC (exp) == const0_rtx)
1383                 {
1384                   /* There's no CC0 change when clearing a register or
1385                      memory.  Just check for overlap.  */
1386                   if (cc_status.value1
1387                       && modified_in_p (cc_status.value1, insn))
1388                     cc_status.value1 = 0;
1389
1390                   if (cc_status.value2
1391                       && modified_in_p (cc_status.value2, insn))
1392                     cc_status.value2 = 0;
1393
1394                   return;
1395                 }
1396               else
1397                 {
1398                   cc_status.flags = 0;
1399                   cc_status.value1 = SET_DEST (exp);
1400                   cc_status.value2 = SET_SRC (exp);
1401
1402                   if (cris_reg_overlap_mentioned_p (cc_status.value1,
1403                                                     cc_status.value2))
1404                     cc_status.value2 = 0;
1405
1406                   /* Some operations may set V, which gets us
1407                      unoptimizable results in "gt" and "le" condition
1408                      codes.  */
1409                   if (GET_CODE (SET_SRC (exp)) == PLUS
1410                       || GET_CODE (SET_SRC (exp)) == MINUS
1411                       || GET_CODE (SET_SRC (exp)) == NEG)
1412                     cc_status.flags |= CC_NO_OVERFLOW;
1413
1414                   return;
1415                 }
1416             }
1417           else if (GET_CODE (SET_DEST (exp)) == MEM
1418                    || (GET_CODE (SET_DEST (exp)) == STRICT_LOW_PART
1419                        && GET_CODE (XEXP (SET_DEST (exp), 0)) == MEM))
1420             {
1421               /* When SET to MEM, then CC is not changed (except for
1422                  overlap).  */
1423               if (cc_status.value1
1424                   && modified_in_p (cc_status.value1, insn))
1425                 cc_status.value1 = 0;
1426
1427               if (cc_status.value2
1428                   && modified_in_p (cc_status.value2, insn))
1429                 cc_status.value2 = 0;
1430
1431               return;
1432             }
1433         }
1434       else if (GET_CODE (exp) == PARALLEL)
1435         {
1436           if (GET_CODE (XVECEXP (exp, 0, 0)) == SET
1437               && GET_CODE (XVECEXP (exp, 0, 1)) == SET
1438               && REG_P (XEXP (XVECEXP (exp, 0, 1), 0)))
1439             {
1440               if (REG_P (XEXP (XVECEXP (exp, 0, 0), 0))
1441                   && GET_CODE (XEXP (XVECEXP (exp, 0, 0), 1)) == MEM)
1442                 {
1443                   /* For "move.S [rx=ry+o],rz", say CC reflects
1444                      value1=rz and value2=[rx] */
1445                   cc_status.value1 = XEXP (XVECEXP (exp, 0, 0), 0);
1446                   cc_status.value2
1447                     = replace_equiv_address (XEXP (XVECEXP (exp, 0, 0), 1),
1448                                              XEXP (XVECEXP (exp, 0, 1), 0));
1449                   cc_status.flags = 0;
1450
1451                   /* Huh?  A side-effect cannot change the destination
1452                      register.  */
1453                   if (cris_reg_overlap_mentioned_p (cc_status.value1,
1454                                                     cc_status.value2))
1455                     internal_error ("internal error: sideeffect-insn affecting main effect");
1456                   return;
1457                 }
1458               else if ((REG_P (XEXP (XVECEXP (exp, 0, 0), 1))
1459                         || XEXP (XVECEXP (exp, 0, 0), 1) == const0_rtx)
1460                        && GET_CODE (XEXP (XVECEXP (exp, 0, 0), 0)) == MEM)
1461                 {
1462                   /* For "move.S rz,[rx=ry+o]" and "clear.S [rx=ry+o]",
1463                      say flags are not changed, except for overlap.  */
1464                   if (cc_status.value1
1465                       && modified_in_p (cc_status.value1, insn))
1466                     cc_status.value1 = 0;
1467
1468                   if (cc_status.value2
1469                       && modified_in_p (cc_status.value2, insn))
1470                     cc_status.value2 = 0;
1471
1472                   return;
1473                 }
1474             }
1475         }
1476       break;
1477
1478     default:
1479       internal_error ("Unknown cc_attr value");
1480     }
1481
1482   CC_STATUS_INIT;
1483 }
1484
1485 /* Return != 0 if the return sequence for the current function is short,
1486    like "ret" or "jump [sp+]".  Prior to reloading, we can't tell if
1487    registers must be saved, so return 0 then.  */
1488
1489 bool
1490 cris_simple_epilogue (void)
1491 {
1492   unsigned int regno;
1493   unsigned int reglimit = STACK_POINTER_REGNUM;
1494   bool got_really_used = current_function_uses_pic_offset_table;
1495
1496   if (! reload_completed
1497       || frame_pointer_needed
1498       || get_frame_size () != 0
1499       || current_function_pretend_args_size
1500       || current_function_args_size
1501       || current_function_outgoing_args_size
1502       || current_function_calls_eh_return
1503
1504       /* If we're not supposed to emit prologue and epilogue, we must
1505          not emit return-type instructions.  */
1506       || !TARGET_PROLOGUE_EPILOGUE)
1507     return false;
1508
1509   /* No simple epilogue if there are saved registers.  */
1510   for (regno = 0; regno < reglimit; regno++)
1511     if (cris_reg_saved_in_regsave_area (regno, got_really_used))
1512       return false;
1513
1514   return true;
1515 }
1516
1517 /* Expand a return insn (just one insn) marked as using SRP or stack
1518    slot depending on parameter ON_STACK.  */
1519
1520 void
1521 cris_expand_return (bool on_stack)
1522 {
1523   /* FIXME: emit a parallel with a USE for SRP or the stack-slot, to
1524      tell "ret" from "jump [sp+]".  Some, but not all, other parts of
1525      GCC expect just (return) to do the right thing when optimizing, so
1526      we do that until they're fixed.  Currently, all return insns in a
1527      function must be the same (not really a limiting factor) so we need
1528      to check that it doesn't change half-way through.  */
1529   emit_jump_insn (gen_rtx_RETURN (VOIDmode));
1530
1531   CRIS_ASSERT (cfun->machine->return_type != CRIS_RETINSN_RET || !on_stack);
1532   CRIS_ASSERT (cfun->machine->return_type != CRIS_RETINSN_JUMP || on_stack);
1533
1534   cfun->machine->return_type
1535     = on_stack ? CRIS_RETINSN_JUMP : CRIS_RETINSN_RET;
1536 }
1537
1538 /* Compute a (partial) cost for rtx X.  Return true if the complete
1539    cost has been computed, and false if subexpressions should be
1540    scanned.  In either case, *TOTAL contains the cost result.  */
1541
1542 static bool
1543 cris_rtx_costs (rtx x, int code, int outer_code, int *total)
1544 {
1545   switch (code)
1546     {
1547     case CONST_INT:
1548       {
1549         HOST_WIDE_INT val = INTVAL (x);
1550         if (val == 0)
1551           *total = 0;
1552         else if (val < 32 && val >= -32)
1553           *total = 1;
1554         /* Eight or 16 bits are a word and cycle more expensive.  */
1555         else if (val <= 32767 && val >= -32768)
1556           *total = 2;
1557         /* A 32 bit constant (or very seldom, unsigned 16 bits) costs
1558            another word.  FIXME: This isn't linear to 16 bits.  */
1559         else
1560           *total = 4;
1561         return true;
1562       }
1563
1564     case LABEL_REF:
1565       *total = 6;
1566       return true;
1567
1568     case CONST:
1569     case SYMBOL_REF:
1570       /* For PIC, we need a prefix (if it isn't already there),
1571          and the PIC register.  For a global PIC symbol, we also
1572          need a read of the GOT.  */
1573       if (flag_pic)
1574         {
1575           if (cris_got_symbol (x))
1576             *total = 2 + 4 + 6;
1577           else
1578             *total = 2 + 6;
1579         }
1580       else
1581         *total = 6;
1582       return true;
1583
1584     case CONST_DOUBLE:
1585       if (x != CONST0_RTX (GET_MODE (x) == VOIDmode ? DImode : GET_MODE (x)))
1586         *total = 12;
1587       else
1588         /* Make 0.0 cheap, else test-insns will not be used.  */
1589         *total = 0;
1590       return true;
1591
1592     case MULT:
1593       /* Identify values that are no powers of two.  Powers of 2 are
1594          taken care of already and those values should not be changed.  */
1595       if (GET_CODE (XEXP (x, 1)) != CONST_INT
1596           || exact_log2 (INTVAL (XEXP (x, 1)) < 0))
1597         {
1598           /* If we have a multiply insn, then the cost is between
1599              1 and 2 "fast" instructions.  */
1600           if (TARGET_HAS_MUL_INSNS)
1601             {
1602               *total = COSTS_N_INSNS (1) + COSTS_N_INSNS (1) / 2;
1603               return true;
1604             }
1605
1606           /* Estimate as 4 + 4 * #ofbits.  */
1607           *total = COSTS_N_INSNS (132);
1608           return true;
1609         }
1610       return false;
1611
1612     case UDIV:
1613     case MOD:
1614     case UMOD:
1615     case DIV:
1616       if (GET_CODE (XEXP (x, 1)) != CONST_INT
1617           || exact_log2 (INTVAL (XEXP (x, 1)) < 0))
1618         {
1619           /* Estimate this as 4 + 8 * #of bits.  */
1620           *total = COSTS_N_INSNS (260);
1621           return true;
1622         }
1623       return false;
1624
1625     case AND:
1626       if (GET_CODE (XEXP (x, 1)) == CONST_INT
1627           /* Two constants may actually happen before optimization.  */
1628           && GET_CODE (XEXP (x, 0)) != CONST_INT
1629           && !CONST_OK_FOR_LETTER_P (INTVAL (XEXP (x, 1)), 'I'))
1630         {
1631           *total = (rtx_cost (XEXP (x, 0), outer_code) + 2
1632                     + 2 * GET_MODE_NUNITS (GET_MODE (XEXP (x, 0))));
1633           return true;
1634         }
1635       return false;
1636
1637     case ZERO_EXTEND: case SIGN_EXTEND:
1638       *total = rtx_cost (XEXP (x, 0), outer_code);
1639       return true;
1640
1641     default:
1642       return false;
1643     }
1644 }
1645
1646 /* The ADDRESS_COST worker.  */
1647
1648 static int
1649 cris_address_cost (rtx x)
1650 {
1651   /* The metric to use for the cost-macros is unclear.
1652      The metric used here is (the number of cycles needed) / 2,
1653      where we consider equal a cycle for a word of code and a cycle to
1654      read memory.  */
1655
1656   /* The cheapest addressing modes get 0, since nothing extra is needed.  */
1657   if (BASE_OR_AUTOINCR_P (x))
1658     return 0;
1659
1660   /* An indirect mem must be a DIP.  This means two bytes extra for code,
1661      and 4 bytes extra for memory read, i.e.  (2 + 4) / 2.  */
1662   if (GET_CODE (x) == MEM)
1663     return (2 + 4) / 2;
1664
1665   /* Assume (2 + 4) / 2 for a single constant; a dword, since it needs
1666      an extra DIP prefix and 4 bytes of constant in most cases.
1667      For PIC and a symbol with a GOT entry, we double the cost since we
1668      add a [rPIC+...] offset.  A GOT-less symbol uses a BDAP prefix
1669      equivalent to the DIP prefix for non-PIC, hence the same cost.  */
1670   if (CONSTANT_P (x))
1671     return flag_pic && cris_got_symbol (x) ? 2 * (2 + 4) / 2 : (2 + 4) / 2;
1672
1673   /* Handle BIAP and BDAP prefixes.  */
1674   if (GET_CODE (x) == PLUS)
1675     {
1676       rtx tem1 = XEXP (x, 0);
1677       rtx tem2 = XEXP (x, 1);
1678
1679     /* A BIAP is 2 extra bytes for the prefix insn, nothing more.  We
1680        recognize the typical MULT which is always in tem1 because of
1681        insn canonicalization.  */
1682     if ((GET_CODE (tem1) == MULT && BIAP_INDEX_P (tem1))
1683         || REG_P (tem1))
1684       return 2 / 2;
1685
1686     /* A BDAP (quick) is 2 extra bytes.  Any constant operand to the
1687        PLUS is always found in tem2.  */
1688     if (GET_CODE (tem2) == CONST_INT
1689         && INTVAL (tem2) < 128 && INTVAL (tem2) >= -128)
1690       return 2 / 2;
1691
1692     /* A BDAP -32768 .. 32767 is like BDAP quick, but with 2 extra
1693        bytes.  */
1694     if (GET_CODE (tem2) == CONST_INT
1695         && CONST_OK_FOR_LETTER_P (INTVAL (tem2), 'L'))
1696       return (2 + 2) / 2;
1697
1698     /* A BDAP with some other constant is 2 bytes extra.  */
1699     if (CONSTANT_P (tem2))
1700       return (2 + 2 + 2) / 2;
1701
1702     /* BDAP with something indirect should have a higher cost than
1703        BIAP with register.   FIXME: Should it cost like a MEM or more?  */
1704     /* Don't need to check it, it's the only one left.
1705        FIXME:  There was a REG test missing, perhaps there are others.
1706        Think more.  */
1707     return (2 + 2 + 2) / 2;
1708   }
1709
1710   /* What else?  Return a high cost.  It matters only for valid
1711      addressing modes.  */
1712   return 10;
1713 }
1714
1715 /* Check various objections to the side-effect.  Used in the test-part
1716    of an anonymous insn describing an insn with a possible side-effect.
1717    Returns nonzero if the implied side-effect is ok.
1718
1719    code     : PLUS or MULT
1720    ops      : An array of rtx:es. lreg, rreg, rval,
1721               The variables multop and other_op are indexes into this,
1722               or -1 if they are not applicable.
1723    lreg     : The register that gets assigned in the side-effect.
1724    rreg     : One register in the side-effect expression
1725    rval     : The other register, or an int.
1726    multop   : An integer to multiply rval with.
1727    other_op : One of the entities of the main effect,
1728               whose mode we must consider.  */
1729
1730 int
1731 cris_side_effect_mode_ok (enum rtx_code code, rtx *ops,
1732                           int lreg, int rreg, int rval,
1733                           int multop, int other_op)
1734 {
1735   /* Find what value to multiply with, for rx =ry + rz * n.  */
1736   int mult = multop < 0 ? 1 : INTVAL (ops[multop]);
1737
1738   rtx reg_rtx = ops[rreg];
1739   rtx val_rtx = ops[rval];
1740
1741   /* The operands may be swapped.  Canonicalize them in reg_rtx and
1742      val_rtx, where reg_rtx always is a reg (for this constraint to
1743      match).  */
1744   if (! BASE_P (reg_rtx))
1745     reg_rtx = val_rtx, val_rtx = ops[rreg];
1746
1747   /* Don't forget to check that reg_rtx really is a reg.  If it isn't,
1748      we have no business.  */
1749   if (! BASE_P (reg_rtx))
1750     return 0;
1751
1752   /* Don't do this when -mno-split.  */
1753   if (!TARGET_SIDE_EFFECT_PREFIXES)
1754     return 0;
1755
1756   /* The mult expression may be hidden in lreg.  FIXME:  Add more
1757      commentary about that.  */
1758   if (GET_CODE (val_rtx) == MULT)
1759     {
1760       mult = INTVAL (XEXP (val_rtx, 1));
1761       val_rtx = XEXP (val_rtx, 0);
1762       code = MULT;
1763     }
1764
1765   /* First check the "other operand".  */
1766   if (other_op >= 0)
1767     {
1768       if (GET_MODE_SIZE (GET_MODE (ops[other_op])) > UNITS_PER_WORD)
1769         return 0;
1770
1771       /* Check if the lvalue register is the same as the "other
1772          operand".  If so, the result is undefined and we shouldn't do
1773          this.  FIXME:  Check again.  */
1774       if ((BASE_P (ops[lreg])
1775            && BASE_P (ops[other_op])
1776            && REGNO (ops[lreg]) == REGNO (ops[other_op]))
1777           || rtx_equal_p (ops[other_op], ops[lreg]))
1778       return 0;
1779     }
1780
1781   /* Do not accept frame_pointer_rtx as any operand.  */
1782   if (ops[lreg] == frame_pointer_rtx || ops[rreg] == frame_pointer_rtx
1783       || ops[rval] == frame_pointer_rtx
1784       || (other_op >= 0 && ops[other_op] == frame_pointer_rtx))
1785     return 0;
1786
1787   if (code == PLUS
1788       && ! BASE_P (val_rtx))
1789     {
1790
1791       /* Do not allow rx = rx + n if a normal add or sub with same size
1792          would do.  */
1793       if (rtx_equal_p (ops[lreg], reg_rtx)
1794           && GET_CODE (val_rtx) == CONST_INT
1795           && (INTVAL (val_rtx) <= 63 && INTVAL (val_rtx) >= -63))
1796         return 0;
1797
1798       /* Check allowed cases, like [r(+)?].[bwd] and const.
1799          A symbol is not allowed with PIC.  */
1800       if (CONSTANT_P (val_rtx))
1801         return flag_pic == 0 || cris_symbol (val_rtx) == 0;
1802
1803       if (GET_CODE (val_rtx) == MEM
1804           && BASE_OR_AUTOINCR_P (XEXP (val_rtx, 0)))
1805         return 1;
1806
1807       if (GET_CODE (val_rtx) == SIGN_EXTEND
1808           && GET_CODE (XEXP (val_rtx, 0)) == MEM
1809           && BASE_OR_AUTOINCR_P (XEXP (XEXP (val_rtx, 0), 0)))
1810         return 1;
1811
1812       /* If we got here, it's not a valid addressing mode.  */
1813       return 0;
1814     }
1815   else if (code == MULT
1816            || (code == PLUS && BASE_P (val_rtx)))
1817     {
1818       /* Do not allow rx = rx + ry.S, since it doesn't give better code.  */
1819       if (rtx_equal_p (ops[lreg], reg_rtx)
1820           || (mult == 1 && rtx_equal_p (ops[lreg], val_rtx)))
1821         return 0;
1822
1823       /* Do not allow bad multiply-values.  */
1824       if (mult != 1 && mult != 2 && mult != 4)
1825         return 0;
1826
1827       /* Only allow  r + ...  */
1828       if (! BASE_P (reg_rtx))
1829         return 0;
1830
1831       /* If we got here, all seems ok.
1832          (All checks need to be done above).  */
1833       return 1;
1834     }
1835
1836   /* If we get here, the caller got its initial tests wrong.  */
1837   internal_error ("internal error: cris_side_effect_mode_ok with bad operands");
1838 }
1839
1840 /* The function reg_overlap_mentioned_p in CVS (still as of 2001-05-16)
1841    does not handle the case where the IN operand is strict_low_part; it
1842    does handle it for X.  Test-case in Axis-20010516.  This function takes
1843    care of that for THIS port.  FIXME: strict_low_part is going away
1844    anyway.  */
1845
1846 static int
1847 cris_reg_overlap_mentioned_p (rtx x, rtx in)
1848 {
1849   /* The function reg_overlap_mentioned now handles when X is
1850      strict_low_part, but not when IN is a STRICT_LOW_PART.  */
1851   if (GET_CODE (in) == STRICT_LOW_PART)
1852     in = XEXP (in, 0);
1853
1854   return reg_overlap_mentioned_p (x, in);
1855 }
1856
1857 /* The TARGET_ASM_NAMED_SECTION worker.
1858    We just dispatch to the functions for ELF and a.out.  */
1859
1860 void
1861 cris_target_asm_named_section (const char *name, unsigned int flags,
1862                                tree decl)
1863 {
1864   if (! TARGET_ELF)
1865     default_no_named_section (name, flags, decl);
1866   else
1867     default_elf_asm_named_section (name, flags, decl);
1868 }
1869
1870 /* The LEGITIMATE_PIC_OPERAND_P worker.  */
1871
1872 int
1873 cris_legitimate_pic_operand (rtx x)
1874 {
1875   /* The PIC representation of a symbol with a GOT entry will be (for
1876      example; relocations differ):
1877       sym => [rPIC+sym:GOT]
1878      and for a GOT-less symbol it will be (for example, relocation differ):
1879       sym => rPIC+sym:GOTOFF
1880      so only a symbol with a GOT is by itself a valid operand, and it
1881      can't be a sum of a symbol and an offset.  */
1882   return ! cris_symbol (x) || cris_got_symbol (x);
1883 }
1884
1885 /* Return nonzero if there's a SYMBOL_REF or LABEL_REF hiding inside this
1886    CONSTANT_P.  */
1887
1888 int
1889 cris_symbol (rtx x)
1890 {
1891   switch (GET_CODE (x))
1892     {
1893     case SYMBOL_REF:
1894     case LABEL_REF:
1895       return 1;
1896
1897     case UNSPEC:
1898       if (XINT (x, 1) == CRIS_UNSPEC_GOT || XINT (x, 1) != CRIS_UNSPEC_PLT)
1899         return 0;
1900       /* A PLT reference.  */
1901       ASSERT_PLT_UNSPEC (x);
1902       return 1;
1903
1904     case CONST:
1905       return cris_symbol (XEXP (x, 0));
1906
1907     case PLUS:
1908     case MINUS:
1909       return cris_symbol (XEXP (x, 0)) || cris_symbol (XEXP (x, 1));
1910
1911     case CONST_INT:
1912     case CONST_DOUBLE:
1913       return 0;
1914
1915     default:
1916       fatal_insn ("unrecognized supposed constant", x);
1917     }
1918
1919   return 1;
1920 }
1921
1922 /* Return nonzero if there's a SYMBOL_REF or LABEL_REF hiding inside this
1923    CONSTANT_P, and the symbol does not need a GOT entry.  Also set
1924    current_function_uses_pic_offset_table if we're generating PIC and ever
1925    see something that would need one.  */
1926
1927 int
1928 cris_gotless_symbol (rtx x)
1929 {
1930   CRIS_ASSERT (flag_pic);
1931
1932   switch (GET_CODE (x))
1933     {
1934     case UNSPEC:
1935       if (XINT (x, 1) == CRIS_UNSPEC_GOT)
1936         return 1;
1937       if (XINT (x, 1) != CRIS_UNSPEC_PLT)
1938         return 0;
1939       ASSERT_PLT_UNSPEC (x);
1940       return 1;
1941
1942     case SYMBOL_REF:
1943       if (cfun != NULL)
1944         current_function_uses_pic_offset_table = 1;
1945       return SYMBOL_REF_LOCAL_P (x);
1946
1947     case LABEL_REF:
1948       /* We don't set current_function_uses_pic_offset_table for
1949          LABEL_REF:s in here, since they are almost always originating
1950          from some branch.  The only time it does not come from a label is
1951          when GCC does something like __builtin_setjmp.  Then we get the
1952          LABEL_REF from the movsi expander, so we mark it there as a
1953          special case.  */
1954       return 1;
1955
1956     case CONST:
1957       return cris_gotless_symbol (XEXP (x, 0));
1958
1959     case PLUS:
1960     case MINUS:
1961       {
1962         int x0 = cris_gotless_symbol (XEXP (x, 0)) != 0;
1963         int x1 = cris_gotless_symbol (XEXP (x, 1)) != 0;
1964
1965         /* One and only one of them must be a local symbol.  Neither must
1966            be some other, more general kind of symbol.  */
1967         return
1968           (x0 ^ x1)
1969           && ! (x0 == 0 && cris_symbol (XEXP (x, 0)))
1970           && ! (x1 == 0 && cris_symbol (XEXP (x, 1)));
1971       }
1972
1973     case CONST_INT:
1974     case CONST_DOUBLE:
1975       return 0;
1976
1977     default:
1978       fatal_insn ("unrecognized supposed constant", x);
1979     }
1980
1981   return 1;
1982 }
1983
1984 /* Return nonzero if there's a SYMBOL_REF or LABEL_REF hiding inside this
1985    CONSTANT_P, and the symbol needs a GOT entry.  */
1986
1987 int
1988 cris_got_symbol (rtx x)
1989 {
1990   CRIS_ASSERT (flag_pic);
1991
1992   switch (GET_CODE (x))
1993     {
1994     case UNSPEC:
1995       if (XINT (x, 1) == CRIS_UNSPEC_GOT)
1996         return 0;
1997       ASSERT_PLT_UNSPEC (x);
1998       return 0;
1999
2000     case SYMBOL_REF:
2001       if (cfun != NULL)
2002         current_function_uses_pic_offset_table = 1;
2003       return ! SYMBOL_REF_LOCAL_P (x);
2004
2005     case CONST:
2006       return cris_got_symbol (XEXP (x, 0));
2007
2008     case LABEL_REF:
2009       /* A LABEL_REF is never visible as a symbol outside the local
2010          function.  */
2011     case PLUS:
2012     case MINUS:
2013       /* Nope, can't access the GOT for "symbol + offset".  */
2014       return 0;
2015
2016     case CONST_INT:
2017     case CONST_DOUBLE:
2018       return 0;
2019
2020     default:
2021       fatal_insn ("unrecognized supposed constant in cris_global_pic_symbol",
2022                   x);
2023     }
2024
2025   return 1;
2026 }
2027
2028 /* TARGET_HANDLE_OPTION worker.  We just store the values into local
2029    variables here.  Checks for correct semantics are in
2030    cris_override_options.  */
2031
2032 static bool
2033 cris_handle_option (size_t code, const char *arg, int value ATTRIBUTE_UNUSED)
2034 {
2035   switch (code)
2036     {
2037     case OPT_metrax100:
2038       target_flags
2039         |= (MASK_SVINTO
2040             + MASK_ETRAX4_ADD
2041             + MASK_ALIGN_BY_32);
2042       break;
2043
2044     case OPT_mno_etrax100:
2045       target_flags
2046         &= ~(MASK_SVINTO
2047              + MASK_ETRAX4_ADD
2048              + MASK_ALIGN_BY_32);
2049       break;
2050
2051     case OPT_m32_bit:
2052     case OPT_m32bit:
2053       target_flags
2054         |= (MASK_STACK_ALIGN
2055             + MASK_CONST_ALIGN
2056             + MASK_DATA_ALIGN
2057             + MASK_ALIGN_BY_32);
2058       break;
2059
2060     case OPT_m16_bit:
2061     case OPT_m16bit:
2062       target_flags
2063         |= (MASK_STACK_ALIGN
2064             + MASK_CONST_ALIGN
2065             + MASK_DATA_ALIGN);
2066       break;
2067
2068     case OPT_m8_bit:
2069     case OPT_m8bit:
2070       target_flags
2071         &= ~(MASK_STACK_ALIGN
2072              + MASK_CONST_ALIGN
2073              + MASK_DATA_ALIGN);
2074       break;
2075
2076     case OPT_max_stackframe_:
2077     case OPT_mmax_stackframe_:
2078       cris_max_stackframe_str = arg;
2079       break;
2080
2081     case OPT_march_:
2082     case OPT_mcpu_:
2083       cris_cpu_str = arg;
2084       break;
2085
2086     case OPT_mtune_:
2087       cris_tune_str = arg;
2088       break;
2089
2090     default:
2091       break;
2092     }
2093
2094   CRIS_SUBTARGET_HANDLE_OPTION(code, arg, value);
2095
2096   return true;
2097 }
2098
2099 /* The OVERRIDE_OPTIONS worker.
2100    As is the norm, this also parses -mfoo=bar type parameters.  */
2101
2102 void
2103 cris_override_options (void)
2104 {
2105   if (cris_max_stackframe_str)
2106     {
2107       cris_max_stackframe = atoi (cris_max_stackframe_str);
2108
2109       /* Do some sanity checking.  */
2110       if (cris_max_stackframe < 0 || cris_max_stackframe > 0x20000000)
2111         internal_error ("-max-stackframe=%d is not usable, not between 0 and %d",
2112                         cris_max_stackframe, 0x20000000);
2113     }
2114
2115   /* Let "-metrax4" and "-metrax100" change the cpu version.  */
2116   if (TARGET_SVINTO && cris_cpu_version < CRIS_CPU_SVINTO)
2117     cris_cpu_version = CRIS_CPU_SVINTO;
2118   else if (TARGET_ETRAX4_ADD && cris_cpu_version < CRIS_CPU_ETRAX4)
2119     cris_cpu_version = CRIS_CPU_ETRAX4;
2120
2121   /* Parse -march=... and its synonym, the deprecated -mcpu=...  */
2122   if (cris_cpu_str)
2123     {
2124       cris_cpu_version
2125         = (*cris_cpu_str == 'v' ? atoi (cris_cpu_str + 1) : -1);
2126
2127       if (strcmp ("etrax4", cris_cpu_str) == 0)
2128         cris_cpu_version = 3;
2129
2130       if (strcmp ("svinto", cris_cpu_str) == 0
2131           || strcmp ("etrax100", cris_cpu_str) == 0)
2132         cris_cpu_version = 8;
2133
2134       if (strcmp ("ng", cris_cpu_str) == 0
2135           || strcmp ("etrax100lx", cris_cpu_str) == 0)
2136         cris_cpu_version = 10;
2137
2138       if (cris_cpu_version < 0 || cris_cpu_version > 10)
2139         error ("unknown CRIS version specification in -march= or -mcpu= : %s",
2140                cris_cpu_str);
2141
2142       /* Set the target flags.  */
2143       if (cris_cpu_version >= CRIS_CPU_ETRAX4)
2144         target_flags |= MASK_ETRAX4_ADD;
2145
2146       /* If this is Svinto or higher, align for 32 bit accesses.  */
2147       if (cris_cpu_version >= CRIS_CPU_SVINTO)
2148         target_flags
2149           |= (MASK_SVINTO | MASK_ALIGN_BY_32
2150               | MASK_STACK_ALIGN | MASK_CONST_ALIGN
2151               | MASK_DATA_ALIGN);
2152
2153       /* Note that we do not add new flags when it can be completely
2154          described with a macro that uses -mcpu=X.  So
2155          TARGET_HAS_MUL_INSNS is (cris_cpu_version >= CRIS_CPU_NG).  */
2156     }
2157
2158   if (cris_tune_str)
2159     {
2160       int cris_tune
2161         = (*cris_tune_str == 'v' ? atoi (cris_tune_str + 1) : -1);
2162
2163       if (strcmp ("etrax4", cris_tune_str) == 0)
2164         cris_tune = 3;
2165
2166       if (strcmp ("svinto", cris_tune_str) == 0
2167           || strcmp ("etrax100", cris_tune_str) == 0)
2168         cris_tune = 8;
2169
2170       if (strcmp ("ng", cris_tune_str) == 0
2171           || strcmp ("etrax100lx", cris_tune_str) == 0)
2172         cris_tune = 10;
2173
2174       if (cris_tune < 0 || cris_tune > 10)
2175         error ("unknown CRIS cpu version specification in -mtune= : %s",
2176                cris_tune_str);
2177
2178       if (cris_tune >= CRIS_CPU_SVINTO)
2179         /* We have currently nothing more to tune than alignment for
2180            memory accesses.  */
2181         target_flags
2182           |= (MASK_STACK_ALIGN | MASK_CONST_ALIGN
2183               | MASK_DATA_ALIGN | MASK_ALIGN_BY_32);
2184     }
2185
2186   if (flag_pic)
2187     {
2188       /* Use error rather than warning, so invalid use is easily
2189          detectable.  Still change to the values we expect, to avoid
2190          further errors.  */
2191       if (! TARGET_LINUX)
2192         {
2193           error ("-fPIC and -fpic are not supported in this configuration");
2194           flag_pic = 0;
2195         }
2196
2197       /* Turn off function CSE.  We need to have the addresses reach the
2198          call expanders to get PLT-marked, as they could otherwise be
2199          compared against zero directly or indirectly.  After visiting the
2200          call expanders they will then be cse:ed, as the call expanders
2201          force_reg the addresses, effectively forcing flag_no_function_cse
2202          to 0.  */
2203       flag_no_function_cse = 1;
2204     }
2205
2206   if (write_symbols == DWARF2_DEBUG && ! TARGET_ELF)
2207     {
2208       warning (0, "that particular -g option is invalid with -maout and -melinux");
2209       write_symbols = DBX_DEBUG;
2210     }
2211
2212   /* Set the per-function-data initializer.  */
2213   init_machine_status = cris_init_machine_status;
2214 }
2215
2216 /* The TARGET_ASM_OUTPUT_MI_THUNK worker.  */
2217
2218 static void
2219 cris_asm_output_mi_thunk (FILE *stream,
2220                           tree thunkdecl ATTRIBUTE_UNUSED,
2221                           HOST_WIDE_INT delta,
2222                           HOST_WIDE_INT vcall_offset ATTRIBUTE_UNUSED,
2223                           tree funcdecl)
2224 {
2225   if (delta > 0)
2226     fprintf (stream, "\tadd%s " HOST_WIDE_INT_PRINT_DEC ",$%s\n",
2227              ADDITIVE_SIZE_MODIFIER (delta), delta,
2228              reg_names[CRIS_FIRST_ARG_REG]);
2229   else if (delta < 0)
2230     fprintf (stream, "\tsub%s " HOST_WIDE_INT_PRINT_DEC ",$%s\n",
2231              ADDITIVE_SIZE_MODIFIER (-delta), -delta,
2232              reg_names[CRIS_FIRST_ARG_REG]);
2233
2234   if (flag_pic)
2235     {
2236       const char *name = XSTR (XEXP (DECL_RTL (funcdecl), 0), 0);
2237
2238       name = (* targetm.strip_name_encoding) (name);
2239       fprintf (stream, "add.d ");
2240       assemble_name (stream, name);
2241       fprintf (stream, "%s,$pc\n", CRIS_PLT_PCOFFSET_SUFFIX);
2242     }
2243   else
2244     {
2245       fprintf (stream, "jump ");
2246       assemble_name (stream, XSTR (XEXP (DECL_RTL (funcdecl), 0), 0));
2247       fprintf (stream, "\n");
2248     }
2249 }
2250
2251 /* Boilerplate emitted at start of file.  
2252
2253    NO_APP *only at file start* means faster assembly.  It also means
2254    comments are not allowed.  In some cases comments will be output
2255    for debugging purposes.  Make sure they are allowed then.
2256
2257    We want a .file directive only if TARGET_ELF.  */
2258 static void
2259 cris_file_start (void)
2260 {
2261   /* These expressions can vary at run time, so we cannot put
2262      them into TARGET_INITIALIZER.  */
2263   targetm.file_start_app_off = !(TARGET_PDEBUG || flag_print_asm_name);
2264   targetm.file_start_file_directive = TARGET_ELF;
2265
2266   default_file_start ();
2267 }
2268
2269 /* Rename the function calls for integer multiply and divide.  */
2270 static void
2271 cris_init_libfuncs (void)
2272 {
2273   set_optab_libfunc (smul_optab, SImode, "__Mul");
2274   set_optab_libfunc (sdiv_optab, SImode, "__Div");
2275   set_optab_libfunc (udiv_optab, SImode, "__Udiv");
2276   set_optab_libfunc (smod_optab, SImode, "__Mod");
2277   set_optab_libfunc (umod_optab, SImode, "__Umod");
2278 }
2279
2280 /* The INIT_EXPANDERS worker sets the per-function-data initializer and
2281    mark functions.  */
2282
2283 void
2284 cris_init_expanders (void)
2285 {
2286   /* Nothing here at the moment.  */
2287 }
2288
2289 /* Zero initialization is OK for all current fields.  */
2290
2291 static struct machine_function *
2292 cris_init_machine_status (void)
2293 {
2294   return ggc_alloc_cleared (sizeof (struct machine_function));
2295 }
2296
2297 /* Split a 2 word move (DI or presumably DF) into component parts.
2298    Originally a copy of gen_split_move_double in m32r.c.  */
2299
2300 rtx
2301 cris_split_movdx (rtx *operands)
2302 {
2303   enum machine_mode mode = GET_MODE (operands[0]);
2304   rtx dest = operands[0];
2305   rtx src  = operands[1];
2306   rtx val;
2307
2308   /* We used to have to handle (SUBREG (MEM)) here, but that should no
2309      longer happen; after reload there are no SUBREGs any more, and we're
2310      only called after reload.  */
2311   CRIS_ASSERT (GET_CODE (dest) != SUBREG && GET_CODE (src) != SUBREG);
2312
2313   start_sequence ();
2314   if (GET_CODE (dest) == REG)
2315     {
2316       int dregno = REGNO (dest);
2317
2318       /* Reg-to-reg copy.  */
2319       if (GET_CODE (src) == REG)
2320         {
2321           int sregno = REGNO (src);
2322
2323           int reverse = (dregno == sregno + 1);
2324
2325           /* We normally copy the low-numbered register first.  However, if
2326              the first register operand 0 is the same as the second register of
2327              operand 1, we must copy in the opposite order.  */
2328           emit_insn (gen_rtx_SET (VOIDmode,
2329                                   operand_subword (dest, reverse, TRUE, mode),
2330                                   operand_subword (src, reverse, TRUE, mode)));
2331
2332           emit_insn (gen_rtx_SET (VOIDmode,
2333                                   operand_subword (dest, !reverse, TRUE, mode),
2334                                   operand_subword (src, !reverse, TRUE, mode)));
2335         }
2336       /* Constant-to-reg copy.  */
2337       else if (GET_CODE (src) == CONST_INT || GET_CODE (src) == CONST_DOUBLE)
2338         {
2339           rtx words[2];
2340           split_double (src, &words[0], &words[1]);
2341           emit_insn (gen_rtx_SET (VOIDmode,
2342                                   operand_subword (dest, 0, TRUE, mode),
2343                                   words[0]));
2344
2345           emit_insn (gen_rtx_SET (VOIDmode,
2346                                   operand_subword (dest, 1, TRUE, mode),
2347                                   words[1]));
2348         }
2349       /* Mem-to-reg copy.  */
2350       else if (GET_CODE (src) == MEM)
2351         {
2352           /* If the high-address word is used in the address, we must load it
2353              last.  Otherwise, load it first.  */
2354           rtx addr = XEXP (src, 0);
2355           int reverse
2356             = (refers_to_regno_p (dregno, dregno + 1, addr, NULL) != 0);
2357
2358           /* The original code implies that we can't do
2359              move.x [rN+],rM  move.x [rN],rM+1
2360              when rN is dead, because of REG_NOTES damage.  That is
2361              consistent with what I've seen, so don't try it.
2362
2363              We have two different cases here; if the addr is POST_INC,
2364              just pass it through, otherwise add constants.  */
2365
2366           if (GET_CODE (addr) == POST_INC)
2367             {
2368               emit_insn (gen_rtx_SET (VOIDmode,
2369                                       operand_subword (dest, 0, TRUE, mode),
2370                                       change_address (src, SImode, addr)));
2371               emit_insn (gen_rtx_SET (VOIDmode,
2372                                       operand_subword (dest, 1, TRUE, mode),
2373                                       change_address (src, SImode, addr)));
2374             }
2375           else
2376             {
2377               /* Make sure we don't get any other addresses with
2378                  embedded postincrements.  They should be stopped in
2379                  GO_IF_LEGITIMATE_ADDRESS, but we're here for your
2380                  safety.  */
2381               if (side_effects_p (addr))
2382                 fatal_insn ("unexpected side-effects in address", addr);
2383
2384               emit_insn (gen_rtx_SET
2385                          (VOIDmode,
2386                           operand_subword (dest, reverse, TRUE, mode),
2387                           change_address
2388                           (src, SImode,
2389                            plus_constant (addr,
2390                                           reverse * UNITS_PER_WORD))));
2391               emit_insn (gen_rtx_SET
2392                          (VOIDmode,
2393                           operand_subword (dest, ! reverse, TRUE, mode),
2394                           change_address
2395                           (src, SImode,
2396                            plus_constant (addr,
2397                                           (! reverse) *
2398                                           UNITS_PER_WORD))));
2399             }
2400         }
2401       else
2402         internal_error ("Unknown src");
2403     }
2404   /* Reg-to-mem copy or clear mem.  */
2405   else if (GET_CODE (dest) == MEM
2406            && (GET_CODE (src) == REG
2407                || src == const0_rtx
2408                || src == CONST0_RTX (DFmode)))
2409     {
2410       rtx addr = XEXP (dest, 0);
2411
2412       if (GET_CODE (addr) == POST_INC)
2413         {
2414           emit_insn (gen_rtx_SET (VOIDmode,
2415                                   change_address (dest, SImode, addr),
2416                                   operand_subword (src, 0, TRUE, mode)));
2417           emit_insn (gen_rtx_SET (VOIDmode,
2418                                   change_address (dest, SImode, addr),
2419                                   operand_subword (src, 1, TRUE, mode)));
2420         }
2421       else
2422         {
2423           /* Make sure we don't get any other addresses with embedded
2424              postincrements.  They should be stopped in
2425              GO_IF_LEGITIMATE_ADDRESS, but we're here for your safety.  */
2426           if (side_effects_p (addr))
2427             fatal_insn ("unexpected side-effects in address", addr);
2428
2429           emit_insn (gen_rtx_SET
2430                      (VOIDmode,
2431                       change_address (dest, SImode, addr),
2432                       operand_subword (src, 0, TRUE, mode)));
2433
2434           emit_insn (gen_rtx_SET
2435                      (VOIDmode,
2436                       change_address (dest, SImode,
2437                                       plus_constant (addr,
2438                                                      UNITS_PER_WORD)),
2439                       operand_subword (src, 1, TRUE, mode)));
2440         }
2441     }
2442
2443   else
2444     internal_error ("Unknown dest");
2445
2446   val = get_insns ();
2447   end_sequence ();
2448   return val;
2449 }
2450
2451 /* The expander for the prologue pattern name.  */
2452
2453 void
2454 cris_expand_prologue (void)
2455 {
2456   int regno;
2457   int size = get_frame_size ();
2458   /* Shorten the used name for readability.  */
2459   int cfoa_size = current_function_outgoing_args_size;
2460   int last_movem_reg = -1;
2461   int framesize = 0;
2462   rtx mem, insn;
2463   int return_address_on_stack = cris_return_address_on_stack ();
2464   int got_really_used = current_function_uses_pic_offset_table;
2465   int n_movem_regs = 0;
2466   int pretend = current_function_pretend_args_size;
2467
2468   /* Don't do anything if no prologues or epilogues are wanted.  */
2469   if (!TARGET_PROLOGUE_EPILOGUE)
2470     return;
2471
2472   CRIS_ASSERT (size >= 0);
2473
2474   /* Align the size to what's best for the CPU model.  */
2475   if (TARGET_STACK_ALIGN)
2476     size = TARGET_ALIGN_BY_32 ? (size + 3) & ~3 : (size + 1) & ~1;
2477
2478   if (pretend)
2479     {
2480       /* See also cris_setup_incoming_varargs where
2481          cfun->machine->stdarg_regs is set.  There are other setters of
2482          current_function_pretend_args_size than stdarg handling, like
2483          for an argument passed with parts in R13 and stack.  We must
2484          not store R13 into the pretend-area for that case, as GCC does
2485          that itself.  "Our" store would be marked as redundant and GCC
2486          will attempt to remove it, which will then be flagged as an
2487          internal error; trying to remove a frame-related insn.  */
2488       int stdarg_regs = cfun->machine->stdarg_regs;
2489
2490       framesize += pretend;
2491
2492       for (regno = CRIS_FIRST_ARG_REG + CRIS_MAX_ARGS_IN_REGS - 1;
2493            stdarg_regs > 0;
2494            regno--, pretend -= 4, stdarg_regs--)
2495         {
2496           insn = emit_insn (gen_rtx_SET (VOIDmode,
2497                                          stack_pointer_rtx,
2498                                          plus_constant (stack_pointer_rtx,
2499                                                         -4)));
2500           /* FIXME: When dwarf2 frame output and unless asynchronous
2501              exceptions, make dwarf2 bundle together all stack
2502              adjustments like it does for registers between stack
2503              adjustments.  */
2504           RTX_FRAME_RELATED_P (insn) = 1;
2505
2506           mem = gen_rtx_MEM (SImode, stack_pointer_rtx);
2507           set_mem_alias_set (mem, get_varargs_alias_set ());
2508           insn = emit_move_insn (mem, gen_rtx_raw_REG (SImode, regno));
2509
2510           /* Note the absence of RTX_FRAME_RELATED_P on the above insn:
2511              the value isn't restored, so we don't want to tell dwarf2
2512              that it's been stored to stack, else EH handling info would
2513              get confused.  */
2514         }
2515
2516       /* For other setters of current_function_pretend_args_size, we
2517          just adjust the stack by leaving the remaining size in
2518          "pretend", handled below.  */
2519     }
2520
2521   /* Save SRP if not a leaf function.  */
2522   if (return_address_on_stack)
2523     {
2524       insn = emit_insn (gen_rtx_SET (VOIDmode,
2525                                      stack_pointer_rtx,
2526                                      plus_constant (stack_pointer_rtx,
2527                                                     -4 - pretend)));
2528       pretend = 0;
2529       RTX_FRAME_RELATED_P (insn) = 1;
2530
2531       mem = gen_rtx_MEM (SImode, stack_pointer_rtx);
2532       set_mem_alias_set (mem, get_frame_alias_set ());
2533       insn = emit_move_insn (mem, gen_rtx_raw_REG (SImode, CRIS_SRP_REGNUM));
2534       RTX_FRAME_RELATED_P (insn) = 1;
2535       framesize += 4;
2536     }
2537
2538   /* Set up the frame pointer, if needed.  */
2539   if (frame_pointer_needed)
2540     {
2541       insn = emit_insn (gen_rtx_SET (VOIDmode,
2542                                      stack_pointer_rtx,
2543                                      plus_constant (stack_pointer_rtx,
2544                                                     -4 - pretend)));
2545       pretend = 0;
2546       RTX_FRAME_RELATED_P (insn) = 1;
2547
2548       mem = gen_rtx_MEM (SImode, stack_pointer_rtx);
2549       set_mem_alias_set (mem, get_frame_alias_set ());
2550       insn = emit_move_insn (mem, frame_pointer_rtx);
2551       RTX_FRAME_RELATED_P (insn) = 1;
2552
2553       insn = emit_move_insn (frame_pointer_rtx, stack_pointer_rtx);
2554       RTX_FRAME_RELATED_P (insn) = 1;
2555
2556       framesize += 4;
2557     }
2558
2559   /* Between frame-pointer and saved registers lie the area for local
2560      variables.  If we get here with "pretended" size remaining, count
2561      it into the general stack size.  */
2562   size += pretend;
2563
2564   /* Get a contiguous sequence of registers, starting with R0, that need
2565      to be saved.  */
2566   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
2567     {
2568       if (cris_reg_saved_in_regsave_area (regno, got_really_used))
2569         {
2570           n_movem_regs++;
2571
2572           /* Check if movem may be used for registers so far.  */
2573           if (regno == last_movem_reg + 1)
2574             /* Yes, update next expected register.  */
2575             last_movem_reg = regno;
2576           else
2577             {
2578               /* We cannot use movem for all registers.  We have to flush
2579                  any movem:ed registers we got so far.  */
2580               if (last_movem_reg != -1)
2581                 {
2582                   int n_saved
2583                     = (n_movem_regs == 1) ? 1 : last_movem_reg + 1;
2584
2585                   /* It is a win to use a side-effect assignment for
2586                      64 <= size <= 128.  But side-effect on movem was
2587                      not usable for CRIS v0..3.  Also only do it if
2588                      side-effects insns are allowed.  */
2589                   if ((last_movem_reg + 1) * 4 + size >= 64
2590                       && (last_movem_reg + 1) * 4 + size <= 128
2591                       && (cris_cpu_version >= CRIS_CPU_SVINTO || n_saved == 1)
2592                       && TARGET_SIDE_EFFECT_PREFIXES)
2593                     {
2594                       mem
2595                         = gen_rtx_MEM (SImode,
2596                                        plus_constant (stack_pointer_rtx,
2597                                                       -(n_saved * 4 + size)));
2598                       set_mem_alias_set (mem, get_frame_alias_set ());
2599                       insn
2600                         = cris_emit_movem_store (mem, GEN_INT (n_saved),
2601                                                  -(n_saved * 4 + size),
2602                                                  true);
2603                     }
2604                   else
2605                     {
2606                       insn
2607                         = gen_rtx_SET (VOIDmode,
2608                                        stack_pointer_rtx,
2609                                        plus_constant (stack_pointer_rtx,
2610                                                       -(n_saved * 4 + size)));
2611                       insn = emit_insn (insn);
2612                       RTX_FRAME_RELATED_P (insn) = 1;
2613
2614                       mem = gen_rtx_MEM (SImode, stack_pointer_rtx);
2615                       set_mem_alias_set (mem, get_frame_alias_set ());
2616                       insn = cris_emit_movem_store (mem, GEN_INT (n_saved),
2617                                                     0, true);
2618                     }
2619
2620                   framesize += n_saved * 4 + size;
2621                   last_movem_reg = -1;
2622                   size = 0;
2623                 }
2624
2625               insn = emit_insn (gen_rtx_SET (VOIDmode,
2626                                              stack_pointer_rtx,
2627                                              plus_constant (stack_pointer_rtx,
2628                                                             -4 - size)));
2629               RTX_FRAME_RELATED_P (insn) = 1;
2630
2631               mem = gen_rtx_MEM (SImode, stack_pointer_rtx);
2632               set_mem_alias_set (mem, get_frame_alias_set ());
2633               insn = emit_move_insn (mem, gen_rtx_raw_REG (SImode, regno));
2634               RTX_FRAME_RELATED_P (insn) = 1;
2635
2636               framesize += 4 + size;
2637               size = 0;
2638             }
2639         }
2640     }
2641
2642   /* Check after, if we could movem all registers.  This is the normal case.  */
2643   if (last_movem_reg != -1)
2644     {
2645       int n_saved
2646         = (n_movem_regs == 1) ? 1 : last_movem_reg + 1;
2647
2648       /* Side-effect on movem was not usable for CRIS v0..3.  Also only
2649          do it if side-effects insns are allowed.  */
2650       if ((last_movem_reg + 1) * 4 + size >= 64
2651           && (last_movem_reg + 1) * 4 + size <= 128
2652           && (cris_cpu_version >= CRIS_CPU_SVINTO || n_saved == 1)
2653           && TARGET_SIDE_EFFECT_PREFIXES)
2654         {
2655           mem
2656             = gen_rtx_MEM (SImode,
2657                            plus_constant (stack_pointer_rtx,
2658                                           -(n_saved * 4 + size)));
2659           set_mem_alias_set (mem, get_frame_alias_set ());
2660           insn = cris_emit_movem_store (mem, GEN_INT (n_saved),
2661                                         -(n_saved * 4 + size), true);
2662         }
2663       else
2664         {
2665           insn
2666             = gen_rtx_SET (VOIDmode,
2667                            stack_pointer_rtx,
2668                            plus_constant (stack_pointer_rtx,
2669                                           -(n_saved * 4 + size)));
2670           insn = emit_insn (insn);
2671           RTX_FRAME_RELATED_P (insn) = 1;
2672
2673           mem = gen_rtx_MEM (SImode, stack_pointer_rtx);
2674           set_mem_alias_set (mem, get_frame_alias_set ());
2675           insn = cris_emit_movem_store (mem, GEN_INT (n_saved), 0, true);
2676         }
2677
2678       framesize += n_saved * 4 + size;
2679       /* We have to put outgoing argument space after regs.  */
2680       if (cfoa_size)
2681         {
2682           insn = emit_insn (gen_rtx_SET (VOIDmode,
2683                                          stack_pointer_rtx,
2684                                          plus_constant (stack_pointer_rtx,
2685                                                         -cfoa_size)));
2686           RTX_FRAME_RELATED_P (insn) = 1;
2687           framesize += cfoa_size;
2688         }
2689     }
2690   else if ((size + cfoa_size) > 0)
2691     {
2692       insn = emit_insn (gen_rtx_SET (VOIDmode,
2693                                      stack_pointer_rtx,
2694                                      plus_constant (stack_pointer_rtx,
2695                                                     -(cfoa_size + size))));
2696       RTX_FRAME_RELATED_P (insn) = 1;
2697       framesize += size + cfoa_size;
2698     }
2699
2700   /* Set up the PIC register, if it is used.  */
2701   if (got_really_used)
2702     {
2703       rtx got
2704         = gen_rtx_UNSPEC (SImode, gen_rtvec (1, const0_rtx), CRIS_UNSPEC_GOT);
2705       emit_move_insn (pic_offset_table_rtx, got);
2706
2707       /* FIXME: This is a cover-up for flow2 messing up; it doesn't
2708          follow exceptional paths and tries to delete the GOT load as
2709          unused, if it isn't used on the non-exceptional paths.  Other
2710          ports have similar or other cover-ups, or plain bugs marking
2711          the GOT register load as maybe-dead.  To see this, remove the
2712          line below and try libsupc++/vec.cc or a trivial
2713          "static void y (); void x () {try {y ();} catch (...) {}}".  */
2714       emit_insn (gen_rtx_USE (VOIDmode, pic_offset_table_rtx));
2715     }
2716
2717   if (cris_max_stackframe && framesize > cris_max_stackframe)
2718     warning (0, "stackframe too big: %d bytes", framesize);
2719 }
2720
2721 /* The expander for the epilogue pattern.  */
2722
2723 void
2724 cris_expand_epilogue (void)
2725 {
2726   int regno;
2727   int size = get_frame_size ();
2728   int last_movem_reg = -1;
2729   int argspace_offset = current_function_outgoing_args_size;
2730   int pretend =  current_function_pretend_args_size;
2731   rtx mem;
2732   bool return_address_on_stack = cris_return_address_on_stack ();
2733   /* A reference may have been optimized out
2734      (like the abort () in fde_split in unwind-dw2-fde.c, at least 3.2.1)
2735      so check that it's still used.  */
2736   int got_really_used = current_function_uses_pic_offset_table;
2737   int n_movem_regs = 0;
2738
2739   if (!TARGET_PROLOGUE_EPILOGUE)
2740     return;
2741
2742   /* Align byte count of stack frame.  */
2743   if (TARGET_STACK_ALIGN)
2744     size = TARGET_ALIGN_BY_32 ? (size + 3) & ~3 : (size + 1) & ~1;
2745
2746   /* Check how many saved regs we can movem.  They start at r0 and must
2747      be contiguous.  */
2748   for (regno = 0;
2749        regno < FIRST_PSEUDO_REGISTER;
2750        regno++)
2751     if (cris_reg_saved_in_regsave_area (regno, got_really_used))
2752       {
2753         n_movem_regs++;
2754
2755         if (regno == last_movem_reg + 1)
2756           last_movem_reg = regno;
2757         else
2758           break;
2759       }
2760
2761   /* If there was only one register that really needed to be saved
2762      through movem, don't use movem.  */
2763   if (n_movem_regs == 1)
2764     last_movem_reg = -1;
2765
2766   /* Now emit "normal" move insns for all regs higher than the movem
2767      regs.  */
2768   for (regno = FIRST_PSEUDO_REGISTER - 1;
2769        regno > last_movem_reg;
2770        regno--)
2771     if (cris_reg_saved_in_regsave_area (regno, got_really_used))
2772       {
2773         if (argspace_offset)
2774           {
2775             /* There is an area for outgoing parameters located before
2776                the saved registers.  We have to adjust for that.  */
2777             emit_insn (gen_rtx_SET (VOIDmode,
2778                                     stack_pointer_rtx,
2779                                     plus_constant (stack_pointer_rtx,
2780                                                    argspace_offset)));
2781             /* Make sure we only do this once.  */
2782             argspace_offset = 0;
2783           }
2784
2785         mem = gen_rtx_MEM (SImode, gen_rtx_POST_INC (SImode,
2786                                                      stack_pointer_rtx));
2787         set_mem_alias_set (mem, get_frame_alias_set ());
2788         emit_move_insn (gen_rtx_raw_REG (SImode, regno), mem);
2789       }
2790
2791   /* If we have any movem-restore, do it now.  */
2792   if (last_movem_reg != -1)
2793     {
2794       if (argspace_offset)
2795         {
2796           emit_insn (gen_rtx_SET (VOIDmode,
2797                                   stack_pointer_rtx,
2798                                   plus_constant (stack_pointer_rtx,
2799                                                  argspace_offset)));
2800           argspace_offset = 0;
2801         }
2802
2803       mem = gen_rtx_MEM (SImode,
2804                          gen_rtx_POST_INC (SImode, stack_pointer_rtx));
2805       set_mem_alias_set (mem, get_frame_alias_set ());
2806       emit_insn (cris_gen_movem_load (mem, GEN_INT (last_movem_reg + 1), 0));
2807     }
2808
2809   /* If we don't clobber all of the allocated stack area (we've already
2810      deallocated saved registers), GCC might want to schedule loads from
2811      the stack to *after* the stack-pointer restore, which introduces an
2812      interrupt race condition.  This happened for the initial-value
2813      SRP-restore for g++.dg/eh/registers1.C (noticed by inspection of
2814      other failure for that test).  It also happened for the stack slot
2815      for the return value in (one version of)
2816      linux/fs/dcache.c:__d_lookup, at least with "-O2
2817      -fno-omit-frame-pointer".  */
2818
2819   /* Restore frame pointer if necessary.  */
2820   if (frame_pointer_needed)
2821     {
2822       emit_insn (gen_cris_frame_deallocated_barrier ());
2823
2824       emit_move_insn (stack_pointer_rtx, frame_pointer_rtx);
2825       mem = gen_rtx_MEM (SImode, gen_rtx_POST_INC (SImode,
2826                                                    stack_pointer_rtx));
2827       set_mem_alias_set (mem, get_frame_alias_set ());
2828       emit_move_insn (frame_pointer_rtx, mem);
2829     }
2830   else if ((size + argspace_offset) != 0)
2831     {
2832       emit_insn (gen_cris_frame_deallocated_barrier ());
2833
2834       /* If there was no frame-pointer to restore sp from, we must
2835          explicitly deallocate local variables.  */
2836
2837       /* Handle space for outgoing parameters that hasn't been handled
2838          yet.  */
2839       size += argspace_offset;
2840
2841       emit_insn (gen_rtx_SET (VOIDmode,
2842                               stack_pointer_rtx,
2843                               plus_constant (stack_pointer_rtx, size)));
2844     }
2845
2846   /* If this function has no pushed register parameters
2847      (stdargs/varargs), and if it is not a leaf function, then we have
2848      the return address on the stack.  */
2849   if (return_address_on_stack && pretend == 0)
2850     {
2851       if (current_function_calls_eh_return)
2852         {
2853           rtx mem;
2854           rtx srpreg = gen_rtx_raw_REG (SImode, CRIS_SRP_REGNUM);
2855           mem = gen_rtx_MEM (SImode,
2856                              gen_rtx_POST_INC (SImode,
2857                                                stack_pointer_rtx));
2858           set_mem_alias_set (mem, get_frame_alias_set ());
2859           emit_move_insn (srpreg, mem);
2860
2861           emit_insn (gen_addsi3 (stack_pointer_rtx,
2862                                  stack_pointer_rtx,
2863                                  gen_rtx_raw_REG (SImode,
2864                                                   CRIS_STACKADJ_REG)));
2865           cris_expand_return (false);
2866         }
2867       else
2868         cris_expand_return (true);
2869
2870       return;
2871     }
2872
2873   /* If we pushed some register parameters, then adjust the stack for
2874      them.  */
2875   if (pretend != 0)
2876     {
2877       /* If SRP is stored on the way, we need to restore it first.  */
2878       if (return_address_on_stack)
2879         {
2880           rtx mem;
2881           rtx srpreg = gen_rtx_raw_REG (SImode, CRIS_SRP_REGNUM);
2882           mem = gen_rtx_MEM (SImode,
2883                              gen_rtx_POST_INC (SImode,
2884                                                stack_pointer_rtx));
2885           set_mem_alias_set (mem, get_frame_alias_set ());
2886           emit_move_insn (srpreg, mem);
2887         }
2888
2889       emit_insn (gen_rtx_SET (VOIDmode,
2890                               stack_pointer_rtx,
2891                               plus_constant (stack_pointer_rtx, pretend)));
2892     }
2893
2894   /* Perform the "physical" unwinding that the EH machinery calculated.  */
2895   if (current_function_calls_eh_return)
2896     emit_insn (gen_addsi3 (stack_pointer_rtx,
2897                            stack_pointer_rtx,
2898                            gen_rtx_raw_REG (SImode,
2899                                             CRIS_STACKADJ_REG)));
2900   cris_expand_return (false);
2901 }
2902
2903 /* Worker function for generating movem from mem for load_multiple.  */
2904
2905 rtx
2906 cris_gen_movem_load (rtx src, rtx nregs_rtx, int nprefix)
2907 {
2908   int nregs = INTVAL (nregs_rtx);
2909   rtvec vec;
2910   int eltno = 1;
2911   int i;
2912   rtx srcreg = XEXP (src, 0);
2913   unsigned int regno = nregs - 1;
2914   int regno_inc = -1;
2915
2916   if (GET_CODE (srcreg) == POST_INC)
2917     srcreg = XEXP (srcreg, 0);
2918
2919   CRIS_ASSERT (REG_P (srcreg));
2920
2921   /* Don't use movem for just one insn.  The insns are equivalent except
2922      for the pipeline hazard (on v32); movem does not forward the loaded
2923      registers so there's a three cycles penalty for their use.  */
2924   if (nregs == 1)
2925     return gen_movsi (gen_rtx_REG (SImode, 0), src);
2926
2927   vec = rtvec_alloc (nprefix + nregs
2928                      + (GET_CODE (XEXP (src, 0)) == POST_INC));
2929
2930   if (GET_CODE (XEXP (src, 0)) == POST_INC)
2931     {
2932       RTVEC_ELT (vec, nprefix + 1)
2933         = gen_rtx_SET (VOIDmode, srcreg, plus_constant (srcreg, nregs * 4));
2934       eltno++;
2935     }
2936
2937   src = replace_equiv_address (src, srcreg);
2938   RTVEC_ELT (vec, nprefix)
2939     = gen_rtx_SET (VOIDmode, gen_rtx_REG (SImode, regno), src);
2940   regno += regno_inc;
2941
2942   for (i = 1; i < nregs; i++, eltno++)
2943     {
2944       RTVEC_ELT (vec, nprefix + eltno)
2945         = gen_rtx_SET (VOIDmode, gen_rtx_REG (SImode, regno),
2946                        adjust_address_nv (src, SImode, i * 4));
2947       regno += regno_inc;
2948     }
2949
2950   return gen_rtx_PARALLEL (VOIDmode, vec);
2951 }
2952
2953 /* Worker function for generating movem to mem.  If FRAME_RELATED, notes
2954    are added that the dwarf2 machinery understands.  */
2955
2956 rtx
2957 cris_emit_movem_store (rtx dest, rtx nregs_rtx, int increment,
2958                        bool frame_related)
2959 {
2960   int nregs = INTVAL (nregs_rtx);
2961   rtvec vec;
2962   int eltno = 1;
2963   int i;
2964   rtx insn;
2965   rtx destreg = XEXP (dest, 0);
2966   unsigned int regno = nregs - 1;
2967   int regno_inc = -1;
2968
2969   if (GET_CODE (destreg) == POST_INC)
2970     increment += nregs * 4;
2971
2972   if (GET_CODE (destreg) == POST_INC || GET_CODE (destreg) == PLUS)
2973     destreg = XEXP (destreg, 0);
2974
2975   CRIS_ASSERT (REG_P (destreg));
2976
2977   /* Don't use movem for just one insn.  The insns are equivalent except
2978      for the pipeline hazard (on v32); movem does not forward the loaded
2979      registers so there's a three cycles penalty for use.  */
2980   if (nregs == 1)
2981     {
2982       rtx mov = gen_rtx_SET (VOIDmode, dest, gen_rtx_REG (SImode, 0));
2983
2984       if (increment == 0)
2985         {
2986           insn = emit_insn (mov);
2987           if (frame_related)
2988             RTX_FRAME_RELATED_P (insn) = 1;
2989           return insn;
2990         }
2991
2992       /* If there was a request for a side-effect, create the ordinary
2993          parallel.  */
2994       vec = rtvec_alloc (2);
2995
2996       RTVEC_ELT (vec, 0) = mov;
2997       RTVEC_ELT (vec, 1) = gen_rtx_SET (VOIDmode, destreg,
2998                                         plus_constant (destreg, increment));
2999       if (frame_related)
3000         {
3001           RTX_FRAME_RELATED_P (mov) = 1;
3002           RTX_FRAME_RELATED_P (RTVEC_ELT (vec, 1)) = 1;
3003         }
3004     }
3005   else
3006     {
3007       vec = rtvec_alloc (nregs + (increment != 0 ? 1 : 0));
3008       RTVEC_ELT (vec, 0)
3009         = gen_rtx_SET (VOIDmode,
3010                        replace_equiv_address (dest,
3011                                               plus_constant (destreg,
3012                                                              increment)),
3013                        gen_rtx_REG (SImode, regno));
3014       regno += regno_inc;
3015
3016       /* The dwarf2 info wants this mark on each component in a parallel
3017          that's part of the prologue (though it's optional on the first
3018          component).  */
3019       if (frame_related)
3020         RTX_FRAME_RELATED_P (RTVEC_ELT (vec, 0)) = 1;
3021
3022       if (increment != 0)
3023         {
3024           RTVEC_ELT (vec, 1)
3025             = gen_rtx_SET (VOIDmode, destreg,
3026                            plus_constant (destreg,
3027                                           increment != 0
3028                                           ? increment : nregs * 4));
3029           eltno++;
3030
3031           if (frame_related)
3032             RTX_FRAME_RELATED_P (RTVEC_ELT (vec, 1)) = 1;
3033
3034           /* Don't call adjust_address_nv on a post-incremented address if
3035              we can help it.  */
3036           if (GET_CODE (XEXP (dest, 0)) == POST_INC)
3037             dest = replace_equiv_address (dest, destreg);
3038         }
3039
3040       for (i = 1; i < nregs; i++, eltno++)
3041         {
3042           RTVEC_ELT (vec, eltno)
3043             = gen_rtx_SET (VOIDmode, adjust_address_nv (dest, SImode, i * 4),
3044                            gen_rtx_REG (SImode, regno));
3045           if (frame_related)
3046             RTX_FRAME_RELATED_P (RTVEC_ELT (vec, eltno)) = 1;
3047           regno += regno_inc;
3048         }
3049     }
3050
3051   insn = emit_insn (gen_rtx_PARALLEL (VOIDmode, vec));
3052
3053   /* Because dwarf2out.c handles the insns in a parallel as a sequence,
3054      we need to keep the stack adjustment separate, after the
3055      MEM-setters.  Else the stack-adjustment in the second component of
3056      the parallel would be mishandled; the offsets for the SETs that
3057      follow it would be wrong.  We prepare for this by adding a
3058      REG_FRAME_RELATED_EXPR with the MEM-setting parts in a SEQUENCE
3059      followed by the increment.  Note that we have FRAME_RELATED_P on
3060      all the SETs, including the original stack adjustment SET in the
3061      parallel.  */
3062   if (frame_related)
3063     {
3064       if (increment != 0)
3065         {
3066           rtx seq = gen_rtx_SEQUENCE (VOIDmode, rtvec_alloc (nregs + 1));
3067           XVECEXP (seq, 0, 0) = XVECEXP (PATTERN (insn), 0, 0);
3068           for (i = 1; i < nregs; i++)
3069             XVECEXP (seq, 0, i) = XVECEXP (PATTERN (insn), 0, i + 1);
3070           XVECEXP (seq, 0, nregs) = XVECEXP (PATTERN (insn), 0, 1);
3071           REG_NOTES (insn)
3072             = gen_rtx_EXPR_LIST (REG_FRAME_RELATED_EXPR, seq,
3073                                  REG_NOTES (insn));
3074         }
3075
3076       RTX_FRAME_RELATED_P (insn) = 1;
3077     }
3078
3079   return insn;
3080 }
3081
3082 /* Use from within code, from e.g. PRINT_OPERAND and
3083    PRINT_OPERAND_ADDRESS.  Macros used in output_addr_const need to emit
3084    different things depending on whether code operand or constant is
3085    emitted.  */
3086
3087 static void
3088 cris_output_addr_const (FILE *file, rtx x)
3089 {
3090   in_code++;
3091   output_addr_const (file, x);
3092   in_code--;
3093 }
3094
3095 /* Worker function for ASM_OUTPUT_SYMBOL_REF.  */
3096
3097 void
3098 cris_asm_output_symbol_ref (FILE *file, rtx x)
3099 {
3100   if (flag_pic && in_code > 0)
3101     {
3102       const char *origstr = XSTR (x, 0);
3103       const char *str;
3104
3105       str = (* targetm.strip_name_encoding) (origstr);
3106
3107       if (cris_gotless_symbol (x))
3108         {
3109           if (! cris_pic_sympart_only)
3110             fprintf (file, "$%s+", reg_names [PIC_OFFSET_TABLE_REGNUM]);
3111           assemble_name (file, str);
3112           fprintf (file, ":GOTOFF");
3113         }
3114       else if (cris_got_symbol (x))
3115         {
3116           CRIS_ASSERT (!cris_pic_sympart_only);
3117
3118           fprintf (file, "[$%s+", reg_names [PIC_OFFSET_TABLE_REGNUM]);
3119           assemble_name (file, XSTR (x, 0));
3120
3121           if (flag_pic == 1)
3122             fprintf (file, ":GOT16]");
3123           else
3124             fprintf (file, ":GOT]");
3125         }
3126       else
3127         LOSE_AND_RETURN ("unexpected PIC symbol", x);
3128
3129       /* Sanity check.  */
3130       if (! current_function_uses_pic_offset_table)
3131         output_operand_lossage ("PIC register isn't set up");
3132     }
3133   else
3134     assemble_name (file, XSTR (x, 0));
3135 }
3136
3137 /* Worker function for ASM_OUTPUT_LABEL_REF.  */
3138
3139 void
3140 cris_asm_output_label_ref (FILE *file, char *buf)
3141 {
3142   if (flag_pic && in_code > 0)
3143     {
3144       if (! cris_pic_sympart_only)
3145         fprintf (file, "$%s+", reg_names [PIC_OFFSET_TABLE_REGNUM]);
3146       assemble_name (file, buf);
3147
3148       fprintf (file, ":GOTOFF");
3149
3150       /* Sanity check.  */
3151       if (! current_function_uses_pic_offset_table)
3152         internal_error ("emitting PIC operand, but PIC register isn't set up");
3153     }
3154   else
3155     assemble_name (file, buf);
3156 }
3157
3158 /* Worker function for OUTPUT_ADDR_CONST_EXTRA.  */
3159
3160 bool
3161 cris_output_addr_const_extra (FILE *file, rtx x)
3162 {
3163   switch (GET_CODE (x))
3164     {
3165       const char *origstr;
3166       const char *str;
3167
3168     case UNSPEC:
3169       ASSERT_PLT_UNSPEC (x);
3170       x = XVECEXP (x, 0, 0);
3171       origstr = XSTR (x, 0);
3172       str = (* targetm.strip_name_encoding) (origstr);
3173       if (cris_pic_sympart_only)
3174         {
3175           assemble_name (file, str);
3176           fprintf (file, ":PLTG");
3177         }
3178       else
3179         {
3180           CRIS_ASSERT (!TARGET_AVOID_GOTPLT);
3181
3182           fprintf (file, "[$%s+", reg_names [PIC_OFFSET_TABLE_REGNUM]);
3183           assemble_name (file, XSTR (x, 0));
3184
3185           if (flag_pic == 1)
3186             fprintf (file, ":GOTPLT16]");
3187           else
3188             fprintf (file, ":GOTPLT]");
3189         }
3190       return true;
3191
3192     default:
3193       return false;
3194     }
3195 }
3196
3197 /* Worker function for TARGET_STRUCT_VALUE_RTX.  */
3198
3199 static rtx
3200 cris_struct_value_rtx (tree fntype ATTRIBUTE_UNUSED,
3201                        int incoming ATTRIBUTE_UNUSED)
3202 {
3203   return gen_rtx_REG (Pmode, CRIS_STRUCT_VALUE_REGNUM);
3204 }
3205
3206 /* Worker function for TARGET_SETUP_INCOMING_VARARGS.  */
3207
3208 static void
3209 cris_setup_incoming_varargs (CUMULATIVE_ARGS *ca,
3210                              enum machine_mode mode ATTRIBUTE_UNUSED,
3211                              tree type ATTRIBUTE_UNUSED,
3212                              int *pretend_arg_size,
3213                              int second_time)
3214 {
3215   if (ca->regs < CRIS_MAX_ARGS_IN_REGS)
3216     {
3217       int stdarg_regs = CRIS_MAX_ARGS_IN_REGS - ca->regs;
3218       cfun->machine->stdarg_regs = stdarg_regs;
3219       *pretend_arg_size = stdarg_regs * 4;
3220     }
3221
3222   if (TARGET_PDEBUG)
3223     fprintf (asm_out_file,
3224              "\n; VA:: ANSI: %d args before, anon @ #%d, %dtime\n",
3225              ca->regs, *pretend_arg_size, second_time);
3226 }
3227
3228 /* Return true if TYPE must be passed by invisible reference.
3229    For cris, we pass <= 8 bytes by value, others by reference.  */
3230
3231 static bool
3232 cris_pass_by_reference (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED,
3233                         enum machine_mode mode, tree type,
3234                         bool named ATTRIBUTE_UNUSED)
3235 {
3236   return (targetm.calls.must_pass_in_stack (mode, type)
3237           || CRIS_FUNCTION_ARG_SIZE (mode, type) > 8);
3238 }
3239
3240
3241 static int
3242 cris_arg_partial_bytes (CUMULATIVE_ARGS *ca, enum machine_mode mode,
3243                         tree type, bool named ATTRIBUTE_UNUSED)
3244 {
3245   if (ca->regs == CRIS_MAX_ARGS_IN_REGS - 1
3246       && !targetm.calls.must_pass_in_stack (mode, type)
3247       && CRIS_FUNCTION_ARG_SIZE (mode, type) > 4
3248       && CRIS_FUNCTION_ARG_SIZE (mode, type) <= 8)
3249     return UNITS_PER_WORD;
3250   else
3251     return 0;
3252 }
3253
3254 /* Worker function for TARGET_MD_ASM_CLOBBERS.  */
3255
3256 static tree
3257 cris_md_asm_clobbers (tree outputs, tree inputs, tree clobbers)
3258 {
3259   HARD_REG_SET mof_set;
3260   tree t;
3261
3262   CLEAR_HARD_REG_SET (mof_set);
3263   SET_HARD_REG_BIT (mof_set, CRIS_MOF_REGNUM);
3264
3265   for (t = outputs; t != NULL; t = TREE_CHAIN (t))
3266     {
3267       tree val = TREE_VALUE (t);
3268
3269       /* The constraint letter for the singleton register class of MOF
3270          is 'h'.  If it's mentioned in the constraints, the asm is
3271          MOF-aware and adding it to the clobbers would cause it to have
3272          impossible constraints.  */
3273       if (strchr (TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t))),
3274                   'h') != NULL
3275           || decl_overlaps_hard_reg_set_p (val, mof_set))
3276         return clobbers;
3277     }
3278
3279   for (t = inputs; t != NULL; t = TREE_CHAIN (t))
3280     {
3281       tree val = TREE_VALUE (t);
3282
3283       if (strchr (TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t))),
3284                   'h') != NULL
3285           || decl_overlaps_hard_reg_set_p (val, mof_set))
3286         return clobbers;
3287     }
3288
3289   return tree_cons (NULL_TREE,
3290                     build_string (strlen (reg_names[CRIS_MOF_REGNUM]),
3291                                   reg_names[CRIS_MOF_REGNUM]),
3292                     clobbers);
3293 }
3294
3295 #if 0
3296 /* Various small functions to replace macros.  Only called from a
3297    debugger.  They might collide with gcc functions or system functions,
3298    so only emit them when '#if 1' above.  */
3299
3300 enum rtx_code Get_code (rtx);
3301
3302 enum rtx_code
3303 Get_code (rtx x)
3304 {
3305   return GET_CODE (x);
3306 }
3307
3308 const char *Get_mode (rtx);
3309
3310 const char *
3311 Get_mode (rtx x)
3312 {
3313   return GET_MODE_NAME (GET_MODE (x));
3314 }
3315
3316 rtx Xexp (rtx, int);
3317
3318 rtx
3319 Xexp (rtx x, int n)
3320 {
3321   return XEXP (x, n);
3322 }
3323
3324 rtx Xvecexp (rtx, int, int);
3325
3326 rtx
3327 Xvecexp (rtx x, int n, int m)
3328 {
3329   return XVECEXP (x, n, m);
3330 }
3331
3332 int Get_rtx_len (rtx);
3333
3334 int
3335 Get_rtx_len (rtx x)
3336 {
3337   return GET_RTX_LENGTH (GET_CODE (x));
3338 }
3339
3340 /* Use upper-case to distinguish from local variables that are sometimes
3341    called next_insn and prev_insn.  */
3342
3343 rtx Next_insn (rtx);
3344
3345 rtx
3346 Next_insn (rtx insn)
3347 {
3348   return NEXT_INSN (insn);
3349 }
3350
3351 rtx Prev_insn (rtx);
3352
3353 rtx
3354 Prev_insn (rtx insn)
3355 {
3356   return PREV_INSN (insn);
3357 }
3358 #endif
3359
3360 #include "gt-cris.h"
3361
3362 /*
3363  * Local variables:
3364  * eval: (c-set-style "gnu")
3365  * indent-tabs-mode: t
3366  * End:
3367  */