[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

/* 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						\
}

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