1 /* Output routines for Sunplus S+CORE processor
2 Copyright (C) 2005, 2007, 2008, 2009, 2010, 2011
3 Free Software Foundation, Inc.
4 Contributed by Sunnorth.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published
10 by the Free Software Foundation; either version 3, or (at your
11 option) any later version.
13 GCC is distributed in the hope that it will be useful, but WITHOUT
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
15 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
16 License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
28 #include "hard-reg-set.h"
29 #include "insn-config.h"
30 #include "conditions.h"
31 #include "insn-attr.h"
33 #include "diagnostic-core.h"
47 #include "target-def.h"
48 #include "langhooks.h"
52 #define SCORE_SDATA_MAX score_sdata_max
53 #define SCORE_STACK_ALIGN(LOC) (((LOC) + 3) & ~3)
54 #define SCORE_PROLOGUE_TEMP_REGNUM (GP_REG_FIRST + 8)
55 #define SCORE_EPILOGUE_TEMP_REGNUM (GP_REG_FIRST + 8)
56 #define SCORE_DEFAULT_SDATA_MAX 8
58 #define BITSET_P(VALUE, BIT) (((VALUE) & (1L << (BIT))) != 0)
59 #define INS_BUF_SZ 128
61 enum score_address_type
68 struct score_frame_info
70 HOST_WIDE_INT total_size
; /* bytes that the entire frame takes up */
71 HOST_WIDE_INT var_size
; /* bytes that variables take up */
72 HOST_WIDE_INT args_size
; /* bytes that outgoing arguments take up */
73 HOST_WIDE_INT gp_reg_size
; /* bytes needed to store gp regs */
74 HOST_WIDE_INT gp_sp_offset
; /* offset from new sp to store gp registers */
75 HOST_WIDE_INT cprestore_size
; /* # bytes that the .cprestore slot takes up */
76 unsigned int mask
; /* mask of saved gp registers */
77 int num_gp
; /* number of gp registers saved */
82 unsigned int num_bytes
; /* The argument's size in bytes */
83 unsigned int reg_words
; /* The number of words passed in registers */
84 unsigned int reg_offset
; /* The offset of the first register from */
85 /* GP_ARG_FIRST or FP_ARG_FIRST etc */
86 unsigned int stack_words
; /* The number of words that must be passed */
88 unsigned int stack_offset
; /* The offset from the start of the stack */
93 struct score_address_info
95 enum score_address_type type
;
99 enum score_symbol_type symbol_type
;
103 static int score_sdata_max
;
104 static char score_ins
[INS_BUF_SZ
+ 8];
106 struct extern_list
*extern_head
= 0;
108 #undef TARGET_ASM_FILE_START
109 #define TARGET_ASM_FILE_START score_asm_file_start
111 #undef TARGET_ASM_FILE_END
112 #define TARGET_ASM_FILE_END score_asm_file_end
114 #undef TARGET_ASM_FUNCTION_PROLOGUE
115 #define TARGET_ASM_FUNCTION_PROLOGUE score_function_prologue
117 #undef TARGET_ASM_FUNCTION_EPILOGUE
118 #define TARGET_ASM_FUNCTION_EPILOGUE score_function_epilogue
120 #undef TARGET_OPTION_OVERRIDE
121 #define TARGET_OPTION_OVERRIDE score_option_override
123 #undef TARGET_LEGITIMIZE_ADDRESS
124 #define TARGET_LEGITIMIZE_ADDRESS score_legitimize_address
126 #undef TARGET_SCHED_ISSUE_RATE
127 #define TARGET_SCHED_ISSUE_RATE score_issue_rate
129 #undef TARGET_ASM_SELECT_RTX_SECTION
130 #define TARGET_ASM_SELECT_RTX_SECTION score_select_rtx_section
132 #undef TARGET_IN_SMALL_DATA_P
133 #define TARGET_IN_SMALL_DATA_P score_in_small_data_p
135 #undef TARGET_FUNCTION_OK_FOR_SIBCALL
136 #define TARGET_FUNCTION_OK_FOR_SIBCALL score_function_ok_for_sibcall
138 #undef TARGET_STRICT_ARGUMENT_NAMING
139 #define TARGET_STRICT_ARGUMENT_NAMING hook_bool_CUMULATIVE_ARGS_true
141 #undef TARGET_ASM_OUTPUT_MI_THUNK
142 #define TARGET_ASM_OUTPUT_MI_THUNK score_output_mi_thunk
144 #undef TARGET_PROMOTE_FUNCTION_MODE
145 #define TARGET_PROMOTE_FUNCTION_MODE default_promote_function_mode_always_promote
147 #undef TARGET_PROMOTE_PROTOTYPES
148 #define TARGET_PROMOTE_PROTOTYPES hook_bool_const_tree_true
150 #undef TARGET_MUST_PASS_IN_STACK
151 #define TARGET_MUST_PASS_IN_STACK must_pass_in_stack_var_size
153 #undef TARGET_ARG_PARTIAL_BYTES
154 #define TARGET_ARG_PARTIAL_BYTES score_arg_partial_bytes
156 #undef TARGET_FUNCTION_ARG
157 #define TARGET_FUNCTION_ARG score_function_arg
159 #undef TARGET_FUNCTION_ARG_ADVANCE
160 #define TARGET_FUNCTION_ARG_ADVANCE score_function_arg_advance
162 #undef TARGET_PASS_BY_REFERENCE
163 #define TARGET_PASS_BY_REFERENCE score_pass_by_reference
165 #undef TARGET_RETURN_IN_MEMORY
166 #define TARGET_RETURN_IN_MEMORY score_return_in_memory
168 #undef TARGET_RTX_COSTS
169 #define TARGET_RTX_COSTS score_rtx_costs
171 #undef TARGET_ADDRESS_COST
172 #define TARGET_ADDRESS_COST score_address_cost
174 #undef TARGET_LEGITIMATE_ADDRESS_P
175 #define TARGET_LEGITIMATE_ADDRESS_P score_legitimate_address_p
177 #undef TARGET_CAN_ELIMINATE
178 #define TARGET_CAN_ELIMINATE score_can_eliminate
180 #undef TARGET_CONDITIONAL_REGISTER_USAGE
181 #define TARGET_CONDITIONAL_REGISTER_USAGE score_conditional_register_usage
183 #undef TARGET_ASM_TRAMPOLINE_TEMPLATE
184 #define TARGET_ASM_TRAMPOLINE_TEMPLATE score_asm_trampoline_template
185 #undef TARGET_TRAMPOLINE_INIT
186 #define TARGET_TRAMPOLINE_INIT score_trampoline_init
188 #undef TARGET_REGISTER_MOVE_COST
189 #define TARGET_REGISTER_MOVE_COST score_register_move_cost
191 /* Return true if SYMBOL is a SYMBOL_REF and OFFSET + SYMBOL points
192 to the same object as SYMBOL. */
194 score_offset_within_object_p (rtx symbol
, HOST_WIDE_INT offset
)
196 if (GET_CODE (symbol
) != SYMBOL_REF
)
199 if (CONSTANT_POOL_ADDRESS_P (symbol
)
201 && offset
< (int)GET_MODE_SIZE (get_pool_mode (symbol
)))
204 if (SYMBOL_REF_DECL (symbol
) != 0
206 && offset
< int_size_in_bytes (TREE_TYPE (SYMBOL_REF_DECL (symbol
))))
212 /* Split X into a base and a constant offset, storing them in *BASE
213 and *OFFSET respectively. */
215 score_split_const (rtx x
, rtx
*base
, HOST_WIDE_INT
*offset
)
219 if (GET_CODE (x
) == CONST
)
222 if (GET_CODE (x
) == PLUS
&& GET_CODE (XEXP (x
, 1)) == CONST_INT
)
224 *offset
+= INTVAL (XEXP (x
, 1));
231 /* Classify symbol X, which must be a SYMBOL_REF or a LABEL_REF. */
232 static enum score_symbol_type
233 score_classify_symbol (rtx x
)
235 if (GET_CODE (x
) == LABEL_REF
)
236 return SYMBOL_GENERAL
;
238 gcc_assert (GET_CODE (x
) == SYMBOL_REF
);
240 if (CONSTANT_POOL_ADDRESS_P (x
))
242 if (GET_MODE_SIZE (get_pool_mode (x
)) <= SCORE_SDATA_MAX
)
243 return SYMBOL_SMALL_DATA
;
244 return SYMBOL_GENERAL
;
246 if (SYMBOL_REF_SMALL_P (x
))
247 return SYMBOL_SMALL_DATA
;
248 return SYMBOL_GENERAL
;
251 /* Return true if the current function must save REGNO. */
253 score_save_reg_p (unsigned int regno
)
255 /* Check call-saved registers. */
256 if (df_regs_ever_live_p (regno
) && !call_used_regs
[regno
])
259 /* We need to save the old frame pointer before setting up a new one. */
260 if (regno
== HARD_FRAME_POINTER_REGNUM
&& frame_pointer_needed
)
263 /* We need to save the incoming return address if it is ever clobbered
264 within the function. */
265 if (regno
== RA_REGNUM
&& df_regs_ever_live_p (regno
))
271 /* Return one word of double-word value OP, taking into account the fixed
272 endianness of certain registers. HIGH_P is true to select the high part,
273 false to select the low part. */
275 score_subw (rtx op
, int high_p
)
278 enum machine_mode mode
= GET_MODE (op
);
280 if (mode
== VOIDmode
)
283 byte
= (TARGET_LITTLE_ENDIAN
? high_p
: !high_p
) ? UNITS_PER_WORD
: 0;
285 if (GET_CODE (op
) == REG
&& REGNO (op
) == HI_REGNUM
)
286 return gen_rtx_REG (SImode
, high_p
? HI_REGNUM
: LO_REGNUM
);
288 if (GET_CODE (op
) == MEM
)
289 return adjust_address (op
, SImode
, byte
);
291 return simplify_gen_subreg (SImode
, op
, mode
, byte
);
294 static struct score_frame_info
*
295 score_cached_frame (void)
297 static struct score_frame_info _frame_info
;
301 /* Return the bytes needed to compute the frame pointer from the current
302 stack pointer. SIZE is the size (in bytes) of the local variables. */
303 static struct score_frame_info
*
304 score_compute_frame_size (HOST_WIDE_INT size
)
307 struct score_frame_info
*f
= score_cached_frame ();
309 memset (f
, 0, sizeof (struct score_frame_info
));
312 f
->var_size
= SCORE_STACK_ALIGN (size
);
313 f
->args_size
= crtl
->outgoing_args_size
;
314 f
->cprestore_size
= flag_pic
? UNITS_PER_WORD
: 0;
315 if (f
->var_size
== 0 && crtl
->is_leaf
)
316 f
->args_size
= f
->cprestore_size
= 0;
318 if (f
->args_size
== 0 && cfun
->calls_alloca
)
319 f
->args_size
= UNITS_PER_WORD
;
321 f
->total_size
= f
->var_size
+ f
->args_size
+ f
->cprestore_size
;
322 for (regno
= GP_REG_FIRST
; regno
<= GP_REG_LAST
; regno
++)
324 if (score_save_reg_p (regno
))
326 f
->gp_reg_size
+= GET_MODE_SIZE (SImode
);
327 f
->mask
|= 1 << (regno
- GP_REG_FIRST
);
331 if (crtl
->calls_eh_return
)
336 regno
= EH_RETURN_DATA_REGNO (i
);
337 if (regno
== INVALID_REGNUM
)
339 f
->gp_reg_size
+= GET_MODE_SIZE (SImode
);
340 f
->mask
|= 1 << (regno
- GP_REG_FIRST
);
344 f
->total_size
+= f
->gp_reg_size
;
345 f
->num_gp
= f
->gp_reg_size
/ UNITS_PER_WORD
;
349 HOST_WIDE_INT offset
;
350 offset
= (f
->args_size
+ f
->cprestore_size
+ f
->var_size
351 + f
->gp_reg_size
- GET_MODE_SIZE (SImode
));
352 f
->gp_sp_offset
= offset
;
360 /* Return true if X is a valid base register for the given mode.
361 Allow only hard registers if STRICT. */
363 score_valid_base_register_p (rtx x
, int strict
)
365 if (!strict
&& GET_CODE (x
) == SUBREG
)
368 return (GET_CODE (x
) == REG
369 && score_regno_mode_ok_for_base_p (REGNO (x
), strict
));
372 /* Return true if X is a valid address for machine mode MODE. If it is,
373 fill in INFO appropriately. STRICT is true if we should only accept
374 hard base registers. */
376 score_classify_address (struct score_address_info
*info
,
377 enum machine_mode mode
, rtx x
, int strict
)
379 info
->code
= GET_CODE (x
);
385 info
->type
= SCORE_ADD_REG
;
387 info
->offset
= const0_rtx
;
388 return score_valid_base_register_p (info
->reg
, strict
);
390 info
->type
= SCORE_ADD_REG
;
391 info
->reg
= XEXP (x
, 0);
392 info
->offset
= XEXP (x
, 1);
393 return (score_valid_base_register_p (info
->reg
, strict
)
394 && GET_CODE (info
->offset
) == CONST_INT
395 && IMM_IN_RANGE (INTVAL (info
->offset
), 15, 1));
400 if (GET_MODE_SIZE (mode
) > GET_MODE_SIZE (SImode
))
402 info
->type
= SCORE_ADD_REG
;
403 info
->reg
= XEXP (x
, 0);
404 info
->offset
= GEN_INT (GET_MODE_SIZE (mode
));
405 return score_valid_base_register_p (info
->reg
, strict
);
407 info
->type
= SCORE_ADD_CONST_INT
;
408 return IMM_IN_RANGE (INTVAL (x
), 15, 1);
412 info
->type
= SCORE_ADD_SYMBOLIC
;
413 return (score_symbolic_constant_p (x
, &info
->symbol_type
)
414 && (info
->symbol_type
== SYMBOL_GENERAL
415 || info
->symbol_type
== SYMBOL_SMALL_DATA
));
421 /* Implement TARGET_RETURN_IN_MEMORY. In S+core,
422 small structures are returned in a register.
423 Objects with varying size must still be returned in memory. */
425 score_return_in_memory (const_tree type
, const_tree fndecl ATTRIBUTE_UNUSED
)
427 return ((TYPE_MODE (type
) == BLKmode
)
428 || (int_size_in_bytes (type
) > 2 * UNITS_PER_WORD
)
429 || (int_size_in_bytes (type
) == -1));
432 /* Return a legitimate address for REG + OFFSET. */
434 score_add_offset (rtx reg
, HOST_WIDE_INT offset
)
436 if (!IMM_IN_RANGE (offset
, 15, 1))
438 reg
= expand_simple_binop (GET_MODE (reg
), PLUS
,
439 gen_int_mode (offset
& 0xffffc000,
441 reg
, NULL
, 0, OPTAB_WIDEN
);
445 return plus_constant (GET_MODE (reg
), reg
, offset
);
448 /* Implement TARGET_ASM_OUTPUT_MI_THUNK. Generate rtl rather than asm text
449 in order to avoid duplicating too much logic from elsewhere. */
451 score_output_mi_thunk (FILE *file
, tree thunk_fndecl ATTRIBUTE_UNUSED
,
452 HOST_WIDE_INT delta
, HOST_WIDE_INT vcall_offset
,
455 rtx this_rtx
, temp1
, insn
, fnaddr
;
457 /* Pretend to be a post-reload pass while generating rtl. */
458 reload_completed
= 1;
460 /* Mark the end of the (empty) prologue. */
461 emit_note (NOTE_INSN_PROLOGUE_END
);
463 /* We need two temporary registers in some cases. */
464 temp1
= gen_rtx_REG (Pmode
, 8);
466 /* Find out which register contains the "this" pointer. */
467 if (aggregate_value_p (TREE_TYPE (TREE_TYPE (function
)), function
))
468 this_rtx
= gen_rtx_REG (Pmode
, ARG_REG_FIRST
+ 1);
470 this_rtx
= gen_rtx_REG (Pmode
, ARG_REG_FIRST
);
472 /* Add DELTA to THIS_RTX. */
475 rtx offset
= GEN_INT (delta
);
476 if (!(delta
>= -32768 && delta
<= 32767))
478 emit_move_insn (temp1
, offset
);
481 emit_insn (gen_add3_insn (this_rtx
, this_rtx
, offset
));
484 /* If needed, add *(*THIS_RTX + VCALL_OFFSET) to THIS_RTX. */
485 if (vcall_offset
!= 0)
489 /* Set TEMP1 to *THIS_RTX. */
490 emit_move_insn (temp1
, gen_rtx_MEM (Pmode
, this_rtx
));
492 /* Set ADDR to a legitimate address for *THIS_RTX + VCALL_OFFSET. */
493 addr
= score_add_offset (temp1
, vcall_offset
);
495 /* Load the offset and add it to THIS_RTX. */
496 emit_move_insn (temp1
, gen_rtx_MEM (Pmode
, addr
));
497 emit_insn (gen_add3_insn (this_rtx
, this_rtx
, temp1
));
500 /* Jump to the target function. */
501 fnaddr
= XEXP (DECL_RTL (function
), 0);
502 insn
= emit_call_insn (gen_sibcall_internal_score7 (fnaddr
, const0_rtx
));
503 SIBLING_CALL_P (insn
) = 1;
505 /* Run just enough of rest_of_compilation. This sequence was
506 "borrowed" from alpha.c. */
508 insn_locators_alloc ();
509 split_all_insns_noflow ();
510 shorten_branches (insn
);
511 final_start_function (insn
, file
, 1);
512 final (insn
, file
, 1);
513 final_end_function ();
515 /* Clean up the vars set above. Note that final_end_function resets
516 the global pointer for us. */
517 reload_completed
= 0;
520 /* Copy VALUE to a register and return that register. If new psuedos
521 are allowed, copy it into a new register, otherwise use DEST. */
523 score_force_temporary (rtx dest
, rtx value
)
525 if (can_create_pseudo_p ())
526 return force_reg (Pmode
, value
);
529 emit_move_insn (copy_rtx (dest
), value
);
534 /* Return a LO_SUM expression for ADDR. TEMP is as for score_force_temporary
535 and is used to load the high part into a register. */
537 score_split_symbol (rtx temp
, rtx addr
)
539 rtx high
= score_force_temporary (temp
,
540 gen_rtx_HIGH (Pmode
, copy_rtx (addr
)));
541 return gen_rtx_LO_SUM (Pmode
, high
, addr
);
544 /* This function is used to implement LEGITIMIZE_ADDRESS. If X can
545 be legitimized in a way that the generic machinery might not expect,
546 return the new address. */
548 score_legitimize_address (rtx x
)
550 enum score_symbol_type symbol_type
;
552 if (score_symbolic_constant_p (x
, &symbol_type
)
553 && symbol_type
== SYMBOL_GENERAL
)
554 return score_split_symbol (0, x
);
556 if (GET_CODE (x
) == PLUS
557 && GET_CODE (XEXP (x
, 1)) == CONST_INT
)
559 rtx reg
= XEXP (x
, 0);
560 if (!score_valid_base_register_p (reg
, 0))
561 reg
= copy_to_mode_reg (Pmode
, reg
);
562 return score_add_offset (reg
, INTVAL (XEXP (x
, 1)));
568 /* Fill INFO with information about a single argument. CUM is the
569 cumulative state for earlier arguments. MODE is the mode of this
570 argument and TYPE is its type (if known). NAMED is true if this
571 is a named (fixed) argument rather than a variable one. */
573 score_classify_arg (const CUMULATIVE_ARGS
*cum
, enum machine_mode mode
,
574 const_tree type
, bool named
, struct score_arg_info
*info
)
577 unsigned int num_words
, max_regs
;
580 if (GET_MODE_CLASS (mode
) == MODE_INT
581 || GET_MODE_CLASS (mode
) == MODE_FLOAT
)
582 even_reg_p
= (GET_MODE_SIZE (mode
) > UNITS_PER_WORD
);
584 if (type
!= NULL_TREE
&& TYPE_ALIGN (type
) > BITS_PER_WORD
&& named
)
587 if (TARGET_MUST_PASS_IN_STACK (mode
, type
))
588 info
->reg_offset
= ARG_REG_NUM
;
591 info
->reg_offset
= cum
->num_gprs
;
593 info
->reg_offset
+= info
->reg_offset
& 1;
597 info
->num_bytes
= int_size_in_bytes (type
);
599 info
->num_bytes
= GET_MODE_SIZE (mode
);
601 num_words
= (info
->num_bytes
+ UNITS_PER_WORD
- 1) / UNITS_PER_WORD
;
602 max_regs
= ARG_REG_NUM
- info
->reg_offset
;
604 /* Partition the argument between registers and stack. */
605 info
->reg_words
= MIN (num_words
, max_regs
);
606 info
->stack_words
= num_words
- info
->reg_words
;
608 /* The alignment applied to registers is also applied to stack arguments. */
609 if (info
->stack_words
)
611 info
->stack_offset
= cum
->stack_words
;
613 info
->stack_offset
+= info
->stack_offset
& 1;
617 /* Set up the stack and frame (if desired) for the function. */
619 score_function_prologue (FILE *file
, HOST_WIDE_INT size ATTRIBUTE_UNUSED
)
622 struct score_frame_info
*f
= score_cached_frame ();
623 HOST_WIDE_INT tsize
= f
->total_size
;
625 fnname
= XSTR (XEXP (DECL_RTL (current_function_decl
), 0), 0);
626 if (!flag_inhibit_size_directive
)
628 fputs ("\t.ent\t", file
);
629 assemble_name (file
, fnname
);
632 assemble_name (file
, fnname
);
635 if (!flag_inhibit_size_directive
)
638 "\t.frame\t%s," HOST_WIDE_INT_PRINT_DEC
",%s, %d\t\t"
639 "# vars= " HOST_WIDE_INT_PRINT_DEC
", regs= %d"
640 ", args= " HOST_WIDE_INT_PRINT_DEC
641 ", gp= " HOST_WIDE_INT_PRINT_DEC
"\n",
642 (reg_names
[(frame_pointer_needed
)
643 ? HARD_FRAME_POINTER_REGNUM
: STACK_POINTER_REGNUM
]),
645 reg_names
[RA_REGNUM
],
646 crtl
->is_leaf
? 1 : 0,
652 fprintf(file
, "\t.mask\t0x%08x," HOST_WIDE_INT_PRINT_DEC
"\n",
654 (f
->gp_sp_offset
- f
->total_size
));
658 /* Do any necessary cleanup after a function to restore stack, frame,
661 score_function_epilogue (FILE *file
, HOST_WIDE_INT size ATTRIBUTE_UNUSED
)
663 if (!flag_inhibit_size_directive
)
666 fnname
= XSTR (XEXP (DECL_RTL (current_function_decl
), 0), 0);
667 fputs ("\t.end\t", file
);
668 assemble_name (file
, fnname
);
673 /* Returns true if X contains a SYMBOL_REF. */
675 score_symbolic_expression_p (rtx x
)
677 if (GET_CODE (x
) == SYMBOL_REF
)
680 if (GET_CODE (x
) == CONST
)
681 return score_symbolic_expression_p (XEXP (x
, 0));
684 return score_symbolic_expression_p (XEXP (x
, 0));
686 if (ARITHMETIC_P (x
))
687 return (score_symbolic_expression_p (XEXP (x
, 0))
688 || score_symbolic_expression_p (XEXP (x
, 1)));
693 /* Choose the section to use for the constant rtx expression X that has
696 score_select_rtx_section (enum machine_mode mode
, rtx x
, unsigned HOST_WIDE_INT align
)
698 if (GET_MODE_SIZE (mode
) <= SCORE_SDATA_MAX
)
699 return get_named_section (0, ".sdata", 0);
700 else if (flag_pic
&& score_symbolic_expression_p (x
))
701 return get_named_section (0, ".data.rel.ro", 3);
703 return mergeable_constant_section (mode
, align
, 0);
706 /* Implement TARGET_IN_SMALL_DATA_P. */
708 score_in_small_data_p (const_tree decl
)
712 if (TREE_CODE (decl
) == STRING_CST
713 || TREE_CODE (decl
) == FUNCTION_DECL
)
716 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_SECTION_NAME (decl
) != 0)
719 name
= TREE_STRING_POINTER (DECL_SECTION_NAME (decl
));
720 if (strcmp (name
, ".sdata") != 0
721 && strcmp (name
, ".sbss") != 0)
723 if (!DECL_EXTERNAL (decl
))
726 size
= int_size_in_bytes (TREE_TYPE (decl
));
727 return (size
> 0 && size
<= SCORE_SDATA_MAX
);
730 /* Implement TARGET_ASM_FILE_START. */
732 score_asm_file_start (void)
734 default_file_start ();
735 fprintf (asm_out_file
, ASM_COMMENT_START
736 "GCC for S+core %s \n", SCORE_GCC_VERSION
);
739 fprintf (asm_out_file
, "\t.set pic\n");
742 /* Implement TARGET_ASM_FILE_END. When using assembler macros, emit
743 .externs for any small-data variables that turned out to be external. */
745 score_asm_file_end (void)
748 struct extern_list
*p
;
751 fputs ("\n", asm_out_file
);
752 for (p
= extern_head
; p
!= 0; p
= p
->next
)
754 name_tree
= get_identifier (p
->name
);
755 if (!TREE_ASM_WRITTEN (name_tree
)
756 && TREE_SYMBOL_REFERENCED (name_tree
))
758 TREE_ASM_WRITTEN (name_tree
) = 1;
759 fputs ("\t.extern\t", asm_out_file
);
760 assemble_name (asm_out_file
, p
->name
);
761 fprintf (asm_out_file
, ", %d\n", p
->size
);
767 /* Implement TARGET_OPTION_OVERRIDE hook. */
769 score_option_override (void)
772 score_sdata_max
= SCORE_DEFAULT_SDATA_MAX
;
776 /* Implement REGNO_REG_CLASS macro. */
778 score_reg_class (int regno
)
781 gcc_assert (regno
>= 0 && regno
< FIRST_PSEUDO_REGISTER
);
783 if (regno
== FRAME_POINTER_REGNUM
784 || regno
== ARG_POINTER_REGNUM
)
787 for (c
= 0; c
< N_REG_CLASSES
; c
++)
788 if (TEST_HARD_REG_BIT (reg_class_contents
[c
], regno
))
794 /* Implement PREFERRED_RELOAD_CLASS macro. */
796 score_preferred_reload_class (rtx x ATTRIBUTE_UNUSED
, enum reg_class rclass
)
798 if (reg_class_subset_p (G16_REGS
, rclass
))
800 if (reg_class_subset_p (G32_REGS
, rclass
))
805 /* Implement SECONDARY_INPUT_RELOAD_CLASS
806 and SECONDARY_OUTPUT_RELOAD_CLASS macro. */
808 score_secondary_reload_class (enum reg_class rclass
,
809 enum machine_mode mode ATTRIBUTE_UNUSED
,
813 if (GET_CODE (x
) == REG
|| GET_CODE(x
) == SUBREG
)
814 regno
= true_regnum (x
);
816 if (!GR_REG_CLASS_P (rclass
))
817 return GP_REG_P (regno
) ? NO_REGS
: G32_REGS
;
822 /* Return truth value on whether or not a given hard register
823 can support a given mode. */
825 score_hard_regno_mode_ok (unsigned int regno
, enum machine_mode mode
)
827 int size
= GET_MODE_SIZE (mode
);
828 enum mode_class mclass
= GET_MODE_CLASS (mode
);
830 if (mclass
== MODE_CC
)
831 return regno
== CC_REGNUM
;
832 else if (regno
== FRAME_POINTER_REGNUM
833 || regno
== ARG_POINTER_REGNUM
)
834 return mclass
== MODE_INT
;
835 else if (GP_REG_P (regno
))
836 /* ((regno <= (GP_REG_LAST- HARD_REGNO_NREGS (dummy, mode)) + 1) */
837 return !(regno
& 1) || (size
<= UNITS_PER_WORD
);
838 else if (CE_REG_P (regno
))
839 return (mclass
== MODE_INT
840 && ((size
<= UNITS_PER_WORD
)
841 || (regno
== CE_REG_FIRST
&& size
== 2 * UNITS_PER_WORD
)));
843 return (mclass
== MODE_INT
) && (size
<= UNITS_PER_WORD
);
846 /* Implement INITIAL_ELIMINATION_OFFSET. FROM is either the frame
847 pointer or argument pointer. TO is either the stack pointer or
848 hard frame pointer. */
850 score_initial_elimination_offset (int from
,
851 int to ATTRIBUTE_UNUSED
)
853 struct score_frame_info
*f
= score_compute_frame_size (get_frame_size ());
856 case ARG_POINTER_REGNUM
:
857 return f
->total_size
;
858 case FRAME_POINTER_REGNUM
:
865 /* Implement TARGET_FUNCTION_ARG_ADVANCE hook. */
867 score_function_arg_advance (cumulative_args_t cum_args
, enum machine_mode mode
,
868 const_tree type
, bool named
)
870 struct score_arg_info info
;
871 CUMULATIVE_ARGS
*cum
= get_cumulative_args (cum_args
);
872 score_classify_arg (cum
, mode
, type
, named
, &info
);
873 cum
->num_gprs
= info
.reg_offset
+ info
.reg_words
;
874 if (info
.stack_words
> 0)
875 cum
->stack_words
= info
.stack_offset
+ info
.stack_words
;
879 /* Implement TARGET_ARG_PARTIAL_BYTES macro. */
881 score_arg_partial_bytes (cumulative_args_t cum_args
,
882 enum machine_mode mode
, tree type
, bool named
)
884 struct score_arg_info info
;
885 CUMULATIVE_ARGS
*cum
= get_cumulative_args (cum_args
);
886 score_classify_arg (cum
, mode
, type
, named
, &info
);
887 return info
.stack_words
> 0 ? info
.reg_words
* UNITS_PER_WORD
: 0;
890 /* Implement TARGET_FUNCTION_ARG hook. */
892 score_function_arg (cumulative_args_t cum_args
, enum machine_mode mode
,
893 const_tree type
, bool named
)
895 struct score_arg_info info
;
896 CUMULATIVE_ARGS
*cum
= get_cumulative_args (cum_args
);
898 if (mode
== VOIDmode
|| !named
)
901 score_classify_arg (cum
, mode
, type
, named
, &info
);
903 if (info
.reg_offset
== ARG_REG_NUM
)
906 if (!info
.stack_words
)
907 return gen_rtx_REG (mode
, ARG_REG_FIRST
+ info
.reg_offset
);
910 rtx ret
= gen_rtx_PARALLEL (mode
, rtvec_alloc (info
.reg_words
));
911 unsigned int i
, part_offset
= 0;
912 for (i
= 0; i
< info
.reg_words
; i
++)
915 reg
= gen_rtx_REG (SImode
, ARG_REG_FIRST
+ info
.reg_offset
+ i
);
916 XVECEXP (ret
, 0, i
) = gen_rtx_EXPR_LIST (SImode
, reg
,
917 GEN_INT (part_offset
));
918 part_offset
+= UNITS_PER_WORD
;
924 /* Implement FUNCTION_VALUE and LIBCALL_VALUE. For normal calls,
925 VALTYPE is the return type and MODE is VOIDmode. For libcalls,
926 VALTYPE is null and MODE is the mode of the return value. */
928 score_function_value (const_tree valtype
, const_tree func
, enum machine_mode mode
)
933 mode
= TYPE_MODE (valtype
);
934 unsignedp
= TYPE_UNSIGNED (valtype
);
935 mode
= promote_function_mode (valtype
, mode
, &unsignedp
, func
, 1);
937 return gen_rtx_REG (mode
, RT_REGNUM
);
940 /* Implement TARGET_ASM_TRAMPOLINE_TEMPLATE. */
943 score_asm_trampoline_template (FILE *f
)
945 fprintf (f
, "\t.set r1\n");
946 fprintf (f
, "\tmv r31, r3\n");
947 fprintf (f
, "\tbl nextinsn\n");
948 fprintf (f
, "nextinsn:\n");
949 fprintf (f
, "\tlw r1, [r3, 6*4-8]\n");
950 fprintf (f
, "\tlw r23, [r3, 6*4-4]\n");
951 fprintf (f
, "\tmv r3, r31\n");
952 fprintf (f
, "\tbr! r1\n");
953 fprintf (f
, "\tnop!\n");
954 fprintf (f
, "\t.set nor1\n");
957 /* Implement TARGET_TRAMPOLINE_INIT. */
959 score_trampoline_init (rtx m_tramp
, tree fndecl
, rtx chain_value
)
961 #define CODE_SIZE (TRAMPOLINE_INSNS * UNITS_PER_WORD)
963 rtx fnaddr
= XEXP (DECL_RTL (fndecl
), 0);
966 emit_block_move (m_tramp
, assemble_trampoline_template (),
967 GEN_INT (TRAMPOLINE_SIZE
), BLOCK_OP_NORMAL
);
969 mem
= adjust_address (m_tramp
, SImode
, CODE_SIZE
);
970 emit_move_insn (mem
, fnaddr
);
971 mem
= adjust_address (m_tramp
, SImode
, CODE_SIZE
+ GET_MODE_SIZE (SImode
));
972 emit_move_insn (mem
, chain_value
);
977 /* This function is used to implement REG_MODE_OK_FOR_BASE_P macro. */
979 score_regno_mode_ok_for_base_p (int regno
, int strict
)
981 if (regno
>= FIRST_PSEUDO_REGISTER
)
985 regno
= reg_renumber
[regno
];
987 if (regno
== ARG_POINTER_REGNUM
988 || regno
== FRAME_POINTER_REGNUM
)
990 return GP_REG_P (regno
);
993 /* Implement TARGET_LEGITIMATE_ADDRESS_P macro. */
995 score_legitimate_address_p (enum machine_mode mode
, rtx x
, bool strict
)
997 struct score_address_info addr
;
999 return score_classify_address (&addr
, mode
, x
, strict
);
1002 /* Implement TARGET_REGISTER_MOVE_COST.
1004 Return a number assessing the cost of moving a register in class
1005 FROM to class TO. */
1007 score_register_move_cost (enum machine_mode mode ATTRIBUTE_UNUSED
,
1008 reg_class_t from
, reg_class_t to
)
1010 if (GR_REG_CLASS_P (from
))
1012 if (GR_REG_CLASS_P (to
))
1014 else if (SP_REG_CLASS_P (to
))
1016 else if (CP_REG_CLASS_P (to
))
1018 else if (CE_REG_CLASS_P (to
))
1021 if (GR_REG_CLASS_P (to
))
1023 if (GR_REG_CLASS_P (from
))
1025 else if (SP_REG_CLASS_P (from
))
1027 else if (CP_REG_CLASS_P (from
))
1029 else if (CE_REG_CLASS_P (from
))
1035 /* Return the number of instructions needed to load a symbol of the
1036 given type into a register. */
1038 score_symbol_insns (enum score_symbol_type type
)
1042 case SYMBOL_GENERAL
:
1045 case SYMBOL_SMALL_DATA
:
1052 /* Return the number of instructions needed to load or store a value
1053 of mode MODE at X. Return 0 if X isn't valid for MODE. */
1055 score_address_insns (rtx x
, enum machine_mode mode
)
1057 struct score_address_info addr
;
1060 if (mode
== BLKmode
)
1063 factor
= (GET_MODE_SIZE (mode
) + UNITS_PER_WORD
- 1) / UNITS_PER_WORD
;
1065 if (score_classify_address (&addr
, mode
, x
, false))
1069 case SCORE_ADD_CONST_INT
:
1072 case SCORE_ADD_SYMBOLIC
:
1073 return factor
* score_symbol_insns (addr
.symbol_type
);
1078 /* Implement TARGET_RTX_COSTS macro. */
1080 score_rtx_costs (rtx x
, int code
, int outer_code
, int opno ATTRIBUTE_UNUSED
,
1081 int *total
, bool speed ATTRIBUTE_UNUSED
)
1083 enum machine_mode mode
= GET_MODE (x
);
1088 if (outer_code
== SET
)
1090 if (((INTVAL (x
) & 0xffff) == 0)
1091 || (INTVAL (x
) >= -32768 && INTVAL (x
) <= 32767))
1092 *total
= COSTS_N_INSNS (1);
1094 *total
= COSTS_N_INSNS (2);
1096 else if (outer_code
== PLUS
|| outer_code
== MINUS
)
1098 if (INTVAL (x
) >= -8192 && INTVAL (x
) <= 8191)
1100 else if (((INTVAL (x
) & 0xffff) == 0)
1101 || (INTVAL (x
) >= -32768 && INTVAL (x
) <= 32767))
1104 *total
= COSTS_N_INSNS (2);
1106 else if (outer_code
== AND
|| outer_code
== IOR
)
1108 if (INTVAL (x
) >= 0 && INTVAL (x
) <= 16383)
1110 else if (((INTVAL (x
) & 0xffff) == 0)
1111 || (INTVAL (x
) >= 0 && INTVAL (x
) <= 65535))
1114 *total
= COSTS_N_INSNS (2);
1126 *total
= COSTS_N_INSNS (2);
1131 /* If the address is legitimate, return the number of
1132 instructions it needs, otherwise use the default handling. */
1133 int n
= score_address_insns (XEXP (x
, 0), GET_MODE (x
));
1136 *total
= COSTS_N_INSNS (n
+ 1);
1143 *total
= COSTS_N_INSNS (6);
1147 *total
= COSTS_N_INSNS (1);
1155 *total
= COSTS_N_INSNS (2);
1165 *total
= COSTS_N_INSNS ((GET_CODE (XEXP (x
, 1)) == CONST_INT
)
1172 *total
= COSTS_N_INSNS (4);
1179 *total
= COSTS_N_INSNS (4);
1182 *total
= COSTS_N_INSNS (1);
1188 *total
= COSTS_N_INSNS (4);
1194 *total
= optimize_size
? COSTS_N_INSNS (2) : COSTS_N_INSNS (12);
1201 *total
= optimize_size
? COSTS_N_INSNS (2) : COSTS_N_INSNS (33);
1206 switch (GET_MODE (XEXP (x
, 0)))
1210 if (GET_CODE (XEXP (x
, 0)) == MEM
)
1212 *total
= COSTS_N_INSNS (2);
1214 if (!TARGET_LITTLE_ENDIAN
&&
1215 side_effects_p (XEXP (XEXP (x
, 0), 0)))
1219 *total
= COSTS_N_INSNS (1);
1223 *total
= COSTS_N_INSNS (1);
1233 /* Implement TARGET_ADDRESS_COST macro. */
1235 score_address_cost (rtx addr
,
1236 bool speed ATTRIBUTE_UNUSED
)
1238 return score_address_insns (addr
, SImode
);
1241 /* Implement ASM_OUTPUT_EXTERNAL macro. */
1243 score_output_external (FILE *file ATTRIBUTE_UNUSED
,
1244 tree decl
, const char *name
)
1246 register struct extern_list
*p
;
1248 if (score_in_small_data_p (decl
))
1250 p
= ggc_alloc_extern_list ();
1251 p
->next
= extern_head
;
1253 p
->size
= int_size_in_bytes (TREE_TYPE (decl
));
1259 /* Implement RETURN_ADDR_RTX. Note, we do not support moving
1260 back to a previous frame. */
1262 score_return_addr (int count
, rtx frame ATTRIBUTE_UNUSED
)
1266 return get_hard_reg_initial_val (Pmode
, RA_REGNUM
);
1269 /* Implement PRINT_OPERAND macro. */
1270 /* Score-specific operand codes:
1271 '[' print .set nor1 directive
1272 ']' print .set r1 directive
1273 'U' print hi part of a CONST_INT rtx
1276 'D' print SFmode const double
1277 'S' selectively print "!" if operand is 15bit instruction accessible
1278 'V' print "v!" if operand is 15bit instruction accessible, or "lfh!"
1279 'L' low part of DImode reg operand
1280 'H' high part of DImode reg operand
1281 'C' print part of opcode for a branch condition. */
1283 score_print_operand (FILE *file
, rtx op
, int c
)
1285 enum rtx_code code
= UNKNOWN
;
1286 if (!PRINT_OPERAND_PUNCT_VALID_P (c
))
1287 code
= GET_CODE (op
);
1291 fprintf (file
, ".set r1\n");
1295 fprintf (file
, "\n\t.set nor1");
1299 gcc_assert (code
== CONST_INT
);
1300 fprintf (file
, HOST_WIDE_INT_PRINT_HEX
,
1301 (INTVAL (op
) >> 16) & 0xffff);
1305 if (GET_CODE (op
) == CONST_DOUBLE
)
1307 rtx temp
= gen_lowpart (SImode
, op
);
1308 gcc_assert (GET_MODE (op
) == SFmode
);
1309 fprintf (file
, HOST_WIDE_INT_PRINT_HEX
, INTVAL (temp
) & 0xffffffff);
1312 output_addr_const (file
, op
);
1316 gcc_assert (code
== REG
);
1317 if (G16_REG_P (REGNO (op
)))
1318 fprintf (file
, "!");
1322 gcc_assert (code
== REG
);
1323 fprintf (file
, G16_REG_P (REGNO (op
)) ? "v!" : "lfh!");
1327 enum machine_mode mode
= GET_MODE (XEXP (op
, 0));
1331 case EQ
: fputs ("eq", file
); break;
1332 case NE
: fputs ("ne", file
); break;
1333 case GT
: fputs ("gt", file
); break;
1334 case GE
: fputs (mode
!= CCmode
? "pl" : "ge", file
); break;
1335 case LT
: fputs (mode
!= CCmode
? "mi" : "lt", file
); break;
1336 case LE
: fputs ("le", file
); break;
1337 case GTU
: fputs ("gtu", file
); break;
1338 case GEU
: fputs ("cs", file
); break;
1339 case LTU
: fputs ("cc", file
); break;
1340 case LEU
: fputs ("leu", file
); break;
1342 output_operand_lossage ("invalid operand for code: '%c'", code
);
1347 unsigned HOST_WIDE_INT i
;
1348 unsigned HOST_WIDE_INT pow2mask
= 1;
1349 unsigned HOST_WIDE_INT val
;
1352 for (i
= 0; i
< 32; i
++)
1354 if (val
== pow2mask
)
1358 gcc_assert (i
< 32);
1359 fprintf (file
, HOST_WIDE_INT_PRINT_HEX
, i
);
1363 unsigned HOST_WIDE_INT i
;
1364 unsigned HOST_WIDE_INT pow2mask
= 1;
1365 unsigned HOST_WIDE_INT val
;
1368 for (i
= 0; i
< 32; i
++)
1370 if (val
== pow2mask
)
1374 gcc_assert (i
< 32);
1375 fprintf (file
, HOST_WIDE_INT_PRINT_HEX
, i
);
1377 else if (code
== REG
)
1379 int regnum
= REGNO (op
);
1380 if ((c
== 'H' && !WORDS_BIG_ENDIAN
)
1381 || (c
== 'L' && WORDS_BIG_ENDIAN
))
1383 fprintf (file
, "%s", reg_names
[regnum
]);
1390 score_print_operand_address (file
, op
);
1393 output_addr_const (file
, op
);
1398 /* Implement PRINT_OPERAND_ADDRESS macro. */
1400 score_print_operand_address (FILE *file
, rtx x
)
1402 struct score_address_info addr
;
1403 enum rtx_code code
= GET_CODE (x
);
1404 enum machine_mode mode
= GET_MODE (x
);
1409 if (score_classify_address (&addr
, mode
, x
, true))
1418 fprintf (file
, "[%s,-%ld]+", reg_names
[REGNO (addr
.reg
)],
1419 INTVAL (addr
.offset
));
1422 fprintf (file
, "[%s]+,-%ld", reg_names
[REGNO (addr
.reg
)],
1423 INTVAL (addr
.offset
));
1426 fprintf (file
, "[%s, %ld]+", reg_names
[REGNO (addr
.reg
)],
1427 INTVAL (addr
.offset
));
1430 fprintf (file
, "[%s]+, %ld", reg_names
[REGNO (addr
.reg
)],
1431 INTVAL (addr
.offset
));
1434 if (INTVAL(addr
.offset
) == 0)
1435 fprintf(file
, "[%s]", reg_names
[REGNO (addr
.reg
)]);
1437 fprintf(file
, "[%s, %ld]", reg_names
[REGNO (addr
.reg
)],
1438 INTVAL(addr
.offset
));
1443 case SCORE_ADD_CONST_INT
:
1444 case SCORE_ADD_SYMBOLIC
:
1445 output_addr_const (file
, x
);
1449 print_rtl (stderr
, x
);
1453 /* Implement SELECT_CC_MODE macro. */
1455 score_select_cc_mode (enum rtx_code op
, rtx x
, rtx y
)
1457 if ((op
== EQ
|| op
== NE
|| op
== LT
|| op
== GE
)
1459 && GET_MODE (x
) == SImode
)
1461 switch (GET_CODE (x
))
1479 return (op
== LT
|| op
== GE
) ? CC_Nmode
: CCmode
;
1486 if ((op
== EQ
|| op
== NE
)
1487 && (GET_CODE (y
) == NEG
)
1488 && register_operand (XEXP (y
, 0), SImode
)
1489 && register_operand (x
, SImode
))
1497 /* Generate the prologue instructions for entry into a S+core function. */
1499 score_prologue (void)
1501 #define EMIT_PL(_rtx) RTX_FRAME_RELATED_P (_rtx) = 1
1503 struct score_frame_info
*f
= score_compute_frame_size (get_frame_size ());
1507 size
= f
->total_size
- f
->gp_reg_size
;
1510 emit_insn (gen_cpload_score7 ());
1512 for (regno
= (int) GP_REG_LAST
; regno
>= (int) GP_REG_FIRST
; regno
--)
1514 if (BITSET_P (f
->mask
, regno
- GP_REG_FIRST
))
1516 rtx mem
= gen_rtx_MEM (SImode
,
1517 gen_rtx_PRE_DEC (SImode
, stack_pointer_rtx
));
1518 rtx reg
= gen_rtx_REG (SImode
, regno
);
1519 if (!crtl
->calls_eh_return
)
1520 MEM_READONLY_P (mem
) = 1;
1521 EMIT_PL (emit_insn (gen_pushsi_score7 (mem
, reg
)));
1529 if (size
>= -32768 && size
<= 32767)
1530 EMIT_PL (emit_insn (gen_add3_insn (stack_pointer_rtx
,
1535 EMIT_PL (emit_move_insn (gen_rtx_REG (Pmode
, SCORE_PROLOGUE_TEMP_REGNUM
),
1538 (gen_sub3_insn (stack_pointer_rtx
,
1541 SCORE_PROLOGUE_TEMP_REGNUM
))));
1543 insn
= get_last_insn ();
1545 alloc_EXPR_LIST (REG_FRAME_RELATED_EXPR
,
1546 gen_rtx_SET (VOIDmode
, stack_pointer_rtx
,
1547 plus_constant (Pmode
, stack_pointer_rtx
,
1552 if (frame_pointer_needed
)
1553 EMIT_PL (emit_move_insn (hard_frame_pointer_rtx
, stack_pointer_rtx
));
1555 if (flag_pic
&& f
->cprestore_size
)
1557 if (frame_pointer_needed
)
1558 emit_insn (gen_cprestore_use_fp_score7 (GEN_INT (size
- f
->cprestore_size
)));
1560 emit_insn (gen_cprestore_use_sp_score7 (GEN_INT (size
- f
->cprestore_size
)));
1566 /* Generate the epilogue instructions in a S+core function. */
1568 score_epilogue (int sibcall_p
)
1570 struct score_frame_info
*f
= score_compute_frame_size (get_frame_size ());
1575 size
= f
->total_size
- f
->gp_reg_size
;
1577 if (!frame_pointer_needed
)
1578 base
= stack_pointer_rtx
;
1580 base
= hard_frame_pointer_rtx
;
1584 if (size
>= -32768 && size
<= 32767)
1585 emit_insn (gen_add3_insn (base
, base
, GEN_INT (size
)));
1588 emit_move_insn (gen_rtx_REG (Pmode
, SCORE_EPILOGUE_TEMP_REGNUM
),
1590 emit_insn (gen_add3_insn (base
, base
,
1592 SCORE_EPILOGUE_TEMP_REGNUM
)));
1596 if (base
!= stack_pointer_rtx
)
1597 emit_move_insn (stack_pointer_rtx
, base
);
1599 if (crtl
->calls_eh_return
)
1600 emit_insn (gen_add3_insn (stack_pointer_rtx
,
1602 EH_RETURN_STACKADJ_RTX
));
1604 for (regno
= (int) GP_REG_FIRST
; regno
<= (int) GP_REG_LAST
; regno
++)
1606 if (BITSET_P (f
->mask
, regno
- GP_REG_FIRST
))
1608 rtx mem
= gen_rtx_MEM (SImode
,
1609 gen_rtx_POST_INC (SImode
, stack_pointer_rtx
));
1610 rtx reg
= gen_rtx_REG (SImode
, regno
);
1612 if (!crtl
->calls_eh_return
)
1613 MEM_READONLY_P (mem
) = 1;
1615 emit_insn (gen_popsi_score7 (reg
, mem
));
1620 emit_jump_insn (gen_return_internal_score7 (gen_rtx_REG (Pmode
, RA_REGNUM
)));
1623 /* Return true if X is a symbolic constant that can be calculated in
1624 the same way as a bare symbol. If it is, store the type of the
1625 symbol in *SYMBOL_TYPE. */
1627 score_symbolic_constant_p (rtx x
, enum score_symbol_type
*symbol_type
)
1629 HOST_WIDE_INT offset
;
1631 score_split_const (x
, &x
, &offset
);
1632 if (GET_CODE (x
) == SYMBOL_REF
|| GET_CODE (x
) == LABEL_REF
)
1633 *symbol_type
= score_classify_symbol (x
);
1640 /* if offset > 15bit, must reload */
1641 if (!IMM_IN_RANGE (offset
, 15, 1))
1644 switch (*symbol_type
)
1646 case SYMBOL_GENERAL
:
1648 case SYMBOL_SMALL_DATA
:
1649 return score_offset_within_object_p (x
, offset
);
1655 score_movsicc (rtx
*ops
)
1657 enum machine_mode mode
;
1659 mode
= score_select_cc_mode (GET_CODE (ops
[1]), ops
[2], ops
[3]);
1660 emit_insn (gen_rtx_SET (VOIDmode
, gen_rtx_REG (mode
, CC_REGNUM
),
1661 gen_rtx_COMPARE (mode
, XEXP (ops
[1], 0),
1662 XEXP (ops
[1], 1))));
1665 /* Call and sibcall pattern all need call this function. */
1667 score_call (rtx
*ops
, bool sib
)
1669 rtx addr
= XEXP (ops
[0], 0);
1670 if (!call_insn_operand (addr
, VOIDmode
))
1673 addr
= gen_reg_rtx (Pmode
);
1674 gen_move_insn (addr
, oaddr
);
1678 emit_call_insn (gen_sibcall_internal_score7 (addr
, ops
[1]));
1680 emit_call_insn (gen_call_internal_score7 (addr
, ops
[1]));
1683 /* Call value and sibcall value pattern all need call this function. */
1685 score_call_value (rtx
*ops
, bool sib
)
1687 rtx result
= ops
[0];
1688 rtx addr
= XEXP (ops
[1], 0);
1691 if (!call_insn_operand (addr
, VOIDmode
))
1694 addr
= gen_reg_rtx (Pmode
);
1695 gen_move_insn (addr
, oaddr
);
1699 emit_call_insn (gen_sibcall_value_internal_score7 (result
, addr
, arg
));
1701 emit_call_insn (gen_call_value_internal_score7 (result
, addr
, arg
));
1706 score_movdi (rtx
*ops
)
1710 rtx dst0
= score_subw (dst
, 0);
1711 rtx dst1
= score_subw (dst
, 1);
1712 rtx src0
= score_subw (src
, 0);
1713 rtx src1
= score_subw (src
, 1);
1715 if (GET_CODE (dst0
) == REG
&& reg_overlap_mentioned_p (dst0
, src
))
1717 emit_move_insn (dst1
, src1
);
1718 emit_move_insn (dst0
, src0
);
1722 emit_move_insn (dst0
, src0
);
1723 emit_move_insn (dst1
, src1
);
1728 score_zero_extract_andi (rtx
*ops
)
1730 if (INTVAL (ops
[1]) == 1 && const_uimm5 (ops
[2], SImode
))
1731 emit_insn (gen_zero_extract_bittst_score7 (ops
[0], ops
[2]));
1734 unsigned HOST_WIDE_INT mask
;
1735 mask
= (0xffffffffU
& ((1U << INTVAL (ops
[1])) - 1U));
1736 mask
= mask
<< INTVAL (ops
[2]);
1737 emit_insn (gen_andsi3_cmp_score7 (ops
[3], ops
[0],
1738 gen_int_mode (mask
, SImode
)));
1742 /* Check addr could be present as PRE/POST mode. */
1744 score_pindex_mem (rtx addr
)
1746 if (GET_CODE (addr
) == MEM
)
1748 switch (GET_CODE (XEXP (addr
, 0)))
1762 /* Output asm code for ld/sw insn. */
1764 score_pr_addr_post (rtx
*ops
, int idata
, int iaddr
, char *ip
, enum score_mem_unit unit
)
1766 struct score_address_info ai
;
1768 gcc_assert (GET_CODE (ops
[idata
]) == REG
);
1769 gcc_assert (score_classify_address (&ai
, SImode
, XEXP (ops
[iaddr
], 0), true));
1771 if (!score_pindex_mem (ops
[iaddr
])
1772 && ai
.type
== SCORE_ADD_REG
1773 && GET_CODE (ai
.offset
) == CONST_INT
1774 && G16_REG_P (REGNO (ops
[idata
]))
1775 && G16_REG_P (REGNO (ai
.reg
)))
1777 if (INTVAL (ai
.offset
) == 0)
1779 ops
[iaddr
] = ai
.reg
;
1780 return snprintf (ip
, INS_BUF_SZ
,
1781 "!\t%%%d, [%%%d]", idata
, iaddr
);
1783 if (REGNO (ai
.reg
) == HARD_FRAME_POINTER_REGNUM
)
1785 HOST_WIDE_INT offset
= INTVAL (ai
.offset
);
1786 if (SCORE_ALIGN_UNIT (offset
, unit
)
1787 && (((offset
>> unit
) >= 0) && ((offset
>> unit
) <= 31)))
1789 ops
[iaddr
] = ai
.offset
;
1790 return snprintf (ip
, INS_BUF_SZ
,
1791 "p!\t%%%d, %%c%d", idata
, iaddr
);
1795 return snprintf (ip
, INS_BUF_SZ
, "\t%%%d, %%a%d", idata
, iaddr
);
1798 /* Output asm insn for load. */
1800 score_linsn (rtx
*ops
, enum score_mem_unit unit
, bool sign
)
1802 const char *pre_ins
[] =
1803 {"lbu", "lhu", "lw", "??", "lb", "lh", "lw", "??"};
1806 strcpy (score_ins
, pre_ins
[(sign
? 4 : 0) + unit
]);
1807 ip
= score_ins
+ strlen (score_ins
);
1809 if ((!sign
&& unit
!= SCORE_HWORD
)
1810 || (sign
&& unit
!= SCORE_BYTE
))
1811 score_pr_addr_post (ops
, 0, 1, ip
, unit
);
1813 snprintf (ip
, INS_BUF_SZ
, "\t%%0, %%a1");
1818 /* Output asm insn for store. */
1820 score_sinsn (rtx
*ops
, enum score_mem_unit unit
)
1822 const char *pre_ins
[] = {"sb", "sh", "sw"};
1825 strcpy (score_ins
, pre_ins
[unit
]);
1826 ip
= score_ins
+ strlen (score_ins
);
1827 score_pr_addr_post (ops
, 1, 0, ip
, unit
);
1831 /* Output asm insn for load immediate. */
1833 score_limm (rtx
*ops
)
1837 gcc_assert (GET_CODE (ops
[0]) == REG
);
1838 gcc_assert (GET_CODE (ops
[1]) == CONST_INT
);
1840 v
= INTVAL (ops
[1]);
1841 if (G16_REG_P (REGNO (ops
[0])) && IMM_IN_RANGE (v
, 8, 0))
1842 return "ldiu!\t%0, %c1";
1843 else if (IMM_IN_RANGE (v
, 16, 1))
1844 return "ldi\t%0, %c1";
1845 else if ((v
& 0xffff) == 0)
1846 return "ldis\t%0, %U1";
1848 return "li\t%0, %c1";
1851 /* Output asm insn for move. */
1853 score_move (rtx
*ops
)
1855 gcc_assert (GET_CODE (ops
[0]) == REG
);
1856 gcc_assert (GET_CODE (ops
[1]) == REG
);
1858 if (G16_REG_P (REGNO (ops
[0])))
1860 if (G16_REG_P (REGNO (ops
[1])))
1861 return "mv!\t%0, %1";
1863 return "mlfh!\t%0, %1";
1865 else if (G16_REG_P (REGNO (ops
[1])))
1866 return "mhfl!\t%0, %1";
1868 return "mv\t%0, %1";
1871 /* Generate add insn. */
1873 score_select_add_imm (rtx
*ops
, bool set_cc
)
1875 HOST_WIDE_INT v
= INTVAL (ops
[2]);
1877 gcc_assert (GET_CODE (ops
[2]) == CONST_INT
);
1878 gcc_assert (REGNO (ops
[0]) == REGNO (ops
[1]));
1880 if (set_cc
&& G16_REG_P (REGNO (ops
[0])))
1882 if (v
> 0 && IMM_IS_POW_OF_2 ((unsigned HOST_WIDE_INT
) v
, 0, 15))
1884 ops
[2] = GEN_INT (ffs (v
) - 1);
1885 return "addei!\t%0, %c2";
1888 if (v
< 0 && IMM_IS_POW_OF_2 ((unsigned HOST_WIDE_INT
) (-v
), 0, 15))
1890 ops
[2] = GEN_INT (ffs (-v
) - 1);
1891 return "subei!\t%0, %c2";
1896 return "addi.c\t%0, %c2";
1898 return "addi\t%0, %c2";
1901 /* Output arith insn. */
1903 score_select (rtx
*ops
, const char *inst_pre
,
1904 bool commu
, const char *letter
, bool set_cc
)
1906 gcc_assert (GET_CODE (ops
[0]) == REG
);
1907 gcc_assert (GET_CODE (ops
[1]) == REG
);
1909 if (set_cc
&& G16_REG_P (REGNO (ops
[0]))
1910 && (GET_CODE (ops
[2]) == REG
? G16_REG_P (REGNO (ops
[2])) : 1)
1911 && REGNO (ops
[0]) == REGNO (ops
[1]))
1913 snprintf (score_ins
, INS_BUF_SZ
, "%s!\t%%0, %%%s2", inst_pre
, letter
);
1917 if (commu
&& set_cc
&& G16_REG_P (REGNO (ops
[0]))
1918 && G16_REG_P (REGNO (ops
[1]))
1919 && REGNO (ops
[0]) == REGNO (ops
[2]))
1921 gcc_assert (GET_CODE (ops
[2]) == REG
);
1922 snprintf (score_ins
, INS_BUF_SZ
, "%s!\t%%0, %%%s1", inst_pre
, letter
);
1927 snprintf (score_ins
, INS_BUF_SZ
, "%s.c\t%%0, %%1, %%%s2", inst_pre
, letter
);
1929 snprintf (score_ins
, INS_BUF_SZ
, "%s\t%%0, %%1, %%%s2", inst_pre
, letter
);
1933 /* Return nonzero when an argument must be passed by reference. */
1935 score_pass_by_reference (cumulative_args_t cum ATTRIBUTE_UNUSED
,
1936 enum machine_mode mode
, const_tree type
,
1937 bool named ATTRIBUTE_UNUSED
)
1939 /* If we have a variable-sized parameter, we have no choice. */
1940 return targetm
.calls
.must_pass_in_stack (mode
, type
);
1943 /* Implement TARGET_FUNCTION_OK_FOR_SIBCALL. */
1945 score_function_ok_for_sibcall (ATTRIBUTE_UNUSED tree decl
,
1946 ATTRIBUTE_UNUSED tree exp
)
1951 /* Implement TARGET_SCHED_ISSUE_RATE. */
1953 score_issue_rate (void)
1958 /* We can always eliminate to the hard frame pointer. We can eliminate
1959 to the stack pointer unless a frame pointer is needed. */
1962 score_can_eliminate (const int from ATTRIBUTE_UNUSED
, const int to
)
1964 return (to
== HARD_FRAME_POINTER_REGNUM
1965 || (to
== STACK_POINTER_REGNUM
&& !frame_pointer_needed
));
1968 /* Argument support functions. */
1970 /* Initialize CUMULATIVE_ARGS for a function. */
1972 score_init_cumulative_args (CUMULATIVE_ARGS
*cum
,
1973 tree fntype ATTRIBUTE_UNUSED
,
1974 rtx libname ATTRIBUTE_UNUSED
)
1976 memset (cum
, 0, sizeof (CUMULATIVE_ARGS
));
1980 score_conditional_register_usage (void)
1983 fixed_regs
[PIC_OFFSET_TABLE_REGNUM
] =
1984 call_used_regs
[PIC_OFFSET_TABLE_REGNUM
] = 0;
1987 struct gcc_target targetm
= TARGET_INITIALIZER
;