OSDN Git Service

a66eb3cd162cdb0150d18965bdc0efb416dd36ae
[pf3gnuchains/gcc-fork.git] / gcc / config / mcore / mcore.c
1 /* Output routines for Motorola MCore processor
2    Copyright (C) 1993, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008,
3    2009, 2010 Free Software Foundation, Inc.
4
5    This file is part of GCC.
6
7    GCC is free software; you can redistribute it and/or modify it
8    under the terms of the GNU General Public License as published
9    by the Free Software Foundation; either version 3, or (at your
10    option) any later version.
11
12    GCC is distributed in the hope that it will be useful, but WITHOUT
13    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
14    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
15    License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with GCC; see the file COPYING3.  If not see
19    <http://www.gnu.org/licenses/>.  */
20
21 #include "config.h"
22 #include "system.h"
23 #include "coretypes.h"
24 #include "tm.h"
25 #include "rtl.h"
26 #include "tree.h"
27 #include "tm_p.h"
28 #include "assert.h"
29 #include "mcore.h"
30 #include "regs.h"
31 #include "hard-reg-set.h"
32 #include "insn-config.h"
33 #include "conditions.h"
34 #include "output.h"
35 #include "insn-attr.h"
36 #include "flags.h"
37 #include "obstack.h"
38 #include "expr.h"
39 #include "reload.h"
40 #include "recog.h"
41 #include "function.h"
42 #include "ggc.h"
43 #include "diagnostic-core.h"
44 #include "target.h"
45 #include "target-def.h"
46 #include "df.h"
47
48 /* For dumping information about frame sizes.  */
49 char * mcore_current_function_name = 0;
50 long   mcore_current_compilation_timestamp = 0;
51
52 /* Global variables for machine-dependent things.  */
53
54 /* Provides the class number of the smallest class containing
55    reg number.  */
56 const enum reg_class regno_reg_class[FIRST_PSEUDO_REGISTER] =
57 {
58   GENERAL_REGS, ONLYR1_REGS,  LRW_REGS,     LRW_REGS,
59   LRW_REGS,     LRW_REGS,     LRW_REGS,     LRW_REGS,
60   LRW_REGS,     LRW_REGS,     LRW_REGS,     LRW_REGS,
61   LRW_REGS,     LRW_REGS,     LRW_REGS,     GENERAL_REGS,
62   GENERAL_REGS, C_REGS,       NO_REGS,      NO_REGS,
63 };
64
65 /* Provide reg_class from a letter such as appears in the machine
66    description.  */
67 const enum reg_class reg_class_from_letter[] =
68 {
69   /* a */ LRW_REGS, /* b */ ONLYR1_REGS, /* c */ C_REGS,  /* d */ NO_REGS,
70   /* e */ NO_REGS, /* f */ NO_REGS, /* g */ NO_REGS, /* h */ NO_REGS,
71   /* i */ NO_REGS, /* j */ NO_REGS, /* k */ NO_REGS, /* l */ NO_REGS,
72   /* m */ NO_REGS, /* n */ NO_REGS, /* o */ NO_REGS, /* p */ NO_REGS,
73   /* q */ NO_REGS, /* r */ GENERAL_REGS, /* s */ NO_REGS, /* t */ NO_REGS,
74   /* u */ NO_REGS, /* v */ NO_REGS, /* w */ NO_REGS, /* x */ ALL_REGS,
75   /* y */ NO_REGS, /* z */ NO_REGS
76 };
77
78 struct mcore_frame
79 {
80   int arg_size;                 /* Stdarg spills (bytes).  */
81   int reg_size;                 /* Non-volatile reg saves (bytes).  */
82   int reg_mask;                 /* Non-volatile reg saves.  */
83   int local_size;               /* Locals.  */
84   int outbound_size;            /* Arg overflow on calls out.  */
85   int pad_outbound;
86   int pad_local;
87   int pad_reg;
88   /* Describe the steps we'll use to grow it.  */
89 #define MAX_STACK_GROWS 4       /* Gives us some spare space.  */
90   int growth[MAX_STACK_GROWS];
91   int arg_offset;
92   int reg_offset;
93   int reg_growth;
94   int local_growth;
95 };
96
97 typedef enum
98 {
99   COND_NO,
100   COND_MOV_INSN,
101   COND_CLR_INSN,
102   COND_INC_INSN,
103   COND_DEC_INSN,
104   COND_BRANCH_INSN
105 }
106 cond_type;
107
108 static void       output_stack_adjust           (int, int);
109 static int        calc_live_regs                (int *);
110 static int        try_constant_tricks           (long, HOST_WIDE_INT *, HOST_WIDE_INT *);
111 static const char *     output_inline_const     (enum machine_mode, rtx *);
112 static void       layout_mcore_frame            (struct mcore_frame *);
113 static void       mcore_setup_incoming_varargs  (CUMULATIVE_ARGS *, enum machine_mode, tree, int *, int);
114 static cond_type  is_cond_candidate             (rtx);
115 static rtx        emit_new_cond_insn            (rtx, int);
116 static rtx        conditionalize_block          (rtx);
117 static void       conditionalize_optimization   (void);
118 static void       mcore_reorg                   (void);
119 static rtx        handle_structs_in_regs        (enum machine_mode, const_tree, int);
120 static void       mcore_mark_dllexport          (tree);
121 static void       mcore_mark_dllimport          (tree);
122 static int        mcore_dllexport_p             (tree);
123 static int        mcore_dllimport_p             (tree);
124 static tree       mcore_handle_naked_attribute  (tree *, tree, tree, int, bool *);
125 #ifdef OBJECT_FORMAT_ELF
126 static void       mcore_asm_named_section       (const char *,
127                                                  unsigned int, tree);
128 #endif
129 static void       mcore_print_operand           (FILE *, rtx, int);
130 static void       mcore_print_operand_address   (FILE *, rtx);
131 static bool       mcore_print_operand_punct_valid_p (unsigned char code);
132 static void       mcore_unique_section          (tree, int);
133 static void mcore_encode_section_info           (tree, rtx, int);
134 static const char *mcore_strip_name_encoding    (const char *);
135 static int        mcore_const_costs             (rtx, RTX_CODE);
136 static int        mcore_and_cost                (rtx);
137 static int        mcore_ior_cost                (rtx);
138 static bool       mcore_rtx_costs               (rtx, int, int, int *, bool);
139 static void       mcore_external_libcall        (rtx);
140 static bool       mcore_return_in_memory        (const_tree, const_tree);
141 static int        mcore_arg_partial_bytes       (CUMULATIVE_ARGS *,
142                                                  enum machine_mode,
143                                                  tree, bool);
144 static rtx        mcore_function_arg            (CUMULATIVE_ARGS *,
145                                                  enum machine_mode,
146                                                  const_tree, bool);
147 static void       mcore_function_arg_advance    (CUMULATIVE_ARGS *,
148                                                  enum machine_mode,
149                                                  const_tree, bool);
150 static unsigned int mcore_function_arg_boundary (enum machine_mode,
151                                                  const_tree);
152 static void       mcore_asm_trampoline_template (FILE *);
153 static void       mcore_trampoline_init         (rtx, tree, rtx);
154 static void       mcore_option_override         (void);
155 \f
156 /* MCore specific attributes.  */
157
158 static const struct attribute_spec mcore_attribute_table[] =
159 {
160   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
161   { "dllexport", 0, 0, true,  false, false, NULL },
162   { "dllimport", 0, 0, true,  false, false, NULL },
163   { "naked",     0, 0, true,  false, false, mcore_handle_naked_attribute },
164   { NULL,        0, 0, false, false, false, NULL }
165 };
166
167 /* What options are we going to default to specific settings when
168    -O* happens; the user can subsequently override these settings.
169   
170    Omitting the frame pointer is a very good idea on the MCore.
171    Scheduling isn't worth anything on the current MCore implementation.  */
172
173 static const struct default_options mcore_option_optimization_table[] =
174   {
175     { OPT_LEVELS_1_PLUS, OPT_ffunction_cse, NULL, 0 },
176     { OPT_LEVELS_1_PLUS, OPT_fomit_frame_pointer, NULL, 1 },
177     { OPT_LEVELS_ALL, OPT_fcaller_saves, NULL, 0 },
178     { OPT_LEVELS_ALL, OPT_fschedule_insns, NULL, 0 },
179     { OPT_LEVELS_ALL, OPT_fschedule_insns2, NULL, 0 },
180     { OPT_LEVELS_SIZE, OPT_mhardlit, NULL, 0 },
181     { OPT_LEVELS_NONE, 0, NULL, 0 }
182   };
183 \f
184 /* Initialize the GCC target structure.  */
185 #undef  TARGET_ASM_EXTERNAL_LIBCALL
186 #define TARGET_ASM_EXTERNAL_LIBCALL     mcore_external_libcall
187
188 #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
189 #undef  TARGET_MERGE_DECL_ATTRIBUTES
190 #define TARGET_MERGE_DECL_ATTRIBUTES    merge_dllimport_decl_attributes
191 #endif
192
193 #ifdef OBJECT_FORMAT_ELF
194 #undef  TARGET_ASM_UNALIGNED_HI_OP
195 #define TARGET_ASM_UNALIGNED_HI_OP "\t.short\t"
196 #undef  TARGET_ASM_UNALIGNED_SI_OP
197 #define TARGET_ASM_UNALIGNED_SI_OP "\t.long\t"
198 #endif
199
200 #undef  TARGET_PRINT_OPERAND
201 #define TARGET_PRINT_OPERAND            mcore_print_operand
202 #undef  TARGET_PRINT_OPERAND_ADDRESS
203 #define TARGET_PRINT_OPERAND_ADDRESS    mcore_print_operand_address
204 #undef  TARGET_PRINT_OPERAND_PUNCT_VALID_P
205 #define TARGET_PRINT_OPERAND_PUNCT_VALID_P mcore_print_operand_punct_valid_p
206
207 #undef  TARGET_ATTRIBUTE_TABLE
208 #define TARGET_ATTRIBUTE_TABLE          mcore_attribute_table
209 #undef  TARGET_ASM_UNIQUE_SECTION
210 #define TARGET_ASM_UNIQUE_SECTION       mcore_unique_section
211 #undef  TARGET_ASM_FUNCTION_RODATA_SECTION
212 #define TARGET_ASM_FUNCTION_RODATA_SECTION default_no_function_rodata_section
213 #undef  TARGET_DEFAULT_TARGET_FLAGS
214 #define TARGET_DEFAULT_TARGET_FLAGS     TARGET_DEFAULT
215 #undef  TARGET_ENCODE_SECTION_INFO
216 #define TARGET_ENCODE_SECTION_INFO      mcore_encode_section_info
217 #undef  TARGET_STRIP_NAME_ENCODING
218 #define TARGET_STRIP_NAME_ENCODING      mcore_strip_name_encoding
219 #undef  TARGET_RTX_COSTS
220 #define TARGET_RTX_COSTS                mcore_rtx_costs
221 #undef  TARGET_ADDRESS_COST
222 #define TARGET_ADDRESS_COST             hook_int_rtx_bool_0
223 #undef  TARGET_MACHINE_DEPENDENT_REORG
224 #define TARGET_MACHINE_DEPENDENT_REORG  mcore_reorg
225
226 #undef  TARGET_PROMOTE_FUNCTION_MODE
227 #define TARGET_PROMOTE_FUNCTION_MODE    default_promote_function_mode_always_promote
228 #undef  TARGET_PROMOTE_PROTOTYPES
229 #define TARGET_PROMOTE_PROTOTYPES       hook_bool_const_tree_true
230
231 #undef  TARGET_RETURN_IN_MEMORY
232 #define TARGET_RETURN_IN_MEMORY         mcore_return_in_memory
233 #undef  TARGET_MUST_PASS_IN_STACK
234 #define TARGET_MUST_PASS_IN_STACK       must_pass_in_stack_var_size
235 #undef  TARGET_PASS_BY_REFERENCE
236 #define TARGET_PASS_BY_REFERENCE  hook_pass_by_reference_must_pass_in_stack
237 #undef  TARGET_ARG_PARTIAL_BYTES
238 #define TARGET_ARG_PARTIAL_BYTES        mcore_arg_partial_bytes
239 #undef  TARGET_FUNCTION_ARG
240 #define TARGET_FUNCTION_ARG             mcore_function_arg
241 #undef  TARGET_FUNCTION_ARG_ADVANCE
242 #define TARGET_FUNCTION_ARG_ADVANCE     mcore_function_arg_advance
243 #undef  TARGET_FUNCTION_ARG_BOUNDARY
244 #define TARGET_FUNCTION_ARG_BOUNDARY    mcore_function_arg_boundary
245
246 #undef  TARGET_SETUP_INCOMING_VARARGS
247 #define TARGET_SETUP_INCOMING_VARARGS   mcore_setup_incoming_varargs
248
249 #undef  TARGET_ASM_TRAMPOLINE_TEMPLATE
250 #define TARGET_ASM_TRAMPOLINE_TEMPLATE  mcore_asm_trampoline_template
251 #undef  TARGET_TRAMPOLINE_INIT
252 #define TARGET_TRAMPOLINE_INIT          mcore_trampoline_init
253
254 #undef TARGET_OPTION_OVERRIDE
255 #define TARGET_OPTION_OVERRIDE mcore_option_override
256 #undef TARGET_OPTION_OPTIMIZATION_TABLE
257 #define TARGET_OPTION_OPTIMIZATION_TABLE mcore_option_optimization_table
258
259 #undef TARGET_EXCEPT_UNWIND_INFO
260 #define TARGET_EXCEPT_UNWIND_INFO sjlj_except_unwind_info
261
262 struct gcc_target targetm = TARGET_INITIALIZER;
263 \f
264 /* Adjust the stack and return the number of bytes taken to do it.  */
265 static void
266 output_stack_adjust (int direction, int size)
267 {
268   /* If extending stack a lot, we do it incrementally.  */
269   if (direction < 0 && size > mcore_stack_increment && mcore_stack_increment > 0)
270     {
271       rtx tmp = gen_rtx_REG (SImode, 1);
272       rtx memref;
273
274       emit_insn (gen_movsi (tmp, GEN_INT (mcore_stack_increment)));
275       do
276         {
277           emit_insn (gen_subsi3 (stack_pointer_rtx, stack_pointer_rtx, tmp));
278           memref = gen_rtx_MEM (SImode, stack_pointer_rtx);
279           MEM_VOLATILE_P (memref) = 1;
280           emit_insn (gen_movsi (memref, stack_pointer_rtx));
281           size -= mcore_stack_increment;
282         }
283       while (size > mcore_stack_increment);
284
285       /* SIZE is now the residual for the last adjustment,
286          which doesn't require a probe.  */
287     }
288
289   if (size)
290     {
291       rtx insn;
292       rtx val = GEN_INT (size);
293
294       if (size > 32)
295         {
296           rtx nval = gen_rtx_REG (SImode, 1);
297           emit_insn (gen_movsi (nval, val));
298           val = nval;
299         }
300       
301       if (direction > 0)
302         insn = gen_addsi3 (stack_pointer_rtx, stack_pointer_rtx, val);
303       else
304         insn = gen_subsi3 (stack_pointer_rtx, stack_pointer_rtx, val);
305       
306       emit_insn (insn);
307     }
308 }
309
310 /* Work out the registers which need to be saved,
311    both as a mask and a count.  */
312
313 static int
314 calc_live_regs (int * count)
315 {
316   int reg;
317   int live_regs_mask = 0;
318   
319   * count = 0;
320
321   for (reg = 0; reg < FIRST_PSEUDO_REGISTER; reg++)
322     {
323       if (df_regs_ever_live_p (reg) && !call_used_regs[reg])
324         {
325           (*count)++;
326           live_regs_mask |= (1 << reg);
327         }
328     }
329
330   return live_regs_mask;
331 }
332
333 /* Print the operand address in x to the stream.  */
334
335 static void
336 mcore_print_operand_address (FILE * stream, rtx x)
337 {
338   switch (GET_CODE (x))
339     {
340     case REG:
341       fprintf (stream, "(%s)", reg_names[REGNO (x)]);
342       break;
343       
344     case PLUS:
345       {
346         rtx base = XEXP (x, 0);
347         rtx index = XEXP (x, 1);
348
349         if (GET_CODE (base) != REG)
350           {
351             /* Ensure that BASE is a register (one of them must be).  */
352             rtx temp = base;
353             base = index;
354             index = temp;
355           }
356
357         switch (GET_CODE (index))
358           {
359           case CONST_INT:
360             fprintf (stream, "(%s," HOST_WIDE_INT_PRINT_DEC ")",
361                      reg_names[REGNO(base)], INTVAL (index));
362             break;
363
364           default:
365             gcc_unreachable ();
366           }
367       }
368
369       break;
370
371     default:
372       output_addr_const (stream, x);
373       break;
374     }
375 }
376
377 static bool
378 mcore_print_operand_punct_valid_p (unsigned char code)
379 {
380   return (code == '.' || code == '#' || code == '*' || code == '^'
381           || code == '!');
382 }
383
384 /* Print operand x (an rtx) in assembler syntax to file stream
385    according to modifier code.
386
387    'R'  print the next register or memory location along, i.e. the lsw in
388         a double word value
389    'O'  print a constant without the #
390    'M'  print a constant as its negative
391    'P'  print log2 of a power of two
392    'Q'  print log2 of an inverse of a power of two
393    'U'  print register for ldm/stm instruction
394    'X'  print byte number for xtrbN instruction.  */
395
396 static void
397 mcore_print_operand (FILE * stream, rtx x, int code)
398 {
399   switch (code)
400     {
401     case 'N':
402       if (INTVAL(x) == -1)
403         fprintf (asm_out_file, "32");
404       else
405         fprintf (asm_out_file, "%d", exact_log2 (INTVAL (x) + 1));
406       break;
407     case 'P':
408       fprintf (asm_out_file, "%d", exact_log2 (INTVAL (x) & 0xffffffff));
409       break;
410     case 'Q':
411       fprintf (asm_out_file, "%d", exact_log2 (~INTVAL (x)));
412       break;
413     case 'O':
414       fprintf (asm_out_file, HOST_WIDE_INT_PRINT_DEC, INTVAL (x));
415       break;
416     case 'M':
417       fprintf (asm_out_file, HOST_WIDE_INT_PRINT_DEC, - INTVAL (x));
418       break;
419     case 'R':
420       /* Next location along in memory or register.  */
421       switch (GET_CODE (x))
422         {
423         case REG:
424           fputs (reg_names[REGNO (x) + 1], (stream));
425           break;
426         case MEM:
427           mcore_print_operand_address
428             (stream, XEXP (adjust_address (x, SImode, 4), 0));
429           break;
430         default:
431           gcc_unreachable ();
432         }
433       break;
434     case 'U':
435       fprintf (asm_out_file, "%s-%s", reg_names[REGNO (x)],
436                reg_names[REGNO (x) + 3]);
437       break;
438     case 'x':
439       fprintf (asm_out_file, HOST_WIDE_INT_PRINT_HEX, INTVAL (x));
440       break;
441     case 'X':
442       fprintf (asm_out_file, HOST_WIDE_INT_PRINT_DEC, 3 - INTVAL (x) / 8);
443       break;
444
445     default:
446       switch (GET_CODE (x))
447         {
448         case REG:
449           fputs (reg_names[REGNO (x)], (stream));
450           break;
451         case MEM:
452           output_address (XEXP (x, 0));
453           break;
454         default:
455           output_addr_const (stream, x);
456           break;
457         }
458       break;
459     }
460 }
461
462 /* What does a constant cost ?  */
463
464 static int
465 mcore_const_costs (rtx exp, enum rtx_code code)
466 {
467   HOST_WIDE_INT val = INTVAL (exp);
468
469   /* Easy constants.  */
470   if (   CONST_OK_FOR_I (val)   
471       || CONST_OK_FOR_M (val)   
472       || CONST_OK_FOR_N (val)   
473       || (code == PLUS && CONST_OK_FOR_L (val)))
474     return 1;                                   
475   else if (code == AND
476            && (   CONST_OK_FOR_M (~val)
477                || CONST_OK_FOR_N (~val)))
478     return 2;
479   else if (code == PLUS                 
480            && (   CONST_OK_FOR_I (-val) 
481                || CONST_OK_FOR_M (-val) 
482                || CONST_OK_FOR_N (-val)))       
483     return 2;                                           
484
485   return 5;                                     
486 }
487
488 /* What does an and instruction cost - we do this b/c immediates may 
489    have been relaxed.   We want to ensure that cse will cse relaxed immeds
490    out.  Otherwise we'll get bad code (multiple reloads of the same const).  */
491
492 static int
493 mcore_and_cost (rtx x)
494 {
495   HOST_WIDE_INT val;
496
497   if (GET_CODE (XEXP (x, 1)) != CONST_INT)
498     return 2;
499
500   val = INTVAL (XEXP (x, 1));
501    
502   /* Do it directly.  */
503   if (CONST_OK_FOR_K (val) || CONST_OK_FOR_M (~val))
504     return 2;
505   /* Takes one instruction to load.  */
506   else if (const_ok_for_mcore (val))
507     return 3;
508   /* Takes two instructions to load.  */
509   else if (TARGET_HARDLIT && mcore_const_ok_for_inline (val))
510     return 4;
511
512   /* Takes a lrw to load.  */
513   return 5;
514 }
515
516 /* What does an or cost - see and_cost().  */
517
518 static int
519 mcore_ior_cost (rtx x)
520 {
521   HOST_WIDE_INT val;
522
523   if (GET_CODE (XEXP (x, 1)) != CONST_INT)
524     return 2;
525
526   val = INTVAL (XEXP (x, 1));
527
528   /* Do it directly with bclri.  */
529   if (CONST_OK_FOR_M (val))
530     return 2;
531   /* Takes one instruction to load.  */
532   else if (const_ok_for_mcore (val))
533     return 3;
534   /* Takes two instructions to load.  */
535   else if (TARGET_HARDLIT && mcore_const_ok_for_inline (val))
536     return 4;
537   
538   /* Takes a lrw to load.  */
539   return 5;
540 }
541
542 static bool
543 mcore_rtx_costs (rtx x, int code, int outer_code, int * total,
544                  bool speed ATTRIBUTE_UNUSED)
545 {
546   switch (code)
547     {
548     case CONST_INT:
549       *total = mcore_const_costs (x, (enum rtx_code) outer_code);
550       return true;
551     case CONST:
552     case LABEL_REF:
553     case SYMBOL_REF:
554       *total = 5;
555       return true;
556     case CONST_DOUBLE:
557       *total = 10;
558       return true;
559
560     case AND:
561       *total = COSTS_N_INSNS (mcore_and_cost (x));
562       return true;
563
564     case IOR:
565       *total = COSTS_N_INSNS (mcore_ior_cost (x));
566       return true;
567
568     case DIV:
569     case UDIV:
570     case MOD:
571     case UMOD:
572     case FLOAT:
573     case FIX:
574       *total = COSTS_N_INSNS (100);
575       return true;
576   
577     default:
578       return false;
579     }
580 }
581
582 /* Prepare the operands for a comparison.  Return whether the branch/setcc
583    should reverse the operands.  */
584
585 bool
586 mcore_gen_compare (enum rtx_code code, rtx op0, rtx op1)
587 {
588   rtx cc_reg = gen_rtx_REG (CCmode, CC_REG);
589   bool invert;
590
591   if (GET_CODE (op1) == CONST_INT)
592     {
593       HOST_WIDE_INT val = INTVAL (op1);
594       
595       switch (code)
596         {
597         case GTU:
598           /* Unsigned > 0 is the same as != 0; everything else is converted
599              below to LEU (reversed cmphs).  */
600           if (val == 0)
601             code = NE;
602           break;
603
604         /* Check whether (LE A imm) can become (LT A imm + 1),
605            or (GT A imm) can become (GE A imm + 1).  */
606         case GT:
607         case LE:
608           if (CONST_OK_FOR_J (val + 1))
609             {
610               op1 = GEN_INT (val + 1);
611               code = code == LE ? LT : GE;
612             }
613           break;
614           
615         default:
616           break;
617         }
618     }
619  
620   if (CONSTANT_P (op1) && GET_CODE (op1) != CONST_INT)
621     op1 = force_reg (SImode, op1);
622
623   /* cmpnei: 0-31 (K immediate)
624      cmplti: 1-32 (J immediate, 0 using btsti x,31).  */
625   invert = false;
626   switch (code)
627     {
628     case EQ:    /* Use inverted condition, cmpne.  */
629       code = NE;
630       invert = true;
631       /* Drop through.  */
632       
633     case NE:    /* Use normal condition, cmpne.  */
634       if (GET_CODE (op1) == CONST_INT && ! CONST_OK_FOR_K (INTVAL (op1)))
635         op1 = force_reg (SImode, op1);
636       break;
637
638     case LE:    /* Use inverted condition, reversed cmplt.  */
639       code = GT;
640       invert = true;
641       /* Drop through.  */
642       
643     case GT:    /* Use normal condition, reversed cmplt.  */
644       if (GET_CODE (op1) == CONST_INT)
645         op1 = force_reg (SImode, op1);
646       break;
647
648     case GE:    /* Use inverted condition, cmplt.  */
649       code = LT;
650       invert = true;
651       /* Drop through.  */
652       
653     case LT:    /* Use normal condition, cmplt.  */
654       if (GET_CODE (op1) == CONST_INT && 
655           /* covered by btsti x,31.  */
656           INTVAL (op1) != 0 &&
657           ! CONST_OK_FOR_J (INTVAL (op1)))
658         op1 = force_reg (SImode, op1);
659       break;
660
661     case GTU:   /* Use inverted condition, cmple.  */
662       /* We coped with unsigned > 0 above.  */
663       gcc_assert (GET_CODE (op1) != CONST_INT || INTVAL (op1) != 0);
664       code = LEU;
665       invert = true;
666       /* Drop through.  */
667       
668     case LEU:   /* Use normal condition, reversed cmphs.  */
669       if (GET_CODE (op1) == CONST_INT && INTVAL (op1) != 0)
670         op1 = force_reg (SImode, op1);
671       break;
672
673     case LTU:   /* Use inverted condition, cmphs.  */
674       code = GEU;
675       invert = true;
676       /* Drop through.  */
677       
678     case GEU:   /* Use normal condition, cmphs.  */
679       if (GET_CODE (op1) == CONST_INT && INTVAL (op1) != 0)
680         op1 = force_reg (SImode, op1);
681       break;
682
683     default:
684       break;
685     }
686
687   emit_insn (gen_rtx_SET (VOIDmode,
688                           cc_reg,
689                           gen_rtx_fmt_ee (code, CCmode, op0, op1)));
690   return invert;
691 }
692
693 int
694 mcore_symbolic_address_p (rtx x)
695 {
696   switch (GET_CODE (x))
697     {
698     case SYMBOL_REF:
699     case LABEL_REF:
700       return 1;
701     case CONST:
702       x = XEXP (x, 0);
703       return (   (GET_CODE (XEXP (x, 0)) == SYMBOL_REF
704                || GET_CODE (XEXP (x, 0)) == LABEL_REF)
705               && GET_CODE (XEXP (x, 1)) == CONST_INT);
706     default:
707       return 0;
708     }
709 }
710
711 /* Functions to output assembly code for a function call.  */
712
713 char *
714 mcore_output_call (rtx operands[], int index)
715 {
716   static char buffer[20];
717   rtx addr = operands [index];
718   
719   if (REG_P (addr))
720     {
721       if (TARGET_CG_DATA)
722         {
723           gcc_assert (mcore_current_function_name);
724           
725           ASM_OUTPUT_CG_EDGE (asm_out_file, mcore_current_function_name,
726                               "unknown", 1);
727         }
728
729       sprintf (buffer, "jsr\t%%%d", index);
730     }
731   else
732     {
733       if (TARGET_CG_DATA)
734         {
735           gcc_assert (mcore_current_function_name);
736           gcc_assert (GET_CODE (addr) == SYMBOL_REF);
737           
738           ASM_OUTPUT_CG_EDGE (asm_out_file, mcore_current_function_name,
739                               XSTR (addr, 0), 0);
740         }
741       
742       sprintf (buffer, "jbsr\t%%%d", index);
743     }
744
745   return buffer;
746 }
747
748 /* Can we load a constant with a single instruction ?  */
749
750 int
751 const_ok_for_mcore (HOST_WIDE_INT value)
752 {
753   if (value >= 0 && value <= 127)
754     return 1;
755   
756   /* Try exact power of two.  */
757   if (CONST_OK_FOR_M (value))
758     return 1;
759   
760   /* Try exact power of two - 1.  */
761   if (CONST_OK_FOR_N (value) && value != -1)
762     return 1;
763   
764   return 0;
765 }
766
767 /* Can we load a constant inline with up to 2 instructions ?  */
768
769 int
770 mcore_const_ok_for_inline (HOST_WIDE_INT value)
771 {
772   HOST_WIDE_INT x, y;
773    
774   return try_constant_tricks (value, & x, & y) > 0;
775 }
776
777 /* Are we loading the constant using a not ?  */
778
779 int
780 mcore_const_trick_uses_not (HOST_WIDE_INT value)
781 {
782   HOST_WIDE_INT x, y;
783
784   return try_constant_tricks (value, & x, & y) == 2; 
785 }       
786
787 /* Try tricks to load a constant inline and return the trick number if
788    success (0 is non-inlinable).
789   
790    0: not inlinable
791    1: single instruction (do the usual thing)
792    2: single insn followed by a 'not'
793    3: single insn followed by a subi
794    4: single insn followed by an addi
795    5: single insn followed by rsubi
796    6: single insn followed by bseti
797    7: single insn followed by bclri
798    8: single insn followed by rotli
799    9: single insn followed by lsli
800    10: single insn followed by ixh
801    11: single insn followed by ixw.  */
802
803 static int
804 try_constant_tricks (HOST_WIDE_INT value, HOST_WIDE_INT * x, HOST_WIDE_INT * y)
805 {
806   HOST_WIDE_INT i;
807   unsigned HOST_WIDE_INT bit, shf, rot;
808
809   if (const_ok_for_mcore (value))
810     return 1;   /* Do the usual thing.  */
811   
812   if (! TARGET_HARDLIT) 
813     return 0;
814
815   if (const_ok_for_mcore (~value))
816     {
817       *x = ~value;
818       return 2;
819     }
820
821   for (i = 1; i <= 32; i++)
822     {
823       if (const_ok_for_mcore (value - i))
824         {
825           *x = value - i;
826           *y = i;
827
828           return 3;
829         }
830
831       if (const_ok_for_mcore (value + i))
832         {
833           *x = value + i;
834           *y = i;
835
836           return 4;
837         }
838     }
839
840   bit = 0x80000000ULL;
841
842   for (i = 0; i <= 31; i++)
843     {
844       if (const_ok_for_mcore (i - value))
845         {
846           *x = i - value;
847           *y = i;
848
849           return 5;
850         }
851
852       if (const_ok_for_mcore (value & ~bit))
853         {
854           *y = bit;
855           *x = value & ~bit;
856           return 6;
857         }
858
859       if (const_ok_for_mcore (value | bit))
860         {
861           *y = ~bit;
862           *x = value | bit;
863
864           return 7;
865         }
866
867       bit >>= 1;
868     }
869
870   shf = value;
871   rot = value;
872
873   for (i = 1; i < 31; i++)
874     {
875       int c;
876
877       /* MCore has rotate left.  */
878       c = rot << 31;
879       rot >>= 1;
880       rot &= 0x7FFFFFFF;
881       rot |= c;   /* Simulate rotate.  */
882
883       if (const_ok_for_mcore (rot))
884         {
885           *y = i;
886           *x = rot;
887
888           return 8;
889         }
890
891       if (shf & 1)
892         shf = 0;        /* Can't use logical shift, low order bit is one.  */
893
894       shf >>= 1;
895
896       if (shf != 0 && const_ok_for_mcore (shf))
897         {
898           *y = i;
899           *x = shf;
900
901           return 9;
902         }
903     }
904
905   if ((value % 3) == 0 && const_ok_for_mcore (value / 3))
906     {
907       *x = value / 3;
908
909       return 10;
910     }
911
912   if ((value % 5) == 0 && const_ok_for_mcore (value / 5))
913     {
914       *x = value / 5;
915
916       return 11;
917     }
918   
919   return 0;
920 }
921
922 /* Check whether reg is dead at first.  This is done by searching ahead
923    for either the next use (i.e., reg is live), a death note, or a set of
924    reg.  Don't just use dead_or_set_p() since reload does not always mark 
925    deaths (especially if PRESERVE_DEATH_NOTES_REGNO_P is not defined). We
926    can ignore subregs by extracting the actual register.  BRC  */
927
928 int
929 mcore_is_dead (rtx first, rtx reg)
930 {
931   rtx insn;
932
933   /* For mcore, subregs can't live independently of their parent regs.  */
934   if (GET_CODE (reg) == SUBREG)
935     reg = SUBREG_REG (reg);
936
937   /* Dies immediately.  */
938   if (dead_or_set_p (first, reg))
939     return 1;
940
941   /* Look for conclusive evidence of live/death, otherwise we have
942      to assume that it is live.  */
943   for (insn = NEXT_INSN (first); insn; insn = NEXT_INSN (insn))
944     {
945       if (GET_CODE (insn) == JUMP_INSN)
946         return 0;       /* We lose track, assume it is alive.  */
947
948       else if (GET_CODE(insn) == CALL_INSN)
949         {
950           /* Call's might use it for target or register parms.  */
951           if (reg_referenced_p (reg, PATTERN (insn))
952               || find_reg_fusage (insn, USE, reg))
953             return 0;
954           else if (dead_or_set_p (insn, reg))
955             return 1;
956         }
957       else if (GET_CODE (insn) == INSN)
958         {
959           if (reg_referenced_p (reg, PATTERN (insn)))
960             return 0;
961           else if (dead_or_set_p (insn, reg))
962             return 1;
963         }
964     }
965
966   /* No conclusive evidence either way, we cannot take the chance
967      that control flow hid the use from us -- "I'm not dead yet".  */
968   return 0;
969 }
970
971 /* Count the number of ones in mask.  */
972
973 int
974 mcore_num_ones (HOST_WIDE_INT mask)
975 {
976   /* A trick to count set bits recently posted on comp.compilers.  */
977   mask =  (mask >> 1  & 0x55555555) + (mask & 0x55555555);
978   mask = ((mask >> 2) & 0x33333333) + (mask & 0x33333333);
979   mask = ((mask >> 4) + mask) & 0x0f0f0f0f;
980   mask = ((mask >> 8) + mask);
981
982   return (mask + (mask >> 16)) & 0xff;
983 }
984
985 /* Count the number of zeros in mask.  */
986
987 int
988 mcore_num_zeros (HOST_WIDE_INT mask)
989 {
990   return 32 - mcore_num_ones (mask);
991 }
992
993 /* Determine byte being masked.  */
994
995 int
996 mcore_byte_offset (unsigned int mask)
997 {
998   if (mask == 0x00ffffffL)
999     return 0;
1000   else if (mask == 0xff00ffffL)
1001     return 1;
1002   else if (mask == 0xffff00ffL)
1003     return 2;
1004   else if (mask == 0xffffff00L)
1005     return 3;
1006
1007   return -1;
1008 }
1009
1010 /* Determine halfword being masked.  */
1011
1012 int
1013 mcore_halfword_offset (unsigned int mask)
1014 {
1015   if (mask == 0x0000ffffL)
1016     return 0;
1017   else if (mask == 0xffff0000L)
1018     return 1;
1019
1020   return -1;
1021 }
1022
1023 /* Output a series of bseti's corresponding to mask.  */
1024
1025 const char *
1026 mcore_output_bseti (rtx dst, int mask)
1027 {
1028   rtx out_operands[2];
1029   int bit;
1030
1031   out_operands[0] = dst;
1032
1033   for (bit = 0; bit < 32; bit++)
1034     {
1035       if ((mask & 0x1) == 0x1)
1036         {
1037           out_operands[1] = GEN_INT (bit);
1038           
1039           output_asm_insn ("bseti\t%0,%1", out_operands);
1040         }
1041       mask >>= 1;
1042     }  
1043
1044   return "";
1045 }
1046
1047 /* Output a series of bclri's corresponding to mask.  */
1048
1049 const char *
1050 mcore_output_bclri (rtx dst, int mask)
1051 {
1052   rtx out_operands[2];
1053   int bit;
1054
1055   out_operands[0] = dst;
1056
1057   for (bit = 0; bit < 32; bit++)
1058     {
1059       if ((mask & 0x1) == 0x0)
1060         {
1061           out_operands[1] = GEN_INT (bit);
1062           
1063           output_asm_insn ("bclri\t%0,%1", out_operands);
1064         }
1065       
1066       mask >>= 1;
1067     }  
1068
1069   return "";
1070 }
1071
1072 /* Output a conditional move of two constants that are +/- 1 within each
1073    other.  See the "movtK" patterns in mcore.md.   I'm not sure this is
1074    really worth the effort.  */
1075
1076 const char *
1077 mcore_output_cmov (rtx operands[], int cmp_t, const char * test)
1078 {
1079   HOST_WIDE_INT load_value;
1080   HOST_WIDE_INT adjust_value;
1081   rtx out_operands[4];
1082
1083   out_operands[0] = operands[0];
1084
1085   /* Check to see which constant is loadable.  */
1086   if (const_ok_for_mcore (INTVAL (operands[1])))
1087     {
1088       out_operands[1] = operands[1];
1089       out_operands[2] = operands[2];
1090     }
1091   else if (const_ok_for_mcore (INTVAL (operands[2])))
1092     {
1093       out_operands[1] = operands[2];
1094       out_operands[2] = operands[1];
1095
1096       /* Complement test since constants are swapped.  */
1097       cmp_t = (cmp_t == 0);
1098     }
1099   load_value   = INTVAL (out_operands[1]);
1100   adjust_value = INTVAL (out_operands[2]);
1101
1102   /* First output the test if folded into the pattern.  */
1103
1104   if (test) 
1105     output_asm_insn (test, operands);
1106
1107   /* Load the constant - for now, only support constants that can be
1108      generated with a single instruction.  maybe add general inlinable
1109      constants later (this will increase the # of patterns since the
1110      instruction sequence has a different length attribute).  */
1111   if (load_value >= 0 && load_value <= 127)
1112     output_asm_insn ("movi\t%0,%1", out_operands);
1113   else if (CONST_OK_FOR_M (load_value))
1114     output_asm_insn ("bgeni\t%0,%P1", out_operands);
1115   else if (CONST_OK_FOR_N (load_value))
1116     output_asm_insn ("bmaski\t%0,%N1", out_operands);
1117    
1118   /* Output the constant adjustment.  */
1119   if (load_value > adjust_value)
1120     {
1121       if (cmp_t)
1122         output_asm_insn ("decf\t%0", out_operands);
1123       else
1124         output_asm_insn ("dect\t%0", out_operands);
1125     }
1126   else
1127     {
1128       if (cmp_t)
1129         output_asm_insn ("incf\t%0", out_operands);
1130       else
1131         output_asm_insn ("inct\t%0", out_operands);
1132     }
1133
1134   return "";
1135 }
1136
1137 /* Outputs the peephole for moving a constant that gets not'ed followed 
1138    by an and (i.e. combine the not and the and into andn). BRC  */
1139
1140 const char *
1141 mcore_output_andn (rtx insn ATTRIBUTE_UNUSED, rtx operands[])
1142 {
1143   HOST_WIDE_INT x, y;
1144   rtx out_operands[3];
1145   const char * load_op;
1146   char buf[256];
1147   int trick_no;
1148
1149   trick_no = try_constant_tricks (INTVAL (operands[1]), &x, &y);
1150   gcc_assert (trick_no == 2);
1151
1152   out_operands[0] = operands[0];
1153   out_operands[1] = GEN_INT (x);
1154   out_operands[2] = operands[2];
1155
1156   if (x >= 0 && x <= 127)
1157     load_op = "movi\t%0,%1";
1158   
1159   /* Try exact power of two.  */
1160   else if (CONST_OK_FOR_M (x))
1161     load_op = "bgeni\t%0,%P1";
1162   
1163   /* Try exact power of two - 1.  */
1164   else if (CONST_OK_FOR_N (x))
1165     load_op = "bmaski\t%0,%N1";
1166   
1167   else
1168     {
1169       load_op = "BADMOVI-andn\t%0, %1";
1170       gcc_unreachable ();
1171     }
1172
1173   sprintf (buf, "%s\n\tandn\t%%2,%%0", load_op);
1174   output_asm_insn (buf, out_operands);
1175
1176   return "";
1177 }
1178
1179 /* Output an inline constant.  */
1180
1181 static const char *
1182 output_inline_const (enum machine_mode mode, rtx operands[])
1183 {
1184   HOST_WIDE_INT x = 0, y = 0;
1185   int trick_no;
1186   rtx out_operands[3];
1187   char buf[256];
1188   char load_op[256];
1189   const char *dst_fmt;
1190   HOST_WIDE_INT value;
1191
1192   value = INTVAL (operands[1]);
1193
1194   trick_no = try_constant_tricks (value, &x, &y);
1195   /* lrw's are handled separately: Large inlinable constants never get
1196      turned into lrw's.  Our caller uses try_constant_tricks to back
1197      off to an lrw rather than calling this routine.  */
1198   gcc_assert (trick_no != 0);
1199   
1200   if (trick_no == 1)
1201     x = value;
1202
1203   /* operands: 0 = dst, 1 = load immed., 2 = immed. adjustment.  */
1204   out_operands[0] = operands[0];
1205   out_operands[1] = GEN_INT (x);
1206   
1207   if (trick_no > 2)
1208     out_operands[2] = GEN_INT (y);
1209
1210   /* Select dst format based on mode.  */
1211   if (mode == DImode && (! TARGET_LITTLE_END))
1212     dst_fmt = "%R0";
1213   else
1214     dst_fmt = "%0";
1215
1216   if (x >= 0 && x <= 127)
1217     sprintf (load_op, "movi\t%s,%%1", dst_fmt);
1218   
1219   /* Try exact power of two.  */
1220   else if (CONST_OK_FOR_M (x))
1221     sprintf (load_op, "bgeni\t%s,%%P1", dst_fmt);
1222   
1223   /* Try exact power of two - 1.  */
1224   else if (CONST_OK_FOR_N (x))
1225     sprintf (load_op, "bmaski\t%s,%%N1", dst_fmt);
1226   
1227   else
1228     {
1229       sprintf (load_op, "BADMOVI-inline_const %s, %%1", dst_fmt);
1230       gcc_unreachable ();
1231     }      
1232
1233   switch (trick_no)
1234     {
1235     case 1:
1236       strcpy (buf, load_op);
1237       break;
1238     case 2:   /* not */
1239       sprintf (buf, "%s\n\tnot\t%s\t// %ld 0x%lx", load_op, dst_fmt, value, value);
1240       break;
1241     case 3:   /* add */
1242       sprintf (buf, "%s\n\taddi\t%s,%%2\t// %ld 0x%lx", load_op, dst_fmt, value, value);
1243       break;
1244     case 4:   /* sub */
1245       sprintf (buf, "%s\n\tsubi\t%s,%%2\t// %ld 0x%lx", load_op, dst_fmt, value, value);
1246       break;
1247     case 5:   /* rsub */
1248       /* Never happens unless -mrsubi, see try_constant_tricks().  */
1249       sprintf (buf, "%s\n\trsubi\t%s,%%2\t// %ld 0x%lx", load_op, dst_fmt, value, value);
1250       break;
1251     case 6:   /* bseti */
1252       sprintf (buf, "%s\n\tbseti\t%s,%%P2\t// %ld 0x%lx", load_op, dst_fmt, value, value);
1253       break;
1254     case 7:   /* bclr */
1255       sprintf (buf, "%s\n\tbclri\t%s,%%Q2\t// %ld 0x%lx", load_op, dst_fmt, value, value);
1256       break;
1257     case 8:   /* rotl */
1258       sprintf (buf, "%s\n\trotli\t%s,%%2\t// %ld 0x%lx", load_op, dst_fmt, value, value);
1259       break;
1260     case 9:   /* lsl */
1261       sprintf (buf, "%s\n\tlsli\t%s,%%2\t// %ld 0x%lx", load_op, dst_fmt, value, value);
1262       break;
1263     case 10:  /* ixh */
1264       sprintf (buf, "%s\n\tixh\t%s,%s\t// %ld 0x%lx", load_op, dst_fmt, dst_fmt, value, value);
1265       break;
1266     case 11:  /* ixw */
1267       sprintf (buf, "%s\n\tixw\t%s,%s\t// %ld 0x%lx", load_op, dst_fmt, dst_fmt, value, value);
1268       break;
1269     default:
1270       return "";
1271     }
1272   
1273   output_asm_insn (buf, out_operands);
1274
1275   return "";
1276 }
1277
1278 /* Output a move of a word or less value.  */
1279
1280 const char *
1281 mcore_output_move (rtx insn ATTRIBUTE_UNUSED, rtx operands[],
1282                    enum machine_mode mode ATTRIBUTE_UNUSED)
1283 {
1284   rtx dst = operands[0];
1285   rtx src = operands[1];
1286
1287   if (GET_CODE (dst) == REG)
1288     {
1289       if (GET_CODE (src) == REG)
1290         {               
1291           if (REGNO (src) == CC_REG)            /* r-c */
1292             return "mvc\t%0"; 
1293           else 
1294             return "mov\t%0,%1";                /* r-r*/
1295         }
1296       else if (GET_CODE (src) == MEM)
1297         {
1298           if (GET_CODE (XEXP (src, 0)) == LABEL_REF) 
1299             return "lrw\t%0,[%1]";              /* a-R */
1300           else
1301             switch (GET_MODE (src))             /* r-m */
1302               {
1303               case SImode:
1304                 return "ldw\t%0,%1";
1305               case HImode:
1306                 return "ld.h\t%0,%1";
1307               case QImode:
1308                 return "ld.b\t%0,%1";
1309               default:
1310                 gcc_unreachable ();
1311               }
1312         }
1313       else if (GET_CODE (src) == CONST_INT)
1314         {
1315           HOST_WIDE_INT x, y;
1316           
1317           if (CONST_OK_FOR_I (INTVAL (src)))       /* r-I */
1318             return "movi\t%0,%1";
1319           else if (CONST_OK_FOR_M (INTVAL (src)))  /* r-M */
1320             return "bgeni\t%0,%P1\t// %1 %x1";
1321           else if (CONST_OK_FOR_N (INTVAL (src)))  /* r-N */
1322             return "bmaski\t%0,%N1\t// %1 %x1";
1323           else if (try_constant_tricks (INTVAL (src), &x, &y))     /* R-P */
1324             return output_inline_const (SImode, operands);  /* 1-2 insns */
1325           else 
1326             return "lrw\t%0,%x1\t// %1";        /* Get it from literal pool.  */
1327         }
1328       else
1329         return "lrw\t%0, %1";                /* Into the literal pool.  */
1330     }
1331   else if (GET_CODE (dst) == MEM)               /* m-r */
1332     switch (GET_MODE (dst))
1333       {
1334       case SImode:
1335         return "stw\t%1,%0";
1336       case HImode:
1337         return "st.h\t%1,%0";
1338       case QImode:
1339         return "st.b\t%1,%0";
1340       default:
1341         gcc_unreachable ();
1342       }
1343
1344   gcc_unreachable ();
1345 }
1346
1347 /* Return a sequence of instructions to perform DI or DF move.
1348    Since the MCORE cannot move a DI or DF in one instruction, we have
1349    to take care when we see overlapping source and dest registers.  */
1350
1351 const char *
1352 mcore_output_movedouble (rtx operands[], enum machine_mode mode ATTRIBUTE_UNUSED)
1353 {
1354   rtx dst = operands[0];
1355   rtx src = operands[1];
1356
1357   if (GET_CODE (dst) == REG)
1358     {
1359       if (GET_CODE (src) == REG)
1360         {
1361           int dstreg = REGNO (dst);
1362           int srcreg = REGNO (src);
1363           
1364           /* Ensure the second source not overwritten.  */
1365           if (srcreg + 1 == dstreg)
1366             return "mov %R0,%R1\n\tmov  %0,%1";
1367           else
1368             return "mov %0,%1\n\tmov    %R0,%R1";
1369         }
1370       else if (GET_CODE (src) == MEM)
1371         {
1372           rtx memexp = memexp = XEXP (src, 0);
1373           int dstreg = REGNO (dst);
1374           int basereg = -1;
1375           
1376           if (GET_CODE (memexp) == LABEL_REF)
1377             return "lrw\t%0,[%1]\n\tlrw\t%R0,[%R1]";
1378           else if (GET_CODE (memexp) == REG) 
1379             basereg = REGNO (memexp);
1380           else if (GET_CODE (memexp) == PLUS)
1381             {
1382               if (GET_CODE (XEXP (memexp, 0)) == REG)
1383                 basereg = REGNO (XEXP (memexp, 0));
1384               else if (GET_CODE (XEXP (memexp, 1)) == REG)
1385                 basereg = REGNO (XEXP (memexp, 1));
1386               else
1387                 gcc_unreachable ();
1388             }
1389           else
1390             gcc_unreachable ();
1391
1392           /* ??? length attribute is wrong here.  */
1393           if (dstreg == basereg)
1394             {
1395               /* Just load them in reverse order.  */
1396               return "ldw\t%R0,%R1\n\tldw\t%0,%1";
1397               
1398               /* XXX: alternative: move basereg to basereg+1
1399                  and then fall through.  */
1400             }
1401           else
1402             return "ldw\t%0,%1\n\tldw\t%R0,%R1";
1403         }
1404       else if (GET_CODE (src) == CONST_INT)
1405         {
1406           if (TARGET_LITTLE_END)
1407             {
1408               if (CONST_OK_FOR_I (INTVAL (src)))
1409                 output_asm_insn ("movi  %0,%1", operands);
1410               else if (CONST_OK_FOR_M (INTVAL (src)))
1411                 output_asm_insn ("bgeni %0,%P1", operands);
1412               else if (CONST_OK_FOR_N (INTVAL (src)))
1413                 output_asm_insn ("bmaski        %0,%N1", operands);
1414               else
1415                 gcc_unreachable ();
1416
1417               if (INTVAL (src) < 0)
1418                 return "bmaski  %R0,32";
1419               else
1420                 return "movi    %R0,0";
1421             }
1422           else
1423             {
1424               if (CONST_OK_FOR_I (INTVAL (src)))
1425                 output_asm_insn ("movi  %R0,%1", operands);
1426               else if (CONST_OK_FOR_M (INTVAL (src)))
1427                 output_asm_insn ("bgeni %R0,%P1", operands);
1428               else if (CONST_OK_FOR_N (INTVAL (src)))
1429                 output_asm_insn ("bmaski        %R0,%N1", operands);
1430               else
1431                 gcc_unreachable ();
1432
1433               if (INTVAL (src) < 0)
1434                 return "bmaski  %0,32";
1435               else
1436                 return "movi    %0,0";
1437             }
1438         }
1439       else
1440         gcc_unreachable ();
1441     }
1442   else if (GET_CODE (dst) == MEM && GET_CODE (src) == REG)
1443     return "stw\t%1,%0\n\tstw\t%R1,%R0";
1444   else
1445     gcc_unreachable ();
1446 }
1447
1448 /* Predicates used by the templates.  */
1449
1450 int
1451 mcore_arith_S_operand (rtx op)
1452 {
1453   if (GET_CODE (op) == CONST_INT && CONST_OK_FOR_M (~INTVAL (op)))
1454     return 1;
1455   
1456   return 0;
1457 }
1458
1459 /* Expand insert bit field.  BRC  */
1460
1461 int
1462 mcore_expand_insv (rtx operands[])
1463 {
1464   int width = INTVAL (operands[1]);
1465   int posn = INTVAL (operands[2]);
1466   int mask;
1467   rtx mreg, sreg, ereg;
1468
1469   /* To get width 1 insv, the test in store_bit_field() (expmed.c, line 191)
1470      for width==1 must be removed.  Look around line 368.  This is something
1471      we really want the md part to do.  */
1472   if (width == 1 && GET_CODE (operands[3]) == CONST_INT)
1473     {
1474       /* Do directly with bseti or bclri.  */
1475       /* RBE: 2/97 consider only low bit of constant.  */
1476       if ((INTVAL (operands[3]) & 1) == 0)
1477         {
1478           mask = ~(1 << posn);
1479           emit_insn (gen_rtx_SET (SImode, operands[0],
1480                               gen_rtx_AND (SImode, operands[0], GEN_INT (mask))));
1481         }
1482       else
1483         {
1484           mask = 1 << posn;
1485           emit_insn (gen_rtx_SET (SImode, operands[0],
1486                             gen_rtx_IOR (SImode, operands[0], GEN_INT (mask))));
1487         }
1488       
1489       return 1;
1490     }
1491
1492   /* Look at some bit-field placements that we aren't interested
1493      in handling ourselves, unless specifically directed to do so.  */
1494   if (! TARGET_W_FIELD)
1495     return 0;           /* Generally, give up about now.  */
1496
1497   if (width == 8 && posn % 8 == 0)
1498     /* Byte sized and aligned; let caller break it up.  */
1499     return 0;
1500   
1501   if (width == 16 && posn % 16 == 0)
1502     /* Short sized and aligned; let caller break it up.  */
1503     return 0;
1504
1505   /* The general case - we can do this a little bit better than what the
1506      machine independent part tries.  This will get rid of all the subregs
1507      that mess up constant folding in combine when working with relaxed
1508      immediates.  */
1509
1510   /* If setting the entire field, do it directly.  */
1511   if (GET_CODE (operands[3]) == CONST_INT
1512       && INTVAL (operands[3]) == ((1 << width) - 1))
1513     {
1514       mreg = force_reg (SImode, GEN_INT (INTVAL (operands[3]) << posn));
1515       emit_insn (gen_rtx_SET (SImode, operands[0],
1516                          gen_rtx_IOR (SImode, operands[0], mreg)));
1517       return 1;
1518     }
1519
1520   /* Generate the clear mask.  */
1521   mreg = force_reg (SImode, GEN_INT (~(((1 << width) - 1) << posn)));
1522
1523   /* Clear the field, to overlay it later with the source.  */
1524   emit_insn (gen_rtx_SET (SImode, operands[0], 
1525                       gen_rtx_AND (SImode, operands[0], mreg)));
1526
1527   /* If the source is constant 0, we've nothing to add back.  */
1528   if (GET_CODE (operands[3]) == CONST_INT && INTVAL (operands[3]) == 0)
1529     return 1;
1530
1531   /* XXX: Should we worry about more games with constant values?
1532      We've covered the high profile: set/clear single-bit and many-bit
1533      fields. How often do we see "arbitrary bit pattern" constants?  */
1534   sreg = copy_to_mode_reg (SImode, operands[3]);
1535
1536   /* Extract src as same width as dst (needed for signed values).  We
1537      always have to do this since we widen everything to SImode.
1538      We don't have to mask if we're shifting this up against the
1539      MSB of the register (e.g., the shift will push out any hi-order
1540      bits.  */
1541   if (width + posn != (int) GET_MODE_SIZE (SImode))
1542     {
1543       ereg = force_reg (SImode, GEN_INT ((1 << width) - 1));      
1544       emit_insn (gen_rtx_SET (SImode, sreg,
1545                           gen_rtx_AND (SImode, sreg, ereg)));
1546     }
1547
1548   /* Insert source value in dest.  */
1549   if (posn != 0)
1550     emit_insn (gen_rtx_SET (SImode, sreg,
1551                         gen_rtx_ASHIFT (SImode, sreg, GEN_INT (posn))));
1552   
1553   emit_insn (gen_rtx_SET (SImode, operands[0],
1554                       gen_rtx_IOR (SImode, operands[0], sreg)));
1555
1556   return 1;
1557 }
1558 \f
1559 /* ??? Block move stuff stolen from m88k.  This code has not been
1560    verified for correctness.  */
1561
1562 /* Emit code to perform a block move.  Choose the best method.
1563
1564    OPERANDS[0] is the destination.
1565    OPERANDS[1] is the source.
1566    OPERANDS[2] is the size.
1567    OPERANDS[3] is the alignment safe to use.  */
1568
1569 /* Emit code to perform a block move with an offset sequence of ldw/st
1570    instructions (..., ldw 0, stw 1, ldw 1, stw 0, ...).  SIZE and ALIGN are
1571    known constants.  DEST and SRC are registers.  OFFSET is the known
1572    starting point for the output pattern.  */
1573
1574 static const enum machine_mode mode_from_align[] =
1575 {
1576   VOIDmode, QImode, HImode, VOIDmode, SImode,
1577 };
1578
1579 static void
1580 block_move_sequence (rtx dst_mem, rtx src_mem, int size, int align)
1581 {
1582   rtx temp[2];
1583   enum machine_mode mode[2];
1584   int amount[2];
1585   bool active[2];
1586   int phase = 0;
1587   int next;
1588   int offset_ld = 0;
1589   int offset_st = 0;
1590   rtx x;
1591
1592   x = XEXP (dst_mem, 0);
1593   if (!REG_P (x))
1594     {
1595       x = force_reg (Pmode, x);
1596       dst_mem = replace_equiv_address (dst_mem, x);
1597     }
1598
1599   x = XEXP (src_mem, 0);
1600   if (!REG_P (x))
1601     {
1602       x = force_reg (Pmode, x);
1603       src_mem = replace_equiv_address (src_mem, x);
1604     }
1605
1606   active[0] = active[1] = false;
1607
1608   do
1609     {
1610       next = phase;
1611       phase ^= 1;
1612
1613       if (size > 0)
1614         {
1615           int next_amount;
1616
1617           next_amount = (size >= 4 ? 4 : (size >= 2 ? 2 : 1));
1618           next_amount = MIN (next_amount, align);
1619
1620           amount[next] = next_amount;
1621           mode[next] = mode_from_align[next_amount];
1622           temp[next] = gen_reg_rtx (mode[next]);
1623
1624           x = adjust_address (src_mem, mode[next], offset_ld);
1625           emit_insn (gen_rtx_SET (VOIDmode, temp[next], x));
1626
1627           offset_ld += next_amount;
1628           size -= next_amount;
1629           active[next] = true;
1630         }
1631
1632       if (active[phase])
1633         {
1634           active[phase] = false;
1635           
1636           x = adjust_address (dst_mem, mode[phase], offset_st);
1637           emit_insn (gen_rtx_SET (VOIDmode, x, temp[phase]));
1638
1639           offset_st += amount[phase];
1640         }
1641     }
1642   while (active[next]);
1643 }
1644
1645 bool
1646 mcore_expand_block_move (rtx *operands)
1647 {
1648   HOST_WIDE_INT align, bytes, max;
1649
1650   if (GET_CODE (operands[2]) != CONST_INT)
1651     return false;
1652
1653   bytes = INTVAL (operands[2]);
1654   align = INTVAL (operands[3]);
1655
1656   if (bytes <= 0)
1657     return false;
1658   if (align > 4)
1659     align = 4;
1660
1661   switch (align)
1662     {
1663     case 4:
1664       if (bytes & 1)
1665         max = 4*4;
1666       else if (bytes & 3)
1667         max = 8*4;
1668       else
1669         max = 16*4;
1670       break;
1671     case 2:
1672       max = 4*2;
1673       break;
1674     case 1:
1675       max = 4*1;
1676       break;
1677     default:
1678       gcc_unreachable ();
1679     }
1680
1681   if (bytes <= max)
1682     {
1683       block_move_sequence (operands[0], operands[1], bytes, align);
1684       return true;
1685     }
1686
1687   return false;
1688 }
1689 \f
1690
1691 /* Code to generate prologue and epilogue sequences.  */
1692 static int number_of_regs_before_varargs;
1693
1694 /* Set by TARGET_SETUP_INCOMING_VARARGS to indicate to prolog that this is
1695    for a varargs function.  */
1696 static int current_function_anonymous_args;
1697
1698 #define STACK_BYTES (STACK_BOUNDARY/BITS_PER_UNIT)
1699 #define STORE_REACH (64)        /* Maximum displace of word store + 4.  */
1700 #define ADDI_REACH (32)         /* Maximum addi operand.  */
1701
1702 static void
1703 layout_mcore_frame (struct mcore_frame * infp)
1704 {
1705   int n;
1706   unsigned int i;
1707   int nbytes;
1708   int regarg;
1709   int localregarg;
1710   int outbounds;
1711   unsigned int growths;
1712   int step;
1713
1714   /* Might have to spill bytes to re-assemble a big argument that
1715      was passed partially in registers and partially on the stack.  */
1716   nbytes = crtl->args.pretend_args_size;
1717   
1718   /* Determine how much space for spilled anonymous args (e.g., stdarg).  */
1719   if (current_function_anonymous_args)
1720     nbytes += (NPARM_REGS - number_of_regs_before_varargs) * UNITS_PER_WORD;
1721   
1722   infp->arg_size = nbytes;
1723
1724   /* How much space to save non-volatile registers we stomp.  */
1725   infp->reg_mask = calc_live_regs (& n);
1726   infp->reg_size = n * 4;
1727
1728   /* And the rest of it... locals and space for overflowed outbounds.  */
1729   infp->local_size = get_frame_size ();
1730   infp->outbound_size = crtl->outgoing_args_size;
1731
1732   /* Make sure we have a whole number of words for the locals.  */
1733   if (infp->local_size % STACK_BYTES)
1734     infp->local_size = (infp->local_size + STACK_BYTES - 1) & ~ (STACK_BYTES -1);
1735   
1736   /* Only thing we know we have to pad is the outbound space, since
1737      we've aligned our locals assuming that base of locals is aligned.  */
1738   infp->pad_local = 0;
1739   infp->pad_reg = 0;
1740   infp->pad_outbound = 0;
1741   if (infp->outbound_size % STACK_BYTES)
1742     infp->pad_outbound = STACK_BYTES - (infp->outbound_size % STACK_BYTES);
1743
1744   /* Now we see how we want to stage the prologue so that it does
1745      the most appropriate stack growth and register saves to either:
1746      (1) run fast,
1747      (2) reduce instruction space, or
1748      (3) reduce stack space.  */
1749   for (i = 0; i < ARRAY_SIZE (infp->growth); i++)
1750     infp->growth[i] = 0;
1751
1752   regarg      = infp->reg_size + infp->arg_size;
1753   localregarg = infp->local_size + regarg;
1754   outbounds   = infp->outbound_size + infp->pad_outbound;
1755   growths     = 0;
1756
1757   /* XXX: Consider one where we consider localregarg + outbound too! */
1758
1759   /* Frame of <= 32 bytes and using stm would get <= 2 registers.
1760      use stw's with offsets and buy the frame in one shot.  */
1761   if (localregarg <= ADDI_REACH
1762       && (infp->reg_size <= 8 || (infp->reg_mask & 0xc000) != 0xc000))
1763     {
1764       /* Make sure we'll be aligned.  */
1765       if (localregarg % STACK_BYTES)
1766         infp->pad_reg = STACK_BYTES - (localregarg % STACK_BYTES);
1767
1768       step = localregarg + infp->pad_reg;
1769       infp->reg_offset = infp->local_size;
1770       
1771       if (outbounds + step <= ADDI_REACH && !frame_pointer_needed)
1772         {
1773           step += outbounds;
1774           infp->reg_offset += outbounds;
1775           outbounds = 0;
1776         }
1777       
1778       infp->arg_offset = step - 4;
1779       infp->growth[growths++] = step;
1780       infp->reg_growth = growths;
1781       infp->local_growth = growths;
1782       
1783       /* If we haven't already folded it in.  */
1784       if (outbounds)
1785         infp->growth[growths++] = outbounds;
1786       
1787       goto finish;
1788     }
1789
1790   /* Frame can't be done with a single subi, but can be done with 2
1791      insns.  If the 'stm' is getting <= 2 registers, we use stw's and
1792      shift some of the stack purchase into the first subi, so both are
1793      single instructions.  */
1794   if (localregarg <= STORE_REACH
1795       && (infp->local_size > ADDI_REACH)
1796       && (infp->reg_size <= 8 || (infp->reg_mask & 0xc000) != 0xc000))
1797     {
1798       int all;
1799
1800       /* Make sure we'll be aligned; use either pad_reg or pad_local.  */
1801       if (localregarg % STACK_BYTES)
1802         infp->pad_reg = STACK_BYTES - (localregarg % STACK_BYTES);
1803
1804       all = localregarg + infp->pad_reg + infp->pad_local;
1805       step = ADDI_REACH;        /* As much up front as we can.  */
1806       if (step > all)
1807         step = all;
1808       
1809       /* XXX: Consider whether step will still be aligned; we believe so.  */
1810       infp->arg_offset = step - 4;
1811       infp->growth[growths++] = step;
1812       infp->reg_growth = growths;
1813       infp->reg_offset = step - infp->pad_reg - infp->reg_size;
1814       all -= step;
1815
1816       /* Can we fold in any space required for outbounds?  */
1817       if (outbounds + all <= ADDI_REACH && !frame_pointer_needed)
1818         {
1819           all += outbounds;
1820           outbounds = 0;
1821         }
1822
1823       /* Get the rest of the locals in place.  */
1824       step = all;
1825       infp->growth[growths++] = step;
1826       infp->local_growth = growths;
1827       all -= step;
1828
1829       assert (all == 0);
1830
1831       /* Finish off if we need to do so.  */
1832       if (outbounds)
1833         infp->growth[growths++] = outbounds;
1834       
1835       goto finish;
1836     }
1837
1838   /* Registers + args is nicely aligned, so we'll buy that in one shot.
1839      Then we buy the rest of the frame in 1 or 2 steps depending on
1840      whether we need a frame pointer.  */
1841   if ((regarg % STACK_BYTES) == 0)
1842     {
1843       infp->growth[growths++] = regarg;
1844       infp->reg_growth = growths;
1845       infp->arg_offset = regarg - 4;
1846       infp->reg_offset = 0;
1847
1848       if (infp->local_size % STACK_BYTES)
1849         infp->pad_local = STACK_BYTES - (infp->local_size % STACK_BYTES);
1850       
1851       step = infp->local_size + infp->pad_local;
1852       
1853       if (!frame_pointer_needed)
1854         {
1855           step += outbounds;
1856           outbounds = 0;
1857         }
1858       
1859       infp->growth[growths++] = step;
1860       infp->local_growth = growths;
1861
1862       /* If there's any left to be done.  */
1863       if (outbounds)
1864         infp->growth[growths++] = outbounds;
1865       
1866       goto finish;
1867     }
1868
1869   /* XXX: optimizations that we'll want to play with....
1870      -- regarg is not aligned, but it's a small number of registers;
1871         use some of localsize so that regarg is aligned and then 
1872         save the registers.  */
1873
1874   /* Simple encoding; plods down the stack buying the pieces as it goes.
1875      -- does not optimize space consumption.
1876      -- does not attempt to optimize instruction counts.
1877      -- but it is safe for all alignments.  */
1878   if (regarg % STACK_BYTES != 0)
1879     infp->pad_reg = STACK_BYTES - (regarg % STACK_BYTES);
1880   
1881   infp->growth[growths++] = infp->arg_size + infp->reg_size + infp->pad_reg;
1882   infp->reg_growth = growths;
1883   infp->arg_offset = infp->growth[0] - 4;
1884   infp->reg_offset = 0;
1885   
1886   if (frame_pointer_needed)
1887     {
1888       if (infp->local_size % STACK_BYTES != 0)
1889         infp->pad_local = STACK_BYTES - (infp->local_size % STACK_BYTES);
1890       
1891       infp->growth[growths++] = infp->local_size + infp->pad_local;
1892       infp->local_growth = growths;
1893       
1894       infp->growth[growths++] = outbounds;
1895     }
1896   else
1897     {
1898       if ((infp->local_size + outbounds) % STACK_BYTES != 0)
1899         infp->pad_local = STACK_BYTES - ((infp->local_size + outbounds) % STACK_BYTES);
1900       
1901       infp->growth[growths++] = infp->local_size + infp->pad_local + outbounds;
1902       infp->local_growth = growths;
1903     }
1904
1905   /* Anything else that we've forgotten?, plus a few consistency checks.  */
1906  finish:
1907   assert (infp->reg_offset >= 0);
1908   assert (growths <= MAX_STACK_GROWS);
1909   
1910   for (i = 0; i < growths; i++)
1911     gcc_assert (!(infp->growth[i] % STACK_BYTES));
1912 }
1913
1914 /* Define the offset between two registers, one to be eliminated, and
1915    the other its replacement, at the start of a routine.  */
1916
1917 int
1918 mcore_initial_elimination_offset (int from, int to)
1919 {
1920   int above_frame;
1921   int below_frame;
1922   struct mcore_frame fi;
1923
1924   layout_mcore_frame (& fi);
1925
1926   /* fp to ap */
1927   above_frame = fi.local_size + fi.pad_local + fi.reg_size + fi.pad_reg;
1928   /* sp to fp */
1929   below_frame = fi.outbound_size + fi.pad_outbound;
1930
1931   if (from == ARG_POINTER_REGNUM && to == FRAME_POINTER_REGNUM)
1932     return above_frame;
1933
1934   if (from == ARG_POINTER_REGNUM && to == STACK_POINTER_REGNUM)
1935     return above_frame + below_frame;
1936
1937   if (from == FRAME_POINTER_REGNUM && to == STACK_POINTER_REGNUM)
1938     return below_frame;
1939
1940   gcc_unreachable ();
1941 }
1942
1943 /* Keep track of some information about varargs for the prolog.  */
1944
1945 static void
1946 mcore_setup_incoming_varargs (CUMULATIVE_ARGS *args_so_far,
1947                               enum machine_mode mode, tree type,
1948                               int * ptr_pretend_size ATTRIBUTE_UNUSED,
1949                               int second_time ATTRIBUTE_UNUSED)
1950 {
1951   current_function_anonymous_args = 1;
1952
1953   /* We need to know how many argument registers are used before
1954      the varargs start, so that we can push the remaining argument
1955      registers during the prologue.  */
1956   number_of_regs_before_varargs = *args_so_far + mcore_num_arg_regs (mode, type);
1957   
1958   /* There is a bug somewhere in the arg handling code.
1959      Until I can find it this workaround always pushes the
1960      last named argument onto the stack.  */
1961   number_of_regs_before_varargs = *args_so_far;
1962   
1963   /* The last named argument may be split between argument registers
1964      and the stack.  Allow for this here.  */
1965   if (number_of_regs_before_varargs > NPARM_REGS)
1966     number_of_regs_before_varargs = NPARM_REGS;
1967 }
1968
1969 void
1970 mcore_expand_prolog (void)
1971 {
1972   struct mcore_frame fi;
1973   int space_allocated = 0;
1974   int growth = 0;
1975
1976   /* Find out what we're doing.  */
1977   layout_mcore_frame (&fi);
1978   
1979   space_allocated = fi.arg_size + fi.reg_size + fi.local_size +
1980     fi.outbound_size + fi.pad_outbound + fi.pad_local + fi.pad_reg;
1981
1982   if (TARGET_CG_DATA)
1983     {
1984       /* Emit a symbol for this routine's frame size.  */
1985       rtx x;
1986
1987       x = DECL_RTL (current_function_decl);
1988       
1989       gcc_assert (GET_CODE (x) == MEM);
1990       
1991       x = XEXP (x, 0);
1992       
1993       gcc_assert (GET_CODE (x) == SYMBOL_REF);
1994       
1995       if (mcore_current_function_name)
1996         free (mcore_current_function_name);
1997       
1998       mcore_current_function_name = xstrdup (XSTR (x, 0));
1999       
2000       ASM_OUTPUT_CG_NODE (asm_out_file, mcore_current_function_name, space_allocated);
2001
2002       if (cfun->calls_alloca)
2003         ASM_OUTPUT_CG_EDGE (asm_out_file, mcore_current_function_name, "alloca", 1);
2004
2005       /* 970425: RBE:
2006          We're looking at how the 8byte alignment affects stack layout
2007          and where we had to pad things. This emits information we can
2008          extract which tells us about frame sizes and the like.  */
2009       fprintf (asm_out_file,
2010                "\t.equ\t__$frame$info$_%s_$_%d_%d_x%x_%d_%d_%d,0\n",
2011                mcore_current_function_name,
2012                fi.arg_size, fi.reg_size, fi.reg_mask,
2013                fi.local_size, fi.outbound_size,
2014                frame_pointer_needed);
2015     }
2016
2017   if (mcore_naked_function_p ())
2018     return;
2019   
2020   /* Handle stdarg+regsaves in one shot: can't be more than 64 bytes.  */
2021   output_stack_adjust (-1, fi.growth[growth++]);        /* Grows it.  */
2022
2023   /* If we have a parameter passed partially in regs and partially in memory,
2024      the registers will have been stored to memory already in function.c.  So
2025      we only need to do something here for varargs functions.  */
2026   if (fi.arg_size != 0 && crtl->args.pretend_args_size == 0)
2027     {
2028       int offset;
2029       int rn = FIRST_PARM_REG + NPARM_REGS - 1;
2030       int remaining = fi.arg_size;
2031
2032       for (offset = fi.arg_offset; remaining >= 4; offset -= 4, rn--, remaining -= 4)
2033         {
2034           emit_insn (gen_movsi
2035                      (gen_rtx_MEM (SImode,
2036                                plus_constant (stack_pointer_rtx, offset)),
2037                       gen_rtx_REG (SImode, rn)));
2038         }
2039     }
2040
2041   /* Do we need another stack adjustment before we do the register saves?  */
2042   if (growth < fi.reg_growth)
2043     output_stack_adjust (-1, fi.growth[growth++]);              /* Grows it.  */
2044
2045   if (fi.reg_size != 0)
2046     {
2047       int i;
2048       int offs = fi.reg_offset;
2049       
2050       for (i = 15; i >= 0; i--)
2051         {
2052           if (offs == 0 && i == 15 && ((fi.reg_mask & 0xc000) == 0xc000))
2053             {
2054               int first_reg = 15;
2055
2056               while (fi.reg_mask & (1 << first_reg))
2057                 first_reg--;
2058               first_reg++;
2059
2060               emit_insn (gen_store_multiple (gen_rtx_MEM (SImode, stack_pointer_rtx),
2061                                              gen_rtx_REG (SImode, first_reg),
2062                                              GEN_INT (16 - first_reg)));
2063
2064               i -= (15 - first_reg);
2065               offs += (16 - first_reg) * 4;
2066             }
2067           else if (fi.reg_mask & (1 << i))
2068             {
2069               emit_insn (gen_movsi
2070                          (gen_rtx_MEM (SImode,
2071                                    plus_constant (stack_pointer_rtx, offs)),
2072                           gen_rtx_REG (SImode, i)));
2073               offs += 4;
2074             }
2075         }
2076     }
2077
2078   /* Figure the locals + outbounds.  */
2079   if (frame_pointer_needed)
2080     {
2081       /* If we haven't already purchased to 'fp'.  */
2082       if (growth < fi.local_growth)
2083         output_stack_adjust (-1, fi.growth[growth++]);          /* Grows it.  */
2084       
2085       emit_insn (gen_movsi (frame_pointer_rtx, stack_pointer_rtx));
2086
2087       /* ... and then go any remaining distance for outbounds, etc.  */
2088       if (fi.growth[growth])
2089         output_stack_adjust (-1, fi.growth[growth++]);
2090     }
2091   else
2092     {
2093       if (growth < fi.local_growth)
2094         output_stack_adjust (-1, fi.growth[growth++]);          /* Grows it.  */
2095       if (fi.growth[growth])
2096         output_stack_adjust (-1, fi.growth[growth++]);
2097     }
2098 }
2099
2100 void
2101 mcore_expand_epilog (void)
2102 {
2103   struct mcore_frame fi;
2104   int i;
2105   int offs;
2106   int growth = MAX_STACK_GROWS - 1 ;
2107
2108     
2109   /* Find out what we're doing.  */
2110   layout_mcore_frame(&fi);
2111
2112   if (mcore_naked_function_p ())
2113     return;
2114
2115   /* If we had a frame pointer, restore the sp from that.  */
2116   if (frame_pointer_needed)
2117     {
2118       emit_insn (gen_movsi (stack_pointer_rtx, frame_pointer_rtx));
2119       growth = fi.local_growth - 1;
2120     }
2121   else
2122     {
2123       /* XXX: while loop should accumulate and do a single sell.  */
2124       while (growth >= fi.local_growth)
2125         {
2126           if (fi.growth[growth] != 0)
2127             output_stack_adjust (1, fi.growth[growth]);
2128           growth--;
2129         }
2130     }
2131
2132   /* Make sure we've shrunk stack back to the point where the registers
2133      were laid down. This is typically 0/1 iterations.  Then pull the
2134      register save information back off the stack.  */
2135   while (growth >= fi.reg_growth)
2136     output_stack_adjust ( 1, fi.growth[growth--]);
2137   
2138   offs = fi.reg_offset;
2139   
2140   for (i = 15; i >= 0; i--)
2141     {
2142       if (offs == 0 && i == 15 && ((fi.reg_mask & 0xc000) == 0xc000))
2143         {
2144           int first_reg;
2145
2146           /* Find the starting register.  */
2147           first_reg = 15;
2148           
2149           while (fi.reg_mask & (1 << first_reg))
2150             first_reg--;
2151           
2152           first_reg++;
2153
2154           emit_insn (gen_load_multiple (gen_rtx_REG (SImode, first_reg),
2155                                         gen_rtx_MEM (SImode, stack_pointer_rtx),
2156                                         GEN_INT (16 - first_reg)));
2157
2158           i -= (15 - first_reg);
2159           offs += (16 - first_reg) * 4;
2160         }
2161       else if (fi.reg_mask & (1 << i))
2162         {
2163           emit_insn (gen_movsi
2164                      (gen_rtx_REG (SImode, i),
2165                       gen_rtx_MEM (SImode,
2166                                plus_constant (stack_pointer_rtx, offs))));
2167           offs += 4;
2168         }
2169     }
2170
2171   /* Give back anything else.  */
2172   /* XXX: Should accumulate total and then give it back.  */
2173   while (growth >= 0)
2174     output_stack_adjust ( 1, fi.growth[growth--]);
2175 }
2176 \f
2177 /* This code is borrowed from the SH port.  */
2178
2179 /* The MCORE cannot load a large constant into a register, constants have to
2180    come from a pc relative load.  The reference of a pc relative load
2181    instruction must be less than 1k in front of the instruction.  This
2182    means that we often have to dump a constant inside a function, and
2183    generate code to branch around it.
2184
2185    It is important to minimize this, since the branches will slow things
2186    down and make things bigger.
2187
2188    Worst case code looks like:
2189
2190    lrw   L1,r0
2191    br    L2
2192    align
2193    L1:   .long value
2194    L2:
2195    ..
2196
2197    lrw   L3,r0
2198    br    L4
2199    align
2200    L3:   .long value
2201    L4:
2202    ..
2203
2204    We fix this by performing a scan before scheduling, which notices which
2205    instructions need to have their operands fetched from the constant table
2206    and builds the table.
2207
2208    The algorithm is:
2209
2210    scan, find an instruction which needs a pcrel move.  Look forward, find the
2211    last barrier which is within MAX_COUNT bytes of the requirement.
2212    If there isn't one, make one.  Process all the instructions between
2213    the find and the barrier.
2214
2215    In the above example, we can tell that L3 is within 1k of L1, so
2216    the first move can be shrunk from the 2 insn+constant sequence into
2217    just 1 insn, and the constant moved to L3 to make:
2218
2219    lrw          L1,r0
2220    ..
2221    lrw          L3,r0
2222    bra          L4
2223    align
2224    L3:.long value
2225    L4:.long value
2226
2227    Then the second move becomes the target for the shortening process.  */
2228
2229 typedef struct
2230 {
2231   rtx value;                    /* Value in table.  */
2232   rtx label;                    /* Label of value.  */
2233 } pool_node;
2234
2235 /* The maximum number of constants that can fit into one pool, since
2236    the pc relative range is 0...1020 bytes and constants are at least 4
2237    bytes long.  We subtract 4 from the range to allow for the case where
2238    we need to add a branch/align before the constant pool.  */
2239
2240 #define MAX_COUNT 1016
2241 #define MAX_POOL_SIZE (MAX_COUNT/4)
2242 static pool_node pool_vector[MAX_POOL_SIZE];
2243 static int pool_size;
2244
2245 /* Dump out any constants accumulated in the final pass.  These
2246    will only be labels.  */
2247
2248 const char *
2249 mcore_output_jump_label_table (void)
2250 {
2251   int i;
2252
2253   if (pool_size)
2254     {
2255       fprintf (asm_out_file, "\t.align 2\n");
2256       
2257       for (i = 0; i < pool_size; i++)
2258         {
2259           pool_node * p = pool_vector + i;
2260
2261           (*targetm.asm_out.internal_label) (asm_out_file, "L", CODE_LABEL_NUMBER (p->label));
2262           
2263           output_asm_insn (".long       %0", &p->value);
2264         }
2265       
2266       pool_size = 0;
2267     }
2268
2269   return "";
2270 }
2271
2272 /* Check whether insn is a candidate for a conditional.  */
2273
2274 static cond_type
2275 is_cond_candidate (rtx insn)
2276 {
2277   /* The only things we conditionalize are those that can be directly
2278      changed into a conditional.  Only bother with SImode items.  If 
2279      we wanted to be a little more aggressive, we could also do other
2280      modes such as DImode with reg-reg move or load 0.  */
2281   if (GET_CODE (insn) == INSN)
2282     {
2283       rtx pat = PATTERN (insn);
2284       rtx src, dst;
2285
2286       if (GET_CODE (pat) != SET)
2287         return COND_NO;
2288
2289       dst = XEXP (pat, 0);
2290
2291       if ((GET_CODE (dst) != REG &&
2292            GET_CODE (dst) != SUBREG) ||
2293           GET_MODE (dst) != SImode)
2294         return COND_NO;
2295   
2296       src = XEXP (pat, 1);
2297
2298       if ((GET_CODE (src) == REG ||
2299            (GET_CODE (src) == SUBREG &&
2300             GET_CODE (SUBREG_REG (src)) == REG)) &&
2301           GET_MODE (src) == SImode)
2302         return COND_MOV_INSN;
2303       else if (GET_CODE (src) == CONST_INT && 
2304                INTVAL (src) == 0)
2305         return COND_CLR_INSN;
2306       else if (GET_CODE (src) == PLUS &&
2307                (GET_CODE (XEXP (src, 0)) == REG ||
2308                 (GET_CODE (XEXP (src, 0)) == SUBREG &&
2309                  GET_CODE (SUBREG_REG (XEXP (src, 0))) == REG)) &&
2310                GET_MODE (XEXP (src, 0)) == SImode &&
2311                GET_CODE (XEXP (src, 1)) == CONST_INT &&
2312                INTVAL (XEXP (src, 1)) == 1)
2313         return COND_INC_INSN;
2314       else if (((GET_CODE (src) == MINUS &&
2315                  GET_CODE (XEXP (src, 1)) == CONST_INT &&
2316                  INTVAL( XEXP (src, 1)) == 1) ||
2317                 (GET_CODE (src) == PLUS &&
2318                  GET_CODE (XEXP (src, 1)) == CONST_INT &&
2319                  INTVAL (XEXP (src, 1)) == -1)) &&
2320                (GET_CODE (XEXP (src, 0)) == REG ||
2321                 (GET_CODE (XEXP (src, 0)) == SUBREG &&
2322                  GET_CODE (SUBREG_REG (XEXP (src, 0))) == REG)) &&
2323                GET_MODE (XEXP (src, 0)) == SImode)
2324         return COND_DEC_INSN;
2325
2326       /* Some insns that we don't bother with:
2327          (set (rx:DI) (ry:DI))
2328          (set (rx:DI) (const_int 0))
2329       */            
2330
2331     }
2332   else if (GET_CODE (insn) == JUMP_INSN &&
2333            GET_CODE (PATTERN (insn)) == SET &&
2334            GET_CODE (XEXP (PATTERN (insn), 1)) == LABEL_REF)
2335     return COND_BRANCH_INSN;
2336
2337   return COND_NO;
2338 }
2339
2340 /* Emit a conditional version of insn and replace the old insn with the
2341    new one.  Return the new insn if emitted.  */
2342
2343 static rtx
2344 emit_new_cond_insn (rtx insn, int cond)
2345 {
2346   rtx c_insn = 0;
2347   rtx pat, dst, src;
2348   cond_type num;
2349
2350   if ((num = is_cond_candidate (insn)) == COND_NO)
2351     return NULL;
2352
2353   pat = PATTERN (insn);
2354
2355   if (GET_CODE (insn) == INSN)
2356     {
2357       dst = SET_DEST (pat);
2358       src = SET_SRC (pat);
2359     }
2360   else
2361     {
2362       dst = JUMP_LABEL (insn);
2363       src = NULL_RTX;
2364     }
2365
2366   switch (num)
2367     {
2368     case COND_MOV_INSN: 
2369     case COND_CLR_INSN:
2370       if (cond)
2371         c_insn = gen_movt0 (dst, src, dst);
2372       else
2373         c_insn = gen_movt0 (dst, dst, src);
2374       break;
2375
2376     case COND_INC_INSN:
2377       if (cond)
2378         c_insn = gen_incscc (dst, dst);
2379       else
2380         c_insn = gen_incscc_false (dst, dst);
2381       break;
2382   
2383     case COND_DEC_INSN:
2384       if (cond)
2385         c_insn = gen_decscc (dst, dst);
2386       else
2387         c_insn = gen_decscc_false (dst, dst);
2388       break;
2389
2390     case COND_BRANCH_INSN:
2391       if (cond)
2392         c_insn = gen_branch_true (dst);
2393       else
2394         c_insn = gen_branch_false (dst);
2395       break;
2396
2397     default:
2398       return NULL;
2399     }
2400
2401   /* Only copy the notes if they exist.  */
2402   if (rtx_length [GET_CODE (c_insn)] >= 7 && rtx_length [GET_CODE (insn)] >= 7)
2403     {
2404       /* We really don't need to bother with the notes and links at this
2405          point, but go ahead and save the notes.  This will help is_dead()
2406          when applying peepholes (links don't matter since they are not
2407          used any more beyond this point for the mcore).  */
2408       REG_NOTES (c_insn) = REG_NOTES (insn);
2409     }
2410   
2411   if (num == COND_BRANCH_INSN)
2412     {
2413       /* For jumps, we need to be a little bit careful and emit the new jump
2414          before the old one and to update the use count for the target label.
2415          This way, the barrier following the old (uncond) jump will get
2416          deleted, but the label won't.  */
2417       c_insn = emit_jump_insn_before (c_insn, insn);
2418       
2419       ++ LABEL_NUSES (dst);
2420       
2421       JUMP_LABEL (c_insn) = dst;
2422     }
2423   else
2424     c_insn = emit_insn_after (c_insn, insn);
2425
2426   delete_insn (insn);
2427   
2428   return c_insn;
2429 }
2430
2431 /* Attempt to change a basic block into a series of conditional insns.  This
2432    works by taking the branch at the end of the 1st block and scanning for the 
2433    end of the 2nd block.  If all instructions in the 2nd block have cond.
2434    versions and the label at the start of block 3 is the same as the target
2435    from the branch at block 1, then conditionalize all insn in block 2 using
2436    the inverse condition of the branch at block 1.  (Note I'm bending the
2437    definition of basic block here.)
2438
2439    e.g., change:   
2440
2441                 bt      L2             <-- end of block 1 (delete)
2442                 mov     r7,r8          
2443                 addu    r7,1           
2444                 br      L3             <-- end of block 2
2445
2446         L2:     ...                    <-- start of block 3 (NUSES==1)
2447         L3:     ...
2448
2449    to:
2450
2451                 movf    r7,r8
2452                 incf    r7
2453                 bf      L3
2454
2455         L3:     ...
2456
2457    we can delete the L2 label if NUSES==1 and re-apply the optimization
2458    starting at the last instruction of block 2.  This may allow an entire
2459    if-then-else statement to be conditionalized.  BRC  */
2460 static rtx
2461 conditionalize_block (rtx first)
2462 {
2463   rtx insn;
2464   rtx br_pat;
2465   rtx end_blk_1_br = 0;
2466   rtx end_blk_2_insn = 0;
2467   rtx start_blk_3_lab = 0;
2468   int cond;
2469   int br_lab_num;
2470   int blk_size = 0;
2471
2472     
2473   /* Check that the first insn is a candidate conditional jump.  This is
2474      the one that we'll eliminate.  If not, advance to the next insn to
2475      try.  */
2476   if (GET_CODE (first) != JUMP_INSN ||
2477       GET_CODE (PATTERN (first)) != SET ||
2478       GET_CODE (XEXP (PATTERN (first), 1)) != IF_THEN_ELSE)
2479     return NEXT_INSN (first);
2480
2481   /* Extract some information we need.  */
2482   end_blk_1_br = first;
2483   br_pat = PATTERN (end_blk_1_br);
2484
2485   /* Complement the condition since we use the reverse cond. for the insns.  */
2486   cond = (GET_CODE (XEXP (XEXP (br_pat, 1), 0)) == EQ);
2487
2488   /* Determine what kind of branch we have.  */
2489   if (GET_CODE (XEXP (XEXP (br_pat, 1), 1)) == LABEL_REF)
2490     {
2491       /* A normal branch, so extract label out of first arm.  */
2492       br_lab_num = CODE_LABEL_NUMBER (XEXP (XEXP (XEXP (br_pat, 1), 1), 0));
2493     }
2494   else
2495     {
2496       /* An inverse branch, so extract the label out of the 2nd arm
2497          and complement the condition.  */
2498       cond = (cond == 0);
2499       br_lab_num = CODE_LABEL_NUMBER (XEXP (XEXP (XEXP (br_pat, 1), 2), 0));
2500     }
2501
2502   /* Scan forward for the start of block 2: it must start with a
2503      label and that label must be the same as the branch target
2504      label from block 1.  We don't care about whether block 2 actually
2505      ends with a branch or a label (an uncond. branch is 
2506      conditionalizable).  */
2507   for (insn = NEXT_INSN (first); insn; insn = NEXT_INSN (insn))
2508     {
2509       enum rtx_code code;
2510       
2511       code = GET_CODE (insn);
2512
2513       /* Look for the label at the start of block 3.  */
2514       if (code == CODE_LABEL && CODE_LABEL_NUMBER (insn) == br_lab_num)
2515         break;
2516
2517       /* Skip barriers, notes, and conditionalizable insns.  If the
2518          insn is not conditionalizable or makes this optimization fail,
2519          just return the next insn so we can start over from that point.  */
2520       if (code != BARRIER && code != NOTE && !is_cond_candidate (insn))
2521         return NEXT_INSN (insn);
2522      
2523       /* Remember the last real insn before the label (i.e. end of block 2).  */
2524       if (code == JUMP_INSN || code == INSN)
2525         {
2526           blk_size ++;
2527           end_blk_2_insn = insn;
2528         }
2529     }
2530
2531   if (!insn)
2532     return insn;
2533  
2534   /* It is possible for this optimization to slow performance if the blocks 
2535      are long.  This really depends upon whether the branch is likely taken 
2536      or not.  If the branch is taken, we slow performance in many cases.  But,
2537      if the branch is not taken, we always help performance (for a single 
2538      block, but for a double block (i.e. when the optimization is re-applied) 
2539      this is not true since the 'right thing' depends on the overall length of
2540      the collapsed block).  As a compromise, don't apply this optimization on 
2541      blocks larger than size 2 (unlikely for the mcore) when speed is important.
2542      the best threshold depends on the latencies of the instructions (i.e., 
2543      the branch penalty).  */
2544   if (optimize > 1 && blk_size > 2)
2545     return insn;
2546
2547   /* At this point, we've found the start of block 3 and we know that
2548      it is the destination of the branch from block 1.   Also, all
2549      instructions in the block 2 are conditionalizable.  So, apply the
2550      conditionalization and delete the branch.  */
2551   start_blk_3_lab = insn;   
2552    
2553   for (insn = NEXT_INSN (end_blk_1_br); insn != start_blk_3_lab; 
2554        insn = NEXT_INSN (insn))
2555     {
2556       rtx newinsn;
2557
2558       if (INSN_DELETED_P (insn))
2559         continue;
2560       
2561       /* Try to form a conditional variant of the instruction and emit it.  */
2562       if ((newinsn = emit_new_cond_insn (insn, cond)))
2563         {
2564           if (end_blk_2_insn == insn)
2565             end_blk_2_insn = newinsn;
2566
2567           insn = newinsn;
2568         }
2569     }
2570
2571   /* Note whether we will delete the label starting blk 3 when the jump
2572      gets deleted.  If so, we want to re-apply this optimization at the 
2573      last real instruction right before the label.  */
2574   if (LABEL_NUSES (start_blk_3_lab) == 1)
2575     {
2576       start_blk_3_lab = 0;
2577     }
2578
2579   /* ??? we probably should redistribute the death notes for this insn, esp.
2580      the death of cc, but it doesn't really matter this late in the game.
2581      The peepholes all use is_dead() which will find the correct death
2582      regardless of whether there is a note.  */
2583   delete_insn (end_blk_1_br);
2584
2585   if (! start_blk_3_lab)
2586     return end_blk_2_insn;
2587   
2588   /* Return the insn right after the label at the start of block 3.  */
2589   return NEXT_INSN (start_blk_3_lab);
2590 }
2591
2592 /* Apply the conditionalization of blocks optimization.  This is the
2593    outer loop that traverses through the insns scanning for a branch
2594    that signifies an opportunity to apply the optimization.  Note that
2595    this optimization is applied late.  If we could apply it earlier,
2596    say before cse 2, it may expose more optimization opportunities.  
2597    but, the pay back probably isn't really worth the effort (we'd have 
2598    to update all reg/flow/notes/links/etc to make it work - and stick it
2599    in before cse 2).  */
2600
2601 static void
2602 conditionalize_optimization (void)
2603 {
2604   rtx insn;
2605
2606   for (insn = get_insns (); insn; insn = conditionalize_block (insn))
2607     continue;
2608 }
2609
2610 static int saved_warn_return_type = -1;
2611 static int saved_warn_return_type_count = 0;
2612
2613 /* This is to handle loads from the constant pool.  */
2614
2615 static void
2616 mcore_reorg (void)
2617 {
2618   /* Reset this variable.  */
2619   current_function_anonymous_args = 0;
2620   
2621   /* Restore the warn_return_type if it has been altered.  */
2622   if (saved_warn_return_type != -1)
2623     {
2624       /* Only restore the value if we have reached another function.
2625          The test of warn_return_type occurs in final_function () in
2626          c-decl.c a long time after the code for the function is generated,
2627          so we need a counter to tell us when we have finished parsing that
2628          function and can restore the flag.  */
2629       if (--saved_warn_return_type_count == 0)
2630         {
2631           warn_return_type = saved_warn_return_type;
2632           saved_warn_return_type = -1;
2633         }
2634     }
2635   
2636   if (optimize == 0)
2637     return;
2638   
2639   /* Conditionalize blocks where we can.  */
2640   conditionalize_optimization ();
2641
2642   /* Literal pool generation is now pushed off until the assembler.  */
2643 }
2644
2645 \f
2646 /* Return true if X is something that can be moved directly into r15.  */
2647
2648 bool
2649 mcore_r15_operand_p (rtx x)
2650 {
2651   switch (GET_CODE (x))
2652     {
2653     case CONST_INT:
2654       return mcore_const_ok_for_inline (INTVAL (x));
2655
2656     case REG:
2657     case SUBREG:
2658     case MEM:
2659       return 1;
2660
2661     default:
2662       return 0;
2663     }
2664 }
2665
2666 /* Implement SECONDARY_RELOAD_CLASS.  If RCLASS contains r15, and we can't
2667    directly move X into it, use r1-r14 as a temporary.  */
2668
2669 enum reg_class
2670 mcore_secondary_reload_class (enum reg_class rclass,
2671                               enum machine_mode mode ATTRIBUTE_UNUSED, rtx x)
2672 {
2673   if (TEST_HARD_REG_BIT (reg_class_contents[rclass], 15)
2674       && !mcore_r15_operand_p (x))
2675     return LRW_REGS;
2676   return NO_REGS;
2677 }
2678
2679 /* Return the reg_class to use when reloading the rtx X into the class
2680    RCLASS.  If X is too complex to move directly into r15, prefer to
2681    use LRW_REGS instead.  */
2682
2683 enum reg_class
2684 mcore_reload_class (rtx x, enum reg_class rclass)
2685 {
2686   if (reg_class_subset_p (LRW_REGS, rclass) && !mcore_r15_operand_p (x))
2687     return LRW_REGS;
2688
2689   return rclass;
2690 }
2691
2692 /* Tell me if a pair of reg/subreg rtx's actually refer to the same
2693    register.  Note that the current version doesn't worry about whether
2694    they are the same mode or note (e.g., a QImode in r2 matches an HImode
2695    in r2 matches an SImode in r2. Might think in the future about whether
2696    we want to be able to say something about modes.  */
2697
2698 int
2699 mcore_is_same_reg (rtx x, rtx y)
2700 {
2701   /* Strip any and all of the subreg wrappers.  */
2702   while (GET_CODE (x) == SUBREG)
2703     x = SUBREG_REG (x);
2704   
2705   while (GET_CODE (y) == SUBREG)
2706     y = SUBREG_REG (y);
2707
2708   if (GET_CODE(x) == REG && GET_CODE(y) == REG && REGNO(x) == REGNO(y))
2709     return 1;
2710
2711   return 0;
2712 }
2713
2714 static void
2715 mcore_option_override (void)
2716 {
2717   /* Only the m340 supports little endian code.  */
2718   if (TARGET_LITTLE_END && ! TARGET_M340)
2719     target_flags |= MASK_M340;
2720 }
2721
2722 \f
2723 /* Compute the number of word sized registers needed to 
2724    hold a function argument of mode MODE and type TYPE.  */
2725
2726 int
2727 mcore_num_arg_regs (enum machine_mode mode, const_tree type)
2728 {
2729   int size;
2730
2731   if (targetm.calls.must_pass_in_stack (mode, type))
2732     return 0;
2733
2734   if (type && mode == BLKmode)
2735     size = int_size_in_bytes (type);
2736   else
2737     size = GET_MODE_SIZE (mode);
2738
2739   return ROUND_ADVANCE (size);
2740 }
2741
2742 static rtx
2743 handle_structs_in_regs (enum machine_mode mode, const_tree type, int reg)
2744 {
2745   int size;
2746
2747   /* The MCore ABI defines that a structure whose size is not a whole multiple
2748      of bytes is passed packed into registers (or spilled onto the stack if
2749      not enough registers are available) with the last few bytes of the
2750      structure being packed, left-justified, into the last register/stack slot.
2751      GCC handles this correctly if the last word is in a stack slot, but we
2752      have to generate a special, PARALLEL RTX if the last word is in an
2753      argument register.  */
2754   if (type
2755       && TYPE_MODE (type) == BLKmode
2756       && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
2757       && (size = int_size_in_bytes (type)) > UNITS_PER_WORD
2758       && (size % UNITS_PER_WORD != 0)
2759       && (reg + mcore_num_arg_regs (mode, type) <= (FIRST_PARM_REG + NPARM_REGS)))
2760     {
2761       rtx    arg_regs [NPARM_REGS]; 
2762       int    nregs;
2763       rtx    result;
2764       rtvec  rtvec;
2765                      
2766       for (nregs = 0; size > 0; size -= UNITS_PER_WORD)
2767         {
2768           arg_regs [nregs] =
2769             gen_rtx_EXPR_LIST (SImode, gen_rtx_REG (SImode, reg ++),
2770                                GEN_INT (nregs * UNITS_PER_WORD));
2771           nregs ++;
2772         }
2773
2774       /* We assume here that NPARM_REGS == 6.  The assert checks this.  */
2775       assert (ARRAY_SIZE (arg_regs) == 6);
2776       rtvec = gen_rtvec (nregs, arg_regs[0], arg_regs[1], arg_regs[2],
2777                           arg_regs[3], arg_regs[4], arg_regs[5]);
2778       
2779       result = gen_rtx_PARALLEL (mode, rtvec);
2780       return result;
2781     }
2782   
2783   return gen_rtx_REG (mode, reg);
2784 }
2785
2786 rtx
2787 mcore_function_value (const_tree valtype, const_tree func)
2788 {
2789   enum machine_mode mode;
2790   int unsigned_p;
2791   
2792   mode = TYPE_MODE (valtype);
2793
2794   /* Since we promote return types, we must promote the mode here too.  */
2795   mode = promote_function_mode (valtype, mode, &unsigned_p, func, 1);
2796   
2797   return handle_structs_in_regs (mode, valtype, FIRST_RET_REG);
2798 }
2799
2800 /* Define where to put the arguments to a function.
2801    Value is zero to push the argument on the stack,
2802    or a hard register in which to store the argument.
2803
2804    MODE is the argument's machine mode.
2805    TYPE is the data type of the argument (as a tree).
2806     This is null for libcalls where that information may
2807     not be available.
2808    CUM is a variable of type CUMULATIVE_ARGS which gives info about
2809     the preceding args and about the function being called.
2810    NAMED is nonzero if this argument is a named parameter
2811     (otherwise it is an extra parameter matching an ellipsis).
2812
2813    On MCore the first args are normally in registers
2814    and the rest are pushed.  Any arg that starts within the first
2815    NPARM_REGS words is at least partially passed in a register unless
2816    its data type forbids.  */
2817
2818 static rtx
2819 mcore_function_arg (CUMULATIVE_ARGS *cum, enum machine_mode mode,
2820                     const_tree type, bool named)
2821 {
2822   int arg_reg;
2823   
2824   if (! named || mode == VOIDmode)
2825     return 0;
2826
2827   if (targetm.calls.must_pass_in_stack (mode, type))
2828     return 0;
2829
2830   arg_reg = ROUND_REG (*cum, mode);
2831   
2832   if (arg_reg < NPARM_REGS)
2833     return handle_structs_in_regs (mode, type, FIRST_PARM_REG + arg_reg);
2834
2835   return 0;
2836 }
2837
2838 static void
2839 mcore_function_arg_advance (CUMULATIVE_ARGS *cum, enum machine_mode mode,
2840                             const_tree type, bool named ATTRIBUTE_UNUSED)
2841 {
2842   *cum = (ROUND_REG (*cum, mode)
2843           + (int)named * mcore_num_arg_regs (mode, type));
2844 }
2845
2846 static unsigned int
2847 mcore_function_arg_boundary (enum machine_mode mode,
2848                              const_tree type ATTRIBUTE_UNUSED)
2849 {
2850   /* Doubles must be aligned to an 8 byte boundary.  */
2851   return (mode != BLKmode && GET_MODE_SIZE (mode) == 8
2852           ? BIGGEST_ALIGNMENT
2853           : PARM_BOUNDARY);
2854 }
2855
2856 /* Returns the number of bytes of argument registers required to hold *part*
2857    of a parameter of machine mode MODE and type TYPE (which may be NULL if
2858    the type is not known).  If the argument fits entirely in the argument
2859    registers, or entirely on the stack, then 0 is returned.  CUM is the
2860    number of argument registers already used by earlier parameters to
2861    the function.  */
2862
2863 static int
2864 mcore_arg_partial_bytes (CUMULATIVE_ARGS *cum, enum machine_mode mode,
2865                          tree type, bool named)
2866 {
2867   int reg = ROUND_REG (*cum, mode);
2868
2869   if (named == 0)
2870     return 0;
2871
2872   if (targetm.calls.must_pass_in_stack (mode, type))
2873     return 0;
2874       
2875   /* REG is not the *hardware* register number of the register that holds
2876      the argument, it is the *argument* register number.  So for example,
2877      the first argument to a function goes in argument register 0, which
2878      translates (for the MCore) into hardware register 2.  The second
2879      argument goes into argument register 1, which translates into hardware
2880      register 3, and so on.  NPARM_REGS is the number of argument registers
2881      supported by the target, not the maximum hardware register number of
2882      the target.  */
2883   if (reg >= NPARM_REGS)
2884     return 0;
2885
2886   /* If the argument fits entirely in registers, return 0.  */
2887   if (reg + mcore_num_arg_regs (mode, type) <= NPARM_REGS)
2888     return 0;
2889
2890   /* The argument overflows the number of available argument registers.
2891      Compute how many argument registers have not yet been assigned to
2892      hold an argument.  */
2893   reg = NPARM_REGS - reg;
2894
2895   /* Return partially in registers and partially on the stack.  */
2896   return reg * UNITS_PER_WORD;
2897 }
2898 \f
2899 /* Return nonzero if SYMBOL is marked as being dllexport'd.  */
2900
2901 int
2902 mcore_dllexport_name_p (const char * symbol)
2903 {
2904   return symbol[0] == '@' && symbol[1] == 'e' && symbol[2] == '.';
2905 }
2906
2907 /* Return nonzero if SYMBOL is marked as being dllimport'd.  */
2908
2909 int
2910 mcore_dllimport_name_p (const char * symbol)
2911 {
2912   return symbol[0] == '@' && symbol[1] == 'i' && symbol[2] == '.';
2913 }
2914
2915 /* Mark a DECL as being dllexport'd.  */
2916
2917 static void
2918 mcore_mark_dllexport (tree decl)
2919 {
2920   const char * oldname;
2921   char * newname;
2922   rtx    rtlname;
2923   tree   idp;
2924
2925   rtlname = XEXP (DECL_RTL (decl), 0);
2926   
2927   if (GET_CODE (rtlname) == MEM)
2928     rtlname = XEXP (rtlname, 0);
2929   gcc_assert (GET_CODE (rtlname) == SYMBOL_REF);
2930   oldname = XSTR (rtlname, 0);
2931   
2932   if (mcore_dllexport_name_p (oldname))
2933     return;  /* Already done.  */
2934
2935   newname = XALLOCAVEC (char, strlen (oldname) + 4);
2936   sprintf (newname, "@e.%s", oldname);
2937
2938   /* We pass newname through get_identifier to ensure it has a unique
2939      address.  RTL processing can sometimes peek inside the symbol ref
2940      and compare the string's addresses to see if two symbols are
2941      identical.  */
2942   /* ??? At least I think that's why we do this.  */
2943   idp = get_identifier (newname);
2944
2945   XEXP (DECL_RTL (decl), 0) =
2946     gen_rtx_SYMBOL_REF (Pmode, IDENTIFIER_POINTER (idp));
2947 }
2948
2949 /* Mark a DECL as being dllimport'd.  */
2950
2951 static void
2952 mcore_mark_dllimport (tree decl)
2953 {
2954   const char * oldname;
2955   char * newname;
2956   tree   idp;
2957   rtx    rtlname;
2958   rtx    newrtl;
2959
2960   rtlname = XEXP (DECL_RTL (decl), 0);
2961   
2962   if (GET_CODE (rtlname) == MEM)
2963     rtlname = XEXP (rtlname, 0);
2964   gcc_assert (GET_CODE (rtlname) == SYMBOL_REF);
2965   oldname = XSTR (rtlname, 0);
2966   
2967   gcc_assert (!mcore_dllexport_name_p (oldname));
2968   if (mcore_dllimport_name_p (oldname))
2969     return; /* Already done.  */
2970
2971   /* ??? One can well ask why we're making these checks here,
2972      and that would be a good question.  */
2973
2974   /* Imported variables can't be initialized.  */
2975   if (TREE_CODE (decl) == VAR_DECL
2976       && !DECL_VIRTUAL_P (decl)
2977       && DECL_INITIAL (decl))
2978     {
2979       error ("initialized variable %q+D is marked dllimport", decl);
2980       return;
2981     }
2982   
2983   /* `extern' needn't be specified with dllimport.
2984      Specify `extern' now and hope for the best.  Sigh.  */
2985   if (TREE_CODE (decl) == VAR_DECL
2986       /* ??? Is this test for vtables needed?  */
2987       && !DECL_VIRTUAL_P (decl))
2988     {
2989       DECL_EXTERNAL (decl) = 1;
2990       TREE_PUBLIC (decl) = 1;
2991     }
2992
2993   newname = XALLOCAVEC (char, strlen (oldname) + 11);
2994   sprintf (newname, "@i.__imp_%s", oldname);
2995
2996   /* We pass newname through get_identifier to ensure it has a unique
2997      address.  RTL processing can sometimes peek inside the symbol ref
2998      and compare the string's addresses to see if two symbols are
2999      identical.  */
3000   /* ??? At least I think that's why we do this.  */
3001   idp = get_identifier (newname);
3002
3003   newrtl = gen_rtx_MEM (Pmode,
3004                     gen_rtx_SYMBOL_REF (Pmode,
3005                              IDENTIFIER_POINTER (idp)));
3006   XEXP (DECL_RTL (decl), 0) = newrtl;
3007 }
3008
3009 static int
3010 mcore_dllexport_p (tree decl)
3011 {
3012   if (   TREE_CODE (decl) != VAR_DECL
3013       && TREE_CODE (decl) != FUNCTION_DECL)
3014     return 0;
3015
3016   return lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)) != 0;
3017 }
3018
3019 static int
3020 mcore_dllimport_p (tree decl)
3021 {
3022   if (   TREE_CODE (decl) != VAR_DECL
3023       && TREE_CODE (decl) != FUNCTION_DECL)
3024     return 0;
3025
3026   return lookup_attribute ("dllimport", DECL_ATTRIBUTES (decl)) != 0;
3027 }
3028
3029 /* We must mark dll symbols specially.  Definitions of dllexport'd objects
3030    install some info in the .drective (PE) or .exports (ELF) sections.  */
3031
3032 static void
3033 mcore_encode_section_info (tree decl, rtx rtl ATTRIBUTE_UNUSED, int first ATTRIBUTE_UNUSED)
3034 {
3035   /* Mark the decl so we can tell from the rtl whether the object is
3036      dllexport'd or dllimport'd.  */
3037   if (mcore_dllexport_p (decl))
3038     mcore_mark_dllexport (decl);
3039   else if (mcore_dllimport_p (decl))
3040     mcore_mark_dllimport (decl);
3041   
3042   /* It might be that DECL has already been marked as dllimport, but
3043      a subsequent definition nullified that.  The attribute is gone
3044      but DECL_RTL still has @i.__imp_foo.  We need to remove that.  */
3045   else if ((TREE_CODE (decl) == FUNCTION_DECL
3046             || TREE_CODE (decl) == VAR_DECL)
3047            && DECL_RTL (decl) != NULL_RTX
3048            && GET_CODE (DECL_RTL (decl)) == MEM
3049            && GET_CODE (XEXP (DECL_RTL (decl), 0)) == MEM
3050            && GET_CODE (XEXP (XEXP (DECL_RTL (decl), 0), 0)) == SYMBOL_REF
3051            && mcore_dllimport_name_p (XSTR (XEXP (XEXP (DECL_RTL (decl), 0), 0), 0)))
3052     {
3053       const char * oldname = XSTR (XEXP (XEXP (DECL_RTL (decl), 0), 0), 0);
3054       tree idp = get_identifier (oldname + 9);
3055       rtx newrtl = gen_rtx_SYMBOL_REF (Pmode, IDENTIFIER_POINTER (idp));
3056
3057       XEXP (DECL_RTL (decl), 0) = newrtl;
3058
3059       /* We previously set TREE_PUBLIC and DECL_EXTERNAL.
3060          ??? We leave these alone for now.  */
3061     }
3062 }
3063
3064 /* Undo the effects of the above.  */
3065
3066 static const char *
3067 mcore_strip_name_encoding (const char * str)
3068 {
3069   return str + (str[0] == '@' ? 3 : 0);
3070 }
3071
3072 /* MCore specific attribute support.
3073    dllexport - for exporting a function/variable that will live in a dll
3074    dllimport - for importing a function/variable from a dll
3075    naked     - do not create a function prologue/epilogue.  */
3076
3077 /* Handle a "naked" attribute; arguments as in
3078    struct attribute_spec.handler.  */
3079
3080 static tree
3081 mcore_handle_naked_attribute (tree * node, tree name, tree args ATTRIBUTE_UNUSED,
3082                               int flags ATTRIBUTE_UNUSED, bool * no_add_attrs)
3083 {
3084   if (TREE_CODE (*node) == FUNCTION_DECL)
3085     {
3086       /* PR14310 - don't complain about lack of return statement
3087          in naked functions.  The solution here is a gross hack
3088          but this is the only way to solve the problem without
3089          adding a new feature to GCC.  I did try submitting a patch
3090          that would add such a new feature, but it was (rightfully)
3091          rejected on the grounds that it was creeping featurism,
3092          so hence this code.  */
3093       if (warn_return_type)
3094         {
3095           saved_warn_return_type = warn_return_type;
3096           warn_return_type = 0;
3097           saved_warn_return_type_count = 2;
3098         }
3099       else if (saved_warn_return_type_count)
3100         saved_warn_return_type_count = 2;
3101     }
3102   else
3103     {
3104       warning (OPT_Wattributes, "%qE attribute only applies to functions",
3105                name);
3106       *no_add_attrs = true;
3107     }
3108
3109   return NULL_TREE;
3110 }
3111
3112 /* ??? It looks like this is PE specific?  Oh well, this is what the
3113    old code did as well.  */
3114
3115 static void
3116 mcore_unique_section (tree decl, int reloc ATTRIBUTE_UNUSED)
3117 {
3118   int len;
3119   const char * name;
3120   char * string;
3121   const char * prefix;
3122
3123   name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
3124   
3125   /* Strip off any encoding in name.  */
3126   name = (* targetm.strip_name_encoding) (name);
3127
3128   /* The object is put in, for example, section .text$foo.
3129      The linker will then ultimately place them in .text
3130      (everything from the $ on is stripped).  */
3131   if (TREE_CODE (decl) == FUNCTION_DECL)
3132     prefix = ".text$";
3133   /* For compatibility with EPOC, we ignore the fact that the
3134      section might have relocs against it.  */
3135   else if (decl_readonly_section (decl, 0))
3136     prefix = ".rdata$";
3137   else
3138     prefix = ".data$";
3139   
3140   len = strlen (name) + strlen (prefix);
3141   string = XALLOCAVEC (char, len + 1);
3142   
3143   sprintf (string, "%s%s", prefix, name);
3144
3145   DECL_SECTION_NAME (decl) = build_string (len, string);
3146 }
3147
3148 int
3149 mcore_naked_function_p (void)
3150 {
3151   return lookup_attribute ("naked", DECL_ATTRIBUTES (current_function_decl)) != NULL_TREE;
3152 }
3153
3154 #ifdef OBJECT_FORMAT_ELF
3155 static void
3156 mcore_asm_named_section (const char *name, 
3157                          unsigned int flags ATTRIBUTE_UNUSED,
3158                          tree decl ATTRIBUTE_UNUSED)
3159 {
3160   fprintf (asm_out_file, "\t.section %s\n", name);
3161 }
3162 #endif /* OBJECT_FORMAT_ELF */
3163
3164 /* Worker function for TARGET_ASM_EXTERNAL_LIBCALL.  */
3165
3166 static void
3167 mcore_external_libcall (rtx fun)
3168 {
3169   fprintf (asm_out_file, "\t.import\t");
3170   assemble_name (asm_out_file, XSTR (fun, 0));
3171   fprintf (asm_out_file, "\n");
3172 }
3173
3174 /* Worker function for TARGET_RETURN_IN_MEMORY.  */
3175
3176 static bool
3177 mcore_return_in_memory (const_tree type, const_tree fntype ATTRIBUTE_UNUSED)
3178 {
3179   const HOST_WIDE_INT size = int_size_in_bytes (type);
3180   return (size == -1 || size > 2 * UNITS_PER_WORD);
3181 }
3182
3183 /* Worker function for TARGET_ASM_TRAMPOLINE_TEMPLATE.
3184    Output assembler code for a block containing the constant parts
3185    of a trampoline, leaving space for the variable parts.
3186
3187    On the MCore, the trampoline looks like:
3188         lrw     r1,  function
3189         lrw     r13, area
3190         jmp     r13
3191         or      r0, r0
3192     .literals                                                */
3193
3194 static void
3195 mcore_asm_trampoline_template (FILE *f)
3196 {
3197   fprintf (f, "\t.short 0x7102\n");
3198   fprintf (f, "\t.short 0x7d02\n");
3199   fprintf (f, "\t.short 0x00cd\n");
3200   fprintf (f, "\t.short 0x1e00\n");
3201   fprintf (f, "\t.long  0\n");
3202   fprintf (f, "\t.long  0\n");
3203 }
3204
3205 /* Worker function for TARGET_TRAMPOLINE_INIT.  */
3206
3207 static void
3208 mcore_trampoline_init (rtx m_tramp, tree fndecl, rtx chain_value)
3209 {
3210   rtx fnaddr = XEXP (DECL_RTL (fndecl), 0);
3211   rtx mem;
3212
3213   emit_block_move (m_tramp, assemble_trampoline_template (),
3214                    GEN_INT (2*UNITS_PER_WORD), BLOCK_OP_NORMAL);
3215
3216   mem = adjust_address (m_tramp, SImode, 8);
3217   emit_move_insn (mem, chain_value);
3218   mem = adjust_address (m_tramp, SImode, 12);
3219   emit_move_insn (mem, fnaddr);
3220 }