[thirdparty/gcc.git] / gcc / config / tilepro / tilepro.h

/* Definitions of target machine for GNU compiler for TILEPro.
   Copyright (C) 2011-2017 Free Software Foundation, Inc.
   Contributed by Walter Lee (walt@tilera.com)

   This file is part of GCC.

   GCC is free software; you can redistribute it and/or modify it
   under the terms of the GNU General Public License as published
   by the Free Software Foundation; either version 3, or (at your
   option) any later version.

   GCC is distributed in the hope that it will be useful, but WITHOUT
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
   License for more details.

   You should have received a copy of the GNU General Public License
   along with GCC; see the file COPYING3.  If not see
   <http://www.gnu.org/licenses/>.  */

/* This is used by tilepro_cpu_cpp_builtins to indicate the byte order
   we're compiling for.  */
#define TILEPRO_CPU_CPP_ENDIAN_BUILTINS()	\
  do						\
    {						\
      if (BYTES_BIG_ENDIAN)			\
	builtin_define ("__BIG_ENDIAN__");	\
      else					\
	builtin_define ("__LITTLE_ENDIAN__");	\
    }						\
  while (0)

/* Target CPU builtins.  */
#define TARGET_CPU_CPP_BUILTINS() \
  tilepro_cpu_cpp_builtins (pfile)

#undef PTRDIFF_TYPE
#define PTRDIFF_TYPE "int"

#undef SIZE_TYPE
#define SIZE_TYPE "unsigned int"
\f

/* Target machine storage layout */

#define BITS_BIG_ENDIAN 0
#define BYTES_BIG_ENDIAN 0
#define WORDS_BIG_ENDIAN 0

#define UNITS_PER_WORD 4
#define PARM_BOUNDARY 32
#define STACK_BOUNDARY 64
#define FUNCTION_BOUNDARY 64
#define BIGGEST_ALIGNMENT 64
#define STRICT_ALIGNMENT 1

#define PCC_BITFIELD_TYPE_MATTERS 1
#define FASTEST_ALIGNMENT 32
#define BIGGEST_FIELD_ALIGNMENT 64

/* Unaligned moves trap and are very slow.  */
#define SLOW_UNALIGNED_ACCESS(MODE, ALIGN) 1

/* Make strings word-aligned so strcpy from constants will be
   faster.  */
#define CONSTANT_ALIGNMENT(EXP, ALIGN)  \
  ((TREE_CODE (EXP) == STRING_CST	\
    && (ALIGN) < FASTEST_ALIGNMENT)	\
   ? FASTEST_ALIGNMENT : (ALIGN))

/* Make arrays of chars word-aligned for the same reasons.  */
#define DATA_ALIGNMENT(TYPE, ALIGN)		\
  (TREE_CODE (TYPE) == ARRAY_TYPE		\
   && TYPE_MODE (TREE_TYPE (TYPE)) == QImode	\
   && (ALIGN) < FASTEST_ALIGNMENT ? FASTEST_ALIGNMENT : (ALIGN))

/* Make local arrays of chars word-aligned for the same reasons.  */
#define LOCAL_ALIGNMENT(TYPE, ALIGN) DATA_ALIGNMENT (TYPE, ALIGN)
\f

/* Standard register usage.  */

#define FIRST_PSEUDO_REGISTER (64 + 3)

#define FIXED_REGISTERS \
 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
  0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, \
  1, 1, 1}

#define CALL_USED_REGISTERS \
 {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, \
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
  0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
  1, 1, 1}

#define CALL_REALLY_USED_REGISTERS \
 CALL_USED_REGISTERS

#define REG_ALLOC_ORDER {				\
      10, 11, 12, 13, 14, /* call used */		\
      15, 16, 17, 18, 19,				\
      20, 21, 22, 23, 24,				\
      25, 26, 27, 28, 29,				\
							\
      9, 8, 7, 6, 5,      /* argument */		\
      4, 3, 2, 1, 0,					\
							\
      55,	          /* return address */		\
							\
      30, 31, 32, 33, 34, /* call saved registers */	\
      35, 36, 37, 38, 39,				\
      40, 41, 42, 43, 44,				\
      45, 46, 47, 48, 49,				\
      50, 51,						\
							\
      52, 		  /* hard frame pointer */	\
      53, 54, 		  /* tp, sp */			\
							\
      56, 57, 58, 59, 60, /* special purpose */		\
      61, 62, 63, 64, 65, /* or fake registers */	\
      66						\
}

#define HARD_REGNO_NREGS(REGNO, MODE)	\
  ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)

#define MODES_TIEABLE_P(MODE1, MODE2)  1

/* Register that holds an address into the text segment that can be
   used by pic code.  */
#define TILEPRO_PIC_TEXT_LABEL_REGNUM (flag_pic ? 50 : INVALID_REGNUM)
#define PIC_OFFSET_TABLE_REGNUM (flag_pic ? 51 : INVALID_REGNUM)
#define HARD_FRAME_POINTER_REGNUM 52
#define THREAD_POINTER_REGNUM 53
#define STACK_POINTER_REGNUM 54
#define TILEPRO_LINK_REGNUM 55
#define FRAME_POINTER_REGNUM 64
#define ARG_POINTER_REGNUM 65
/* Pseudo register used to enforce order between instructions that
   touch the networks.  */
#define TILEPRO_NETORDER_REGNUM 66
#define STATIC_CHAIN_REGNUM 10
\f

enum reg_class
{
  NO_REGS,
  R0_REGS,
  R1_REGS,
  R2_REGS,
  R3_REGS,
  R4_REGS,
  R5_REGS,
  R6_REGS,
  R7_REGS,
  R8_REGS,
  R9_REGS,
  R10_REGS,
  ALL_REGS,
  LIM_REG_CLASSES
};

#define N_REG_CLASSES (int) LIM_REG_CLASSES

/* Since GENERAL_REGS is the same class as ALL_REGS, don't give it a
   different class number; just make it an alias.  */
#define GENERAL_REGS ALL_REGS

#define REG_CLASS_NAMES	\
  { \
    "NO_REGS", \
    "R0_REGS", \
    "R1_REGS", \
    "R2_REGS", \
    "R3_REGS", \
    "R4_REGS", \
    "R5_REGS", \
    "R6_REGS", \
    "R7_REGS", \
    "R8_REGS", \
    "R9_REGS", \
    "R10_REGS", \
    "ALL_REGS" \
  }

#define REG_CLASS_CONTENTS \
  { \
    { 0 }, \
    { 1 << 0 }, \
    { 1 << 1 }, \
    { 1 << 2 }, \
    { 1 << 3 }, \
    { 1 << 4 }, \
    { 1 << 5 }, \
    { 1 << 6 }, \
    { 1 << 7 }, \
    { 1 << 8 }, \
    { 1 << 9 }, \
    { 1 << 10 }, \
    { 0xffffffff, 0xffffffff } \
  }

#define REGNO_REG_CLASS(REGNO) \
  ((unsigned)(REGNO) <= 10 ? \
   (enum reg_class)(R0_REGS + (REGNO)) : ALL_REGS)

#define INDEX_REG_CLASS NO_REGS
#define BASE_REG_CLASS ALL_REGS

#define PREFERRED_RELOAD_CLASS(X,CLASS)  (CLASS)

#define CLASS_MAX_NREGS(CLASS, MODE)	\
 ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
\f

/* Stack layout; function entry, exit and calling.  */

#define STACK_GROWS_DOWNWARD 1
#define FRAME_GROWS_DOWNWARD 1
#define STARTING_FRAME_OFFSET 0

#define DYNAMIC_CHAIN_ADDRESS(FRAME) \
  plus_constant (Pmode, (FRAME), UNITS_PER_WORD)

#define FIRST_PARM_OFFSET(FNDECL) 0

#define ACCUMULATE_OUTGOING_ARGS 1

#define OUTGOING_REG_PARM_STACK_SPACE(FNTYPE) 1

#define INCOMING_FRAME_SP_OFFSET 0

#define STACK_POINTER_OFFSET (2 * UNITS_PER_WORD)

#define ARG_POINTER_CFA_OFFSET(FNDECL) (-STACK_POINTER_OFFSET)

#define DEFAULT_PCC_STRUCT_RETURN 0

/* The first 10 registers may hold return value.  */
#define TILEPRO_NUM_RETURN_REGS 10

/* The first 10 registers hold function arguments.  */
#define TILEPRO_NUM_ARG_REGS 10

#define FUNCTION_ARG_REGNO_P(N) ((N) < TILEPRO_NUM_ARG_REGS)

/* The type used to store the number of words of arguments scanned so
   far during argument scanning.  This includes any space that is
   skipped.  */
#define CUMULATIVE_ARGS int

#define INIT_CUMULATIVE_ARGS(CUM, FNTYPE, LIBNAME, INDIRECT, N_NAMED_ARGS) \
 ((CUM) = 0)
\f

#define ELIMINABLE_REGS					\
  {{ARG_POINTER_REGNUM,	 STACK_POINTER_REGNUM},		\
  {ARG_POINTER_REGNUM,	 HARD_FRAME_POINTER_REGNUM},	\
  {FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM},		\
  {FRAME_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM}}

#define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET) \
  ((OFFSET) = tilepro_initial_elimination_offset((FROM),(TO)))

#define PROFILE_BEFORE_PROLOGUE 1

#define FUNCTION_PROFILER(FILE, LABELNO) \
  tilepro_function_profiler (FILE, LABELNO)

#define TRAMPOLINE_SIZE 48
#define TRAMPOLINE_ALIGNMENT 64
#define TRAMPOLINE_SECTION text_section
\f

/* Call frame debugging information.  */

#define INCOMING_RETURN_ADDR_RTX gen_rtx_REG (Pmode, TILEPRO_LINK_REGNUM)

#define RETURN_ADDR_RTX tilepro_return_addr

#define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (TILEPRO_LINK_REGNUM)

#define DWARF_ZERO_REG 63

#define EH_RETURN_DATA_REGNO(N) ((N) < 4 ? (N + 12) : INVALID_REGNUM)
#define EH_RETURN_STACKADJ_RTX	gen_rtx_REG (Pmode, 11)
#define EH_RETURN_HANDLER_RTX tilepro_eh_return_handler_rtx ()

#define ASM_PREFERRED_EH_DATA_FORMAT(CODE,GLOBAL) \
  tilepro_asm_preferred_eh_data_format ((CODE), (GLOBAL))
\f

/* Addressing modes, and classification of registers for them.  */

#define HAVE_POST_INCREMENT 1
#define HAVE_POST_DECREMENT 1
#define HAVE_POST_MODIFY_DISP 1

#define REGNO_OK_FOR_INDEX_P(regno) 0
#define REGNO_OK_FOR_BASE_P(regno)	\
  ((regno) < FIRST_PSEUDO_REGISTER || reg_renumber[regno] >= 0)

#define MAX_REGS_PER_ADDRESS 1

#define CONSTANT_ADDRESS_P(X) 0

#define LEGITIMATE_PIC_OPERAND_P(X) tilepro_legitimate_pic_operand_p (X)
\f

#define CASE_VECTOR_MODE SImode
#define CASE_VECTOR_PC_RELATIVE 0
#define JUMP_TABLES_IN_TEXT_SECTION 0

#define DEFAULT_SIGNED_CHAR 1

#define MOVE_MAX UNITS_PER_WORD

/* Use a value of 11 for MOVE_RATIO and friends, because TILEPro
   returns structs as large as 10 words in registers.  Because of some
   some code generation inefficiency, we never get smaller code for
   turning that into a memcpy, so pick a value that guarantees this
   doesn't happen.  */
#define TILEPRO_CALL_RATIO 11
#define MOVE_RATIO(speed) ((speed) ? 15 : TILEPRO_CALL_RATIO)
#define CLEAR_RATIO(speed) ((speed) ? 15 : TILEPRO_CALL_RATIO)
#define SET_RATIO(speed) ((speed) ? 15 : TILEPRO_CALL_RATIO)

#define WORD_REGISTER_OPERATIONS 1

#define LOAD_EXTEND_OP(MODE) ZERO_EXTEND

#define PROMOTE_MODE(MODE,UNSIGNEDP,TYPE)	\
  if (GET_MODE_CLASS (MODE) == MODE_INT		\
      && GET_MODE_SIZE (MODE) < UNITS_PER_WORD) \
    (MODE) = SImode;

/* Define SLOW_BYTE_ACCESS to avoid making a QI or HI mode
   register.  */
#define SLOW_BYTE_ACCESS 1

#define SHIFT_COUNT_TRUNCATED 1

#define SHORT_IMMEDIATES_SIGN_EXTEND 1

#define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1

#define CLZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE) ((VALUE) = 32, 1)
#define CTZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE) ((VALUE) = 32, 1)

#define Pmode SImode

#define STORE_FLAG_VALUE 1

#define FUNCTION_MODE SImode

#define NO_FUNCTION_CSE 1

#define ADJUST_INSN_LENGTH(INSN, LENGTH) \
  ((LENGTH) = tilepro_adjust_insn_length ((INSN), (LENGTH)))

#define TARGET_FLOAT_FORMAT IEEE_FLOAT_FORMAT

#define BRANCH_COST(speed_p, predictable_p) ((predictable_p) ? 2 : 6)
\f

/* Control the assembler format that we output.  */

#undef NO_DOLLAR_IN_LABEL

#define ASM_COMMENT_START "##"

#define TEXT_SECTION_ASM_OP "\t.text"

#define DATA_SECTION_ASM_OP "\t.data"

#undef READONLY_DATA_SECTION_ASM_OP
#define READONLY_DATA_SECTION_ASM_OP "\t.section\t.rodata, \"a\""

#undef BSS_SECTION_ASM_OP
#define BSS_SECTION_ASM_OP	"\t.section\t.bss, \"wa\""

#undef INIT_SECTION_ASM_OP
#define INIT_SECTION_ASM_OP	"\t.section\t.init, \"ax\""

#undef FINI_SECTION_ASM_OP
#define FINI_SECTION_ASM_OP	"\t.section\t.fini, \"ax\""

#define GLOBAL_ASM_OP ".global "

#define SUPPORTS_WEAK 1

#define USER_LABEL_PREFIX ""

#define REGISTER_PREFIX ""
#define REGISTER_NAMES                                                  \
  { "r0",   "r1",   "r2",   "r3",   "r4",   "r5",   "r6",   "r7",       \
    "r8",   "r9",   "r10",  "r11",  "r12",  "r13",  "r14",  "r15",      \
    "r16",  "r17",  "r18",  "r19",  "r20",  "r21",  "r22",  "r23",      \
    "r24",  "r25",  "r26",  "r27",  "r28",  "r29",  "r30",  "r31",      \
    "r32",  "r33",  "r34",  "r35",  "r36",  "r37",  "r38",  "r39",      \
    "r40",  "r41",  "r42",  "r43",  "r44",  "r45",  "r46",  "r47",      \
    "r48",  "r49",  "r50",  "r51",  "r52",  "tp",   "sp",   "lr",       \
    "sn",   "idn0", "idn1", "udn0", "udn1", "udn2", "udn3", "zero",     \
    "?FRAME?", "?ARG?", "?NET?" }

/* This is used to help emit bundles.  */
#define FINAL_PRESCAN_INSN(INSN, OPVEC, NOPERANDS) \
  tilepro_final_prescan_insn (insn)

/* This is used to help emit bundles.  */
#define ASM_OUTPUT_OPCODE(STREAM, PTR)	\
  (PTR = tilepro_asm_output_opcode (STREAM, PTR))

#define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE)		\
  do							\
    {							\
      char label[256];					\
      ASM_GENERATE_INTERNAL_LABEL (label, "L", (VALUE));\
      fprintf (FILE, "\t.word ");			\
      assemble_name (FILE, label);			\
      fprintf (FILE, "\n");				\
    }							\
  while (0)

#define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, BODY, VALUE, REL)	\
  do								\
    {								\
      char label[256];						\
      ASM_GENERATE_INTERNAL_LABEL (label, "L", (VALUE));	\
      fprintf (FILE, "\t.word ");				\
      assemble_name (FILE, label);				\
      ASM_GENERATE_INTERNAL_LABEL (label, "L", (REL));		\
      fprintf (FILE, "-");					\
      assemble_name (FILE, label);				\
      fprintf (FILE, "\n");					\
    }								\
  while (0)

#define ASM_OUTPUT_ALIGN(FILE,LOG)  \
  do { if ((LOG) != 0) fprintf (FILE, "\t.align %d\n", 1 << (LOG)); } while (0)

#define ASM_OUTPUT_COMMON(FILE, NAME, SIZE, ROUNDED)	\
  ( fputs (".comm ", (FILE)),				\
    assemble_name ((FILE), (NAME)),			\
    fprintf ((FILE), ",%u\n", (unsigned int)(ROUNDED)))

#define ASM_OUTPUT_LOCAL(FILE, NAME, SIZE, ROUNDED)	\
  ( fputs (".lcomm ", (FILE)),				\
    assemble_name ((FILE), (NAME)),			\
    fprintf ((FILE), ",%u\n", (unsigned int)(ROUNDED)))

\f

#define INIT_EXPANDERS tilepro_init_expanders ()

/* A C structure for machine-specific, per-function data.  This is
   added to the cfun structure.  */
typedef struct GTY(()) machine_function
{
  /* Symbol for the text label used for pic.  */
  rtx text_label_symbol;

  /* Register for the text label.  */
  rtx text_label_rtx;

  /* Register for the pic offset table.  */
  rtx got_rtx;

  /* The function calls tls_get_addr.  */
  int calls_tls_get_addr;
} machine_function;

#ifndef HAVE_AS_TLS
#define HAVE_AS_TLS 0
#endif
Commit	Line	Data
7ce78e23	1	/* Definitions of target machine for GNU compiler for TILEPro.
aad93da1	2	Copyright (C) 2011-2017 Free Software Foundation, Inc.
7ce78e23	3	Contributed by Walter Lee (walt@tilera.com)
	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	/* This is used by tilepro_cpu_cpp_builtins to indicate the byte order
	22	we're compiling for. */
	23	#define TILEPRO_CPU_CPP_ENDIAN_BUILTINS() \
	24	do \
	25	{ \
	26	if (BYTES_BIG_ENDIAN) \
	27	builtin_define ("__BIG_ENDIAN__"); \
	28	else \
	29	builtin_define ("__LITTLE_ENDIAN__"); \
	30	} \
	31	while (0)
	32
	33	/* Target CPU builtins. */
	34	#define TARGET_CPU_CPP_BUILTINS() \
	35	tilepro_cpu_cpp_builtins (pfile)
	36
	37	#undef PTRDIFF_TYPE
	38	#define PTRDIFF_TYPE "int"
	39
	40	#undef SIZE_TYPE
	41	#define SIZE_TYPE "unsigned int"
	42	\f
	43
	44	/* Target machine storage layout */
	45
	46	#define BITS_BIG_ENDIAN 0
	47	#define BYTES_BIG_ENDIAN 0
	48	#define WORDS_BIG_ENDIAN 0
	49
	50	#define UNITS_PER_WORD 4
	51	#define PARM_BOUNDARY 32
	52	#define STACK_BOUNDARY 64
	53	#define FUNCTION_BOUNDARY 64
	54	#define BIGGEST_ALIGNMENT 64
	55	#define STRICT_ALIGNMENT 1
	56
	57	#define PCC_BITFIELD_TYPE_MATTERS 1
	58	#define FASTEST_ALIGNMENT 32
	59	#define BIGGEST_FIELD_ALIGNMENT 64
	60
	61	/* Unaligned moves trap and are very slow. */
	62	#define SLOW_UNALIGNED_ACCESS(MODE, ALIGN) 1
	63
	64	/* Make strings word-aligned so strcpy from constants will be
	65	faster. */
	66	#define CONSTANT_ALIGNMENT(EXP, ALIGN) \
67	((TREE_CODE (EXP) == STRING_CST \
68	&& (ALIGN) < FASTEST_ALIGNMENT) \
69	? FASTEST_ALIGNMENT : (ALIGN))
70
71	/* Make arrays of chars word-aligned for the same reasons. */
72	#define DATA_ALIGNMENT(TYPE, ALIGN) \
73	(TREE_CODE (TYPE) == ARRAY_TYPE \
74	&& TYPE_MODE (TREE_TYPE (TYPE)) == QImode \
75	&& (ALIGN) < FASTEST_ALIGNMENT ? FASTEST_ALIGNMENT : (ALIGN))
76
77	/* Make local arrays of chars word-aligned for the same reasons. */
78	#define LOCAL_ALIGNMENT(TYPE, ALIGN) DATA_ALIGNMENT (TYPE, ALIGN)
79	\f
80
81	/* Standard register usage. */
82
83	#define FIRST_PSEUDO_REGISTER (64 + 3)
84
85	#define FIXED_REGISTERS \
86	{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
87	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
88	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
89	0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, \
90	1, 1, 1}
91
92	#define CALL_USED_REGISTERS \
93	{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
94	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, \
95	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
96	0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
97	1, 1, 1}
98
99	#define CALL_REALLY_USED_REGISTERS \
100	CALL_USED_REGISTERS
101
102	#define REG_ALLOC_ORDER { \
103	10, 11, 12, 13, 14, /* call used */ \
104	15, 16, 17, 18, 19, \
105	20, 21, 22, 23, 24, \
106	25, 26, 27, 28, 29, \
107	\
108	9, 8, 7, 6, 5, /* argument */ \
109	4, 3, 2, 1, 0, \
110	\
111	55, /* return address */ \
112	\
113	30, 31, 32, 33, 34, /* call saved registers */ \
114	35, 36, 37, 38, 39, \
115	40, 41, 42, 43, 44, \
116	45, 46, 47, 48, 49, \
117	50, 51, \
118	\
119	52, /* hard frame pointer */ \
120	53, 54, /* tp, sp */ \
121	\
122	56, 57, 58, 59, 60, /* special purpose */ \
123	61, 62, 63, 64, 65, /* or fake registers */ \
124	66 \
125	}
126
127	#define HARD_REGNO_NREGS(REGNO, MODE) \
128	((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
129
7ce78e23	130	#define MODES_TIEABLE_P(MODE1, MODE2) 1
	131
	132	/* Register that holds an address into the text segment that can be
	133	used by pic code. */
	134	#define TILEPRO_PIC_TEXT_LABEL_REGNUM (flag_pic ? 50 : INVALID_REGNUM)
	135	#define PIC_OFFSET_TABLE_REGNUM (flag_pic ? 51 : INVALID_REGNUM)
	136	#define HARD_FRAME_POINTER_REGNUM 52
	137	#define THREAD_POINTER_REGNUM 53
	138	#define STACK_POINTER_REGNUM 54
	139	#define TILEPRO_LINK_REGNUM 55
	140	#define FRAME_POINTER_REGNUM 64
	141	#define ARG_POINTER_REGNUM 65
	142	/* Pseudo register used to enforce order between instructions that
	143	touch the networks. */
	144	#define TILEPRO_NETORDER_REGNUM 66
	145	#define STATIC_CHAIN_REGNUM 10
	146	\f
	147
	148	enum reg_class
	149	{
	150	NO_REGS,
	151	R0_REGS,
	152	R1_REGS,
	153	R2_REGS,
	154	R3_REGS,
	155	R4_REGS,
	156	R5_REGS,
	157	R6_REGS,
	158	R7_REGS,
	159	R8_REGS,
	160	R9_REGS,
	161	R10_REGS,
	162	ALL_REGS,
	163	LIM_REG_CLASSES
	164	};
	165
	166	#define N_REG_CLASSES (int) LIM_REG_CLASSES
	167
	168	/* Since GENERAL_REGS is the same class as ALL_REGS, don't give it a
	169	different class number; just make it an alias. */
	170	#define GENERAL_REGS ALL_REGS
	171
	172	#define REG_CLASS_NAMES \
	173	{ \
	174	"NO_REGS", \
	175	"R0_REGS", \
	176	"R1_REGS", \
	177	"R2_REGS", \
	178	"R3_REGS", \
	179	"R4_REGS", \
	180	"R5_REGS", \
	181	"R6_REGS", \
	182	"R7_REGS", \
	183	"R8_REGS", \
	184	"R9_REGS", \
	185	"R10_REGS", \
	186	"ALL_REGS" \
	187	}
	188
	189	#define REG_CLASS_CONTENTS \
	190	{ \
	191	{ 0 }, \
	192	{ 1 << 0 }, \
	193	{ 1 << 1 }, \
194	{ 1 << 2 }, \
195	{ 1 << 3 }, \
196	{ 1 << 4 }, \
197	{ 1 << 5 }, \
198	{ 1 << 6 }, \
199	{ 1 << 7 }, \
200	{ 1 << 8 }, \
201	{ 1 << 9 }, \
202	{ 1 << 10 }, \
203	{ 0xffffffff, 0xffffffff } \
204	}
205
206	#define REGNO_REG_CLASS(REGNO) \
207	((unsigned)(REGNO) <= 10 ? \
208	(enum reg_class)(R0_REGS + (REGNO)) : ALL_REGS)
209
210	#define INDEX_REG_CLASS NO_REGS
211	#define BASE_REG_CLASS ALL_REGS
212
213	#define PREFERRED_RELOAD_CLASS(X,CLASS) (CLASS)
214
215	#define CLASS_MAX_NREGS(CLASS, MODE) \
216	((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
217	\f
218
219	/* Stack layout; function entry, exit and calling. */
220
2b785411	221	#define STACK_GROWS_DOWNWARD 1
7ce78e23	222	#define FRAME_GROWS_DOWNWARD 1
	223	#define STARTING_FRAME_OFFSET 0
	224
29c05e22	225	#define DYNAMIC_CHAIN_ADDRESS(FRAME) \
29c05e22	226	plus_constant (Pmode, (FRAME), UNITS_PER_WORD)
7ce78e23	227
	228	#define FIRST_PARM_OFFSET(FNDECL) 0
	229
	230	#define ACCUMULATE_OUTGOING_ARGS 1
	231
	232	#define OUTGOING_REG_PARM_STACK_SPACE(FNTYPE) 1
	233
	234	#define INCOMING_FRAME_SP_OFFSET 0
	235
	236	#define STACK_POINTER_OFFSET (2 * UNITS_PER_WORD)
	237
	238	#define ARG_POINTER_CFA_OFFSET(FNDECL) (-STACK_POINTER_OFFSET)
	239
	240	#define DEFAULT_PCC_STRUCT_RETURN 0
	241
	242	/* The first 10 registers may hold return value. */
	243	#define TILEPRO_NUM_RETURN_REGS 10
	244
	245	/* The first 10 registers hold function arguments. */
	246	#define TILEPRO_NUM_ARG_REGS 10
	247
	248	#define FUNCTION_ARG_REGNO_P(N) ((N) < TILEPRO_NUM_ARG_REGS)
	249
	250	/* The type used to store the number of words of arguments scanned so
	251	far during argument scanning. This includes any space that is
	252	skipped. */
	253	#define CUMULATIVE_ARGS int
	254
	255	#define INIT_CUMULATIVE_ARGS(CUM, FNTYPE, LIBNAME, INDIRECT, N_NAMED_ARGS) \
	256	((CUM) = 0)
	257	\f
	258
	259	#define ELIMINABLE_REGS \
	260	{{ARG_POINTER_REGNUM, STACK_POINTER_REGNUM}, \
	261	{ARG_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM}, \
	262	{FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM}, \
	263	{FRAME_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM}}
	264
	265	#define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET) \
	266	((OFFSET) = tilepro_initial_elimination_offset((FROM),(TO)))
	267
684c0f06	268	#define PROFILE_BEFORE_PROLOGUE 1
684c0f06	269
7ce78e23	270	#define FUNCTION_PROFILER(FILE, LABELNO) \
	271	tilepro_function_profiler (FILE, LABELNO)
	272
	273	#define TRAMPOLINE_SIZE 48
	274	#define TRAMPOLINE_ALIGNMENT 64
	275	#define TRAMPOLINE_SECTION text_section
	276	\f
	277
	278	/* Call frame debugging information. */
	279
	280	#define INCOMING_RETURN_ADDR_RTX gen_rtx_REG (Pmode, TILEPRO_LINK_REGNUM)
	281
	282	#define RETURN_ADDR_RTX tilepro_return_addr
	283
	284	#define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (TILEPRO_LINK_REGNUM)
	285
	286	#define DWARF_ZERO_REG 63
	287
	288	#define EH_RETURN_DATA_REGNO(N) ((N) < 4 ? (N + 12) : INVALID_REGNUM)
	289	#define EH_RETURN_STACKADJ_RTX gen_rtx_REG (Pmode, 11)
	290	#define EH_RETURN_HANDLER_RTX tilepro_eh_return_handler_rtx ()
	291
	292	#define ASM_PREFERRED_EH_DATA_FORMAT(CODE,GLOBAL) \
	293	tilepro_asm_preferred_eh_data_format ((CODE), (GLOBAL))
	294	\f
	295
	296	/* Addressing modes, and classification of registers for them. */
	297
	298	#define HAVE_POST_INCREMENT 1
	299	#define HAVE_POST_DECREMENT 1
	300	#define HAVE_POST_MODIFY_DISP 1
	301
	302	#define REGNO_OK_FOR_INDEX_P(regno) 0
	303	#define REGNO_OK_FOR_BASE_P(regno) \
	304	((regno) < FIRST_PSEUDO_REGISTER \|\| reg_renumber[regno] >= 0)
	305
	306	#define MAX_REGS_PER_ADDRESS 1
	307
	308	#define CONSTANT_ADDRESS_P(X) 0
	309
	310	#define LEGITIMATE_PIC_OPERAND_P(X) tilepro_legitimate_pic_operand_p (X)
	311	\f
	312
	313	#define CASE_VECTOR_MODE SImode
	314	#define CASE_VECTOR_PC_RELATIVE 0
	315	#define JUMP_TABLES_IN_TEXT_SECTION 0
	316
	317	#define DEFAULT_SIGNED_CHAR 1
	318
	319	#define MOVE_MAX UNITS_PER_WORD
	320
	321	/* Use a value of 11 for MOVE_RATIO and friends, because TILEPro
	322	returns structs as large as 10 words in registers. Because of some
	323	some code generation inefficiency, we never get smaller code for
	324	turning that into a memcpy, so pick a value that guarantees this
	325	doesn't happen. */
	326	#define TILEPRO_CALL_RATIO 11
	327	#define MOVE_RATIO(speed) ((speed) ? 15 : TILEPRO_CALL_RATIO)
	328	#define CLEAR_RATIO(speed) ((speed) ? 15 : TILEPRO_CALL_RATIO)
	329	#define SET_RATIO(speed) ((speed) ? 15 : TILEPRO_CALL_RATIO)
	330
94f1fba7	331	#define WORD_REGISTER_OPERATIONS 1
7ce78e23	332
	333	#define LOAD_EXTEND_OP(MODE) ZERO_EXTEND
	334
	335	#define PROMOTE_MODE(MODE,UNSIGNEDP,TYPE) \
	336	if (GET_MODE_CLASS (MODE) == MODE_INT \
	337	&& GET_MODE_SIZE (MODE) < UNITS_PER_WORD) \
	338	(MODE) = SImode;
	339
	340	/* Define SLOW_BYTE_ACCESS to avoid making a QI or HI mode
	341	register. */
	342	#define SLOW_BYTE_ACCESS 1
	343
	344	#define SHIFT_COUNT_TRUNCATED 1
	345
d0b99710	346	#define SHORT_IMMEDIATES_SIGN_EXTEND 1
7ce78e23	347
	348	#define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1
	349
	350	#define CLZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE) ((VALUE) = 32, 1)
	351	#define CTZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE) ((VALUE) = 32, 1)
	352
	353	#define Pmode SImode
	354
	355	#define STORE_FLAG_VALUE 1
	356
	357	#define FUNCTION_MODE SImode
	358
	359	#define NO_FUNCTION_CSE 1
	360
	361	#define ADJUST_INSN_LENGTH(INSN, LENGTH) \
	362	((LENGTH) = tilepro_adjust_insn_length ((INSN), (LENGTH)))
	363
	364	#define TARGET_FLOAT_FORMAT IEEE_FLOAT_FORMAT
	365
	366	#define BRANCH_COST(speed_p, predictable_p) ((predictable_p) ? 2 : 6)
	367	\f
	368
	369	/* Control the assembler format that we output. */
	370
	371	#undef NO_DOLLAR_IN_LABEL
	372
	373	#define ASM_COMMENT_START "##"
	374
	375	#define TEXT_SECTION_ASM_OP "\t.text"
	376
	377	#define DATA_SECTION_ASM_OP "\t.data"
	378
	379	#undef READONLY_DATA_SECTION_ASM_OP
	380	#define READONLY_DATA_SECTION_ASM_OP "\t.section\t.rodata, \"a\""
	381
	382	#undef BSS_SECTION_ASM_OP
	383	#define BSS_SECTION_ASM_OP "\t.section\t.bss, \"wa\""
	384
	385	#undef INIT_SECTION_ASM_OP
	386	#define INIT_SECTION_ASM_OP "\t.section\t.init, \"ax\""
	387
	388	#undef FINI_SECTION_ASM_OP
	389	#define FINI_SECTION_ASM_OP "\t.section\t.fini, \"ax\""
	390
	391	#define GLOBAL_ASM_OP ".global "
	392
	393	#define SUPPORTS_WEAK 1
	394
	395	#define USER_LABEL_PREFIX ""
	396
	397	#define REGISTER_PREFIX ""
	398	#define REGISTER_NAMES \
	399	{ "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", \
	400	"r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", \
	401	"r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23", \
	402	"r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31", \
	403	"r32", "r33", "r34", "r35", "r36", "r37", "r38", "r39", \
	404	"r40", "r41", "r42", "r43", "r44", "r45", "r46", "r47", \
	405	"r48", "r49", "r50", "r51", "r52", "tp", "sp", "lr", \
	406	"sn", "idn0", "idn1", "udn0", "udn1", "udn2", "udn3", "zero", \
	407	"?FRAME?", "?ARG?", "?NET?" }
	408
	409	/* This is used to help emit bundles. */
	410	#define FINAL_PRESCAN_INSN(INSN, OPVEC, NOPERANDS) \
411	tilepro_final_prescan_insn (insn)
412
413	/* This is used to help emit bundles. */
414	#define ASM_OUTPUT_OPCODE(STREAM, PTR) \
415	(PTR = tilepro_asm_output_opcode (STREAM, PTR))
416
417	#define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE) \
418	do \
419	{ \
420	char label[256]; \
421	ASM_GENERATE_INTERNAL_LABEL (label, "L", (VALUE));\
422	fprintf (FILE, "\t.word "); \
423	assemble_name (FILE, label); \
424	fprintf (FILE, "\n"); \
425	} \
426	while (0)
427
428	#define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, BODY, VALUE, REL) \
429	do \
430	{ \
431	char label[256]; \
432	ASM_GENERATE_INTERNAL_LABEL (label, "L", (VALUE)); \
433	fprintf (FILE, "\t.word "); \
434	assemble_name (FILE, label); \
435	ASM_GENERATE_INTERNAL_LABEL (label, "L", (REL)); \
436	fprintf (FILE, "-"); \
437	assemble_name (FILE, label); \
438	fprintf (FILE, "\n"); \
439	} \
440	while (0)
441
442	#define ASM_OUTPUT_ALIGN(FILE,LOG) \
443	do { if ((LOG) != 0) fprintf (FILE, "\t.align %d\n", 1 << (LOG)); } while (0)
444
445	#define ASM_OUTPUT_COMMON(FILE, NAME, SIZE, ROUNDED) \
446	( fputs (".comm ", (FILE)), \
447	assemble_name ((FILE), (NAME)), \
448	fprintf ((FILE), ",%u\n", (unsigned int)(ROUNDED)))
449
450	#define ASM_OUTPUT_LOCAL(FILE, NAME, SIZE, ROUNDED) \
451	( fputs (".lcomm ", (FILE)), \
452	assemble_name ((FILE), (NAME)), \
453	fprintf ((FILE), ",%u\n", (unsigned int)(ROUNDED)))
454
455	\f
456
457	#define INIT_EXPANDERS tilepro_init_expanders ()
458
459	/* A C structure for machine-specific, per-function data. This is
460	added to the cfun structure. */
461	typedef struct GTY(()) machine_function
462	{
463	/* Symbol for the text label used for pic. */
464	rtx text_label_symbol;
465
466	/* Register for the text label. */
467	rtx text_label_rtx;
468
469	/* Register for the pic offset table. */
470	rtx got_rtx;
471
472	/* The function calls tls_get_addr. */
473	int calls_tls_get_addr;
474	} machine_function;
475
476	#ifndef HAVE_AS_TLS
477	#define HAVE_AS_TLS 0
478	#endif