frv.h

linux下的gcc编译器

   disable the use of optional features of the target machine.  For example,
   one machine description serves both the 68000 and the 68020; a command
   argument tells the compiler whether it should use 68020-only instructions or
   not.  This command argument works by means of a macro `TARGET_68020' that
   tests a bit in `target_flags'.

   Define a macro `TARGET_FEATURENAME' for each such option.  Its definition
   should test a bit in `target_flags'; for example:

        #define TARGET_68020 (target_flags & 1)

   One place where these macros are used is in the condition-expressions of
   instruction patterns.  Note how `TARGET_68020' appears frequently in the
   68000 machine description file, `m68k.md'.  Another place they are used is
   in the definitions of the other macros in the `MACHINE.h' file.  */

#define MASK_GPR_32	     0x00000001	/* Limit gprs to 32 registers */
#define MASK_FPR_32	     0x00000002	/* Limit fprs to 32 registers */
#define MASK_SOFT_FLOAT	     0x00000004	/* Use software floating point */
#define MASK_ALLOC_CC	     0x00000008	/* Dynamically allocate icc/fcc's */
#define MASK_DWORD	     0x00000010	/* Change ABi to allow dbl word insns*/
#define MASK_DOUBLE	     0x00000020	/* Use double precision instructions */
#define MASK_MEDIA	     0x00000040	/* Use media instructions */
#define MASK_MULADD	     0x00000080	/* Use multiply add/subtract insns */
#define MASK_LIBPIC	     0x00000100	/* -fpic that can be linked w/o pic */
#define MASK_ACC_4	     0x00000200	/* Only use four media accumulators */
#define MASK_PACK	     0x00000400 /* Set to enable packed output */

			 		/* put debug masks up high */
#define MASK_DEBUG_ARG	     0x40000000	/* debug argument handling */
#define MASK_DEBUG_ADDR	     0x20000000	/* debug go_if_legitimate_address */
#define MASK_DEBUG_STACK     0x10000000	/* debug stack frame */
#define MASK_DEBUG	     0x08000000	/* general debugging switch */
#define MASK_DEBUG_LOC	     0x04000000	/* optimize line # table */
#define MASK_DEBUG_COND_EXEC 0x02000000	/* debug cond exec code */
#define MASK_NO_COND_MOVE    0x01000000	/* disable conditional moves */
#define MASK_NO_SCC	     0x00800000	/* disable set conditional codes */
#define MASK_NO_COND_EXEC    0x00400000	/* disable conditional execution */
#define MASK_NO_VLIW_BRANCH  0x00200000	/* disable repacking branches */
#define MASK_NO_MULTI_CE     0x00100000	/* disable multi-level cond exec */
#define MASK_NO_NESTED_CE    0x00080000	/* disable nested cond exec */

#define MASK_DEFAULT		MASK_DEFAULT_ALLOC_CC

#define TARGET_GPR_32		((target_flags & MASK_GPR_32) != 0)
#define TARGET_FPR_32		((target_flags & MASK_FPR_32) != 0)
#define TARGET_SOFT_FLOAT	((target_flags & MASK_SOFT_FLOAT) != 0)
#define TARGET_ALLOC_CC		((target_flags & MASK_ALLOC_CC) != 0)
#define TARGET_DWORD		((target_flags & MASK_DWORD) != 0)
#define TARGET_DOUBLE		((target_flags & MASK_DOUBLE) != 0)
#define TARGET_MEDIA		((target_flags & MASK_MEDIA) != 0)
#define TARGET_MULADD		((target_flags & MASK_MULADD) != 0)
#define TARGET_LIBPIC		((target_flags & MASK_LIBPIC) != 0)
#define TARGET_ACC_4		((target_flags & MASK_ACC_4) != 0)
#define TARGET_DEBUG_ARG	((target_flags & MASK_DEBUG_ARG) != 0)
#define TARGET_DEBUG_ADDR	((target_flags & MASK_DEBUG_ADDR) != 0)
#define TARGET_DEBUG_STACK	((target_flags & MASK_DEBUG_STACK) != 0)
#define TARGET_DEBUG		((target_flags & MASK_DEBUG) != 0)
#define TARGET_DEBUG_LOC	((target_flags & MASK_DEBUG_LOC) != 0)
#define TARGET_DEBUG_COND_EXEC	((target_flags & MASK_DEBUG_COND_EXEC) != 0)
#define TARGET_NO_COND_MOVE	((target_flags & MASK_NO_COND_MOVE) != 0)
#define TARGET_NO_SCC		((target_flags & MASK_NO_SCC) != 0)
#define TARGET_NO_COND_EXEC	((target_flags & MASK_NO_COND_EXEC) != 0)
#define TARGET_NO_VLIW_BRANCH	((target_flags & MASK_NO_VLIW_BRANCH) != 0)
#define TARGET_NO_MULTI_CE	((target_flags & MASK_NO_MULTI_CE) != 0)
#define TARGET_NO_NESTED_CE	((target_flags & MASK_NO_NESTED_CE) != 0)
#define TARGET_PACK		((target_flags & MASK_PACK) != 0)

#define TARGET_GPR_64		(! TARGET_GPR_32)
#define TARGET_FPR_64		(! TARGET_FPR_32)
#define TARGET_HARD_FLOAT	(! TARGET_SOFT_FLOAT)
#define TARGET_FIXED_CC		(! TARGET_ALLOC_CC)
#define TARGET_COND_MOVE	(! TARGET_NO_COND_MOVE)
#define TARGET_SCC		(! TARGET_NO_SCC)
#define TARGET_COND_EXEC	(! TARGET_NO_COND_EXEC)
#define TARGET_VLIW_BRANCH	(! TARGET_NO_VLIW_BRANCH)
#define TARGET_MULTI_CE		(! TARGET_NO_MULTI_CE)
#define TARGET_NESTED_CE	(! TARGET_NO_NESTED_CE)
#define TARGET_ACC_8		(! TARGET_ACC_4)

#define TARGET_HAS_FPRS		(TARGET_HARD_FLOAT || TARGET_MEDIA)

#define NUM_GPRS		(TARGET_GPR_32? 32 : 64)
#define NUM_FPRS		(!TARGET_HAS_FPRS? 0 : TARGET_FPR_32? 32 : 64)
#define NUM_ACCS		(!TARGET_MEDIA? 0 : TARGET_ACC_4? 4 : 8)

/* Macros to identify the blend of media instructions available.  Revision 1
   is the one found on the FR500.  Revision 2 includes the changes made for
   the FR400.

   Treat the generic processor as a revision 1 machine for now, for
   compatibility with earlier releases.  */

#define TARGET_MEDIA_REV1					\
  (TARGET_MEDIA							\
   && (frv_cpu_type == FRV_CPU_GENERIC				\
       || frv_cpu_type == FRV_CPU_FR500))

#define TARGET_MEDIA_REV2					\
  (TARGET_MEDIA && frv_cpu_type == FRV_CPU_FR400)

/* This macro defines names of command options to set and clear bits in
   `target_flags'.  Its definition is an initializer with a subgrouping for
   each command option.

   Each subgrouping contains a string constant, that defines the option name,
   a number, which contains the bits to set in `target_flags', and an optional
   second string which is the textual description that will be displayed when
   the user passes --help on the command line.  If the number entry is negative
   then the specified bits will be cleared instead of being set.  If the second
   string entry is present but empty, then no help information will be displayed
   for that option, but it will not count as an undocumented option.  The actual
   option name, asseen on the command line is made by appending `-m' to the
   specified name.

   One of the subgroupings should have a null string.  The number in this
   grouping is the default value for `target_flags'.  Any target options act
   starting with that value.

   Here is an example which defines `-m68000' and `-m68020' with opposite
   meanings, and picks the latter as the default:

        #define TARGET_SWITCHES \
          { { "68020",  1, ""},      \
            { "68000", -1, "Compile for the m68000"},     \
            { "",       1, }}

   This declaration must be present.  */

#define TARGET_SWITCHES							    \
{{ "gpr-32",		  MASK_GPR_32,		"Only use 32 gprs"},	    \
 { "gpr-64",		 -MASK_GPR_32,		"Use 64 gprs"},		    \
 { "fpr-32",		  MASK_FPR_32,		"Only use 32 fprs"},	    \
 { "fpr-64",		 -MASK_FPR_32,		"Use 64 fprs"},		    \
 { "hard-float",	 -MASK_SOFT_FLOAT,	"Use hardware floating point" },\
 { "soft-float",	  MASK_SOFT_FLOAT,	"Use software floating point" },\
 { "alloc-cc",		  MASK_ALLOC_CC,	"Dynamically allocate cc's" }, \
 { "fixed-cc",		 -MASK_ALLOC_CC,	"Just use icc0/fcc0" },	    \
 { "dword",		  MASK_DWORD,		"Change ABI to allow double word insns" }, \
 { "no-dword",		 -MASK_DWORD,		"Do not use double word insns" }, \
 { "double",		  MASK_DOUBLE,		"Use fp double instructions" }, \
 { "no-double",		 -MASK_DOUBLE,		"Do not use fp double insns" }, \
 { "media",		  MASK_MEDIA,		"Use media instructions" }, \
 { "no-media",		 -MASK_MEDIA,		"Do not use media insns" }, \
 { "muladd",		  MASK_MULADD,		"Use multiply add/subtract instructions" }, \
 { "no-muladd",		 -MASK_MULADD,		"Do not use multiply add/subtract insns" }, \
 { "library-pic",	  MASK_LIBPIC,		"PIC support for building libraries" }, \
 { "acc-4",		  MASK_ACC_4,		"Use 4 media accumulators" }, \
 { "acc-8",		 -MASK_ACC_4,		"Use 8 media accumulators" }, \
 { "pack",		  MASK_PACK,		"Pack VLIW instructions" }, \
 { "no-pack",		 -MASK_PACK,		"Do not pack VLIW instructions" }, \
 { "no-eflags",		  0,			"Do not mark ABI switches in e_flags" }, \
 { "debug-arg",		  MASK_DEBUG_ARG,	"Internal debug switch" },  \
 { "debug-addr",	  MASK_DEBUG_ADDR,	"Internal debug switch" },  \
 { "debug-stack",	  MASK_DEBUG_STACK,	"Internal debug switch" },  \
 { "debug",		  MASK_DEBUG,		"Internal debug switch" },  \
 { "debug-cond-exec",	  MASK_DEBUG_COND_EXEC,	"Internal debug switch" },  \
 { "debug-loc",		  MASK_DEBUG_LOC,	"Internal debug switch" },  \
 { "cond-move",		 -MASK_NO_COND_MOVE,	"Enable conditional moves" },  \
 { "no-cond-move",	  MASK_NO_COND_MOVE,	"Disable conditional moves" },  \
 { "scc",		 -MASK_NO_SCC,		"Enable setting gprs to the result of comparisons" },  \
 { "no-scc",		  MASK_NO_SCC,		"Disable setting gprs to the result of comparisons" },  \
 { "cond-exec",		 -MASK_NO_COND_EXEC,	"Enable conditional execution other than moves/scc" }, \
 { "no-cond-exec",	  MASK_NO_COND_EXEC,	"Disable conditional execution other than moves/scc" }, \
 { "vliw-branch",	 -MASK_NO_VLIW_BRANCH,	"Run pass to pack branches into VLIW insns" }, \
 { "no-vliw-branch",	  MASK_NO_VLIW_BRANCH,	"Do not run pass to pack branches into VLIW insns" }, \
 { "multi-cond-exec",	 -MASK_NO_MULTI_CE,	"Disable optimizing &&/|| in conditional execution" }, \
 { "no-multi-cond-exec",  MASK_NO_MULTI_CE,	"Enable optimizing &&/|| in conditional execution" }, \
 { "nested-cond-exec",	 -MASK_NO_NESTED_CE,	"Enable nested conditional execution optimizations" }, \
 { "no-nested-cond-exec" ,MASK_NO_NESTED_CE,	"Disable nested conditional execution optimizations" }, \
 { "tomcat-stats",	  0, 			"Cause gas to print tomcat statistics" }, \
 { "",			  MASK_DEFAULT,		"" }}			    \

/* This macro is similar to `TARGET_SWITCHES' but defines names of command
   options that have values.  Its definition is an initializer with a
   subgrouping for each command option.

   Each subgrouping contains a string constant, that defines the fixed part of
   the option name, the address of a variable, and an optional description string.
   The variable, of type `char *', is set to the text following the fixed part of
   the option as it is specified on the command line.  The actual option name is
   made by appending `-m' to the specified name.

   Here is an example which defines `-mshort-data-NUMBER'.  If the given option
   is `-mshort-data-512', the variable `m88k_short_data' will be set to the
   string `"512"'.

        extern char *m88k_short_data;
        #define TARGET_OPTIONS \
         { { "short-data-", & m88k_short_data, \
	 "Specify the size of the short data section"  } }

   This declaration is optional.  */
#define TARGET_OPTIONS							    \
{									    \
  { "cpu=",		&frv_cpu_string,	 "Set cpu type" },	    \
  { "branch-cost=",	&frv_branch_cost_string, "Internal debug switch" }, \
  { "cond-exec-insns=", &frv_condexec_insns_str, "Internal debug switch" }, \
  { "cond-exec-temps=", &frv_condexec_temps_str, "Internal debug switch" }, \
  { "sched-lookahead=", &frv_sched_lookahead_str,"Internal debug switch" }, \
}

/* This macro is a C statement to print on `stderr' a string describing the
   particular machine description choice.  Every machine description should
   define `TARGET_VERSION'.  For example:

        #ifdef MOTOROLA
        #define TARGET_VERSION \
          fprintf (stderr, " (68k, Motorola syntax)");
        #else
        #define TARGET_VERSION \
          fprintf (stderr, " (68k, MIT syntax)");
        #endif  */
#define TARGET_VERSION fprintf (stderr, _(" (frv)"))

/* Sometimes certain combinations of command options do not make sense on a
   particular target machine.  You can define a macro `OVERRIDE_OPTIONS' to
   take account of this.  This macro, if defined, is executed once just after
   all the command options have been parsed.

   Don't use this macro to turn on various extra optimizations for `-O'.  That
   is what `OPTIMIZATION_OPTIONS' is for.  */

#define OVERRIDE_OPTIONS frv_override_options ()

/* Some machines may desire to change what optimizations are performed for
   various optimization levels.  This macro, if defined, is executed once just
   after the optimization level is determined and before the remainder of the
   command options have been parsed.  Values set in this macro are used as the
   default values for the other command line options.

   LEVEL is the optimization level specified; 2 if `-O2' is specified, 1 if
   `-O' is specified, and 0 if neither is specified.

   SIZE is nonzero if `-Os' is specified, 0 otherwise.

   You should not use this macro to change options that are not
   machine-specific.  These should uniformly selected by the same optimization
   level on all supported machines.  Use this macro to enable machbine-specific
   optimizations.

   *Do not examine `write_symbols' in this macro!* The debugging options are
   *not supposed to alter the generated code.  */
#define OPTIMIZATION_OPTIONS(LEVEL,SIZE) frv_optimization_options (LEVEL, SIZE)


/* Define this macro if debugging can be performed even without a frame
   pointer.  If this macro is defined, GNU CC will turn on the
   `-fomit-frame-pointer' option whenever `-O' is specified.  */
/* Frv needs a specific frame layout that includes the frame pointer */

#define CAN_DEBUG_WITHOUT_FP


/* Small Data Area Support.  */
/* Maximum size of variables that go in .sdata/.sbss.
   The -msdata=foo switch also controls how small variables are handled.  */
#ifndef SDATA_DEFAULT_SIZE
#define SDATA_DEFAULT_SIZE 8
#endif

extern int g_switch_value;        /* value of the -G xx switch */
extern int g_switch_set;          /* whether -G xx was passed.  */


/* Storage Layout */

/* Define this macro to have the value 1 if the most significant bit in a byte
   has the lowest number; otherwise define it to have the value zero.  This
   means that bit-field instructions count from the most significant bit.  If
   the machine has no bit-field instructions, then this must still be defined,
   but it doesn't matter which value it is defined to.  This macro need not be
   a constant.

   This macro does not affect the way structure fields are packed into bytes or
   words; that is controlled by `BYTES_BIG_ENDIAN'.  */
#define BITS_BIG_ENDIAN 1

/* Define this macro to have the value 1 if the most significant byte in a word
   has the lowest number.  This macro need not be a constant.  */
#define BYTES_BIG_ENDIAN 1

/* Define this macro to have the value 1 if, in a multiword object, the most
   significant word has the lowest number.  This applies to both memory
   locations and registers; GNU CC fundamentally assumes that the order of
   words in memory is the same as the order in registers.  This macro need not
   be a constant.  */
#define WORDS_BIG_ENDIAN 1

/* Number of storage units in a word; normally 4.  */
#define UNITS_PER_WORD 4

/* A macro to update MODE and UNSIGNEDP when an object whose type is TYPE and
   which has the specified mode and signedness is to be stored in a register.
   This macro is only called when TYPE is a scalar type.

   On most RISC machines, which only have operations that operate on a full
   register, define this macro to set M to `word_mode' if M is an integer mode