OSDN Git Service

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