-/* Stormy16 cpu description.
- Copyright (C) 1997, 1998, 1999, 2000, 2001
+/* Xstormy16 cpu description.
+ Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002
Free Software Foundation, Inc.
Contributed by Red Hat, Inc.
\f
/* Driver configuration */
-/* A C expression which determines whether the option `-CHAR' takes arguments.
- The value should be the number of arguments that option takes-zero, for many
- options.
-
- By default, this macro is defined to handle the standard options properly.
- You need not define it unless you wish to add additional options which take
- arguments.
-
- Defined in svr4.h. */
+/* Defined in svr4.h. */
/* #define SWITCH_TAKES_ARG(CHAR) */
-/* A C expression which determines whether the option `-NAME' takes arguments.
- The value should be the number of arguments that option takes-zero, for many
- options. This macro rather than `SWITCH_TAKES_ARG' is used for
- multi-character option names.
-
- By default, this macro is defined as `DEFAULT_WORD_SWITCH_TAKES_ARG', which
- handles the standard options properly. You need not define
- `WORD_SWITCH_TAKES_ARG' unless you wish to add additional options which take
- arguments. Any redefinition should call `DEFAULT_WORD_SWITCH_TAKES_ARG' and
- then check for additional options.
-
- Defined in svr4.h. */
+/* Defined in svr4.h. */
/* #define WORD_SWITCH_TAKES_ARG(NAME) */
-/* A string-valued C expression which is nonempty if the linker needs a space
- between the `-L' or `-o' option and its argument.
-
- If this macro is not defined, the default value is 0. */
-/* #define SWITCHES_NEED_SPACES "" */
-
-/* A C string constant that tells the GNU CC driver program options to pass to
- CPP. It can also specify how to translate options you give to GNU CC into
- options for GNU CC to pass to the CPP.
-
- Do not define this macro if it does not need to do anything. */
-/* #define CPP_SPEC "" */
-
-/* If this macro is defined, the preprocessor will not define the builtin macro
- `__SIZE_TYPE__'. The macro `__SIZE_TYPE__' must then be defined by
- `CPP_SPEC' instead.
-
- This should be defined if `SIZE_TYPE' depends on target dependent flags
- which are not accessible to the preprocessor. Otherwise, it should not be
- defined. */
-/* #define NO_BUILTIN_SIZE_TYPE */
-
-/* If this macro is defined, the preprocessor will not define the builtin macro
- `__PTRDIFF_TYPE__'. The macro `__PTRDIFF_TYPE__' must then be defined by
- `CPP_SPEC' instead.
-
- This should be defined if `PTRDIFF_TYPE' depends on target dependent flags
- which are not accessible to the preprocessor. Otherwise, it should not be
- defined. */
-/* #define NO_BUILTIN_PTRDIFF_TYPE */
-
-/* A C string constant that tells the GNU CC driver program options to pass to
- CPP. By default, this macro is defined to pass the option
- `-D__CHAR_UNSIGNED__' to CPP if `char' will be treated as `unsigned char' by
- `cc1'.
-
- Do not define this macro unless you need to override the default definition. */
-/* #if DEFAULT_SIGNED_CHAR
- #define SIGNED_CHAR_SPEC "%{funsigned-char:-D__CHAR_UNSIGNED__}"
- #else
- #define SIGNED_CHAR_SPEC "%{!fsigned-char:-D__CHAR_UNSIGNED__}"
- #endif */
-
-/* A C string constant that tells the GNU CC driver program options to pass to
- `cc1'. It can also specify how to translate options you give to GNU CC into
- options for GNU CC to pass to the `cc1'.
-
- Do not define this macro if it does not need to do anything. */
-/* #define CC1_SPEC "" */
-
-/* A C string constant that tells the GNU CC driver program options to pass to
- `cc1plus'. It can also specify how to translate options you give to GNU CC
- into options for GNU CC to pass to the `cc1plus'.
-
- Do not define this macro if it does not need to do anything. */
-/* #define CC1PLUS_SPEC "" */
-
-/* A C string constant that tells the GNU CC driver program options to pass to
- the assembler. It can also specify how to translate options you give to GNU
- CC into options for GNU CC to pass to the assembler. See the file `sun3.h'
- for an example of this.
-
- Do not define this macro if it does not need to do anything.
-
- Defined in svr4.h. */
+/* Defined in svr4.h. */
#undef ASM_SPEC
+#define ASM_SPEC ""
-/* A C string constant that tells the GNU CC driver program how to run any
- programs which cleanup after the normal assembler. Normally, this is not
- needed. See the file `mips.h' for an example of this.
-
- Do not define this macro if it does not need to do anything.
-
- Defined in svr4.h. */
+/* Defined in svr4.h. */
/* #define ASM_FINAL_SPEC "" */
-/* A C string constant that tells the GNU CC driver program options to pass to
- the linker. It can also specify how to translate options you give to GNU CC
- into options for GNU CC to pass to the linker.
-
- Do not define this macro if it does not need to do anything.
-
- Defined in svr4.h. */
+/* Defined in svr4.h. */
/* #define LINK_SPEC "" */
-/* Another C string constant used much like `LINK_SPEC'. The difference
- between the two is that `LIB_SPEC' is used at the end of the command given
- to the linker.
+/* For xstormy16:
+ - If -msim is specified, everything is built and linked as for the sim.
+ - If -T is specified, that linker script is used, and it should provide
+ appropriate libraries.
+ - If neither is specified, everything is built as for the sim, but no
+ I/O support is assumed.
- If this macro is not defined, a default is provided that loads the standard
- C library from the usual place. See `gcc.c'.
-
- Defined in svr4.h. */
+*/
#undef LIB_SPEC
-#if 0
-#define LIB_SPEC "-( -lc %{msim:-lsim}%{!msim:-leva_app -lnosys} -)"
-#endif
-#define LIB_SPEC "-( -lc %{msim:-lsim} -)"
+#define LIB_SPEC "-( -lc %{msim:-lsim}%{!msim:%{!T*:-lnosys}} -)"
-/* Another C string constant that tells the GNU CC driver program how and when
- to place a reference to `libgcc.a' into the linker command line. This
- constant is placed both before and after the value of `LIB_SPEC'.
-
- If this macro is not defined, the GNU CC driver provides a default that
- passes the string `-lgcc' to the linker unless the `-shared' option is
- specified. */
-/* #define LIBGCC_SPEC "" */
-
-/* Another C string constant used much like `LINK_SPEC'. The difference
- between the two is that `STARTFILE_SPEC' is used at the very beginning of
- the command given to the linker.
-
- If this macro is not defined, a default is provided that loads the standard
- C startup file from the usual place. See `gcc.c'.
-
- Defined in svr4.h. */
+/* Defined in svr4.h. */
#undef STARTFILE_SPEC
#define STARTFILE_SPEC "crt0.o%s crti.o%s crtbegin.o%s"
-/* Another C string constant used much like `LINK_SPEC'. The difference
- between the two is that `ENDFILE_SPEC' is used at the very end of the
- command given to the linker.
-
- Do not define this macro if it does not need to do anything.
-
- Defined in svr4.h. */
+/* Defined in svr4.h. */
#undef ENDFILE_SPEC
#define ENDFILE_SPEC "crtend.o%s crtn.o%s"
-/* Define this macro if the driver program should find the library `libgcc.a'
- itself and should not pass `-L' options to the linker. If you do not define
- this macro, the driver program will pass the argument `-lgcc' to tell the
- linker to do the search and will pass `-L' options to it. */
-/* #define LINK_LIBGCC_SPECIAL */
-
-/* Define this macro if the driver program should find the library `libgcc.a'.
- If you do not define this macro, the driver program will pass the argument
- `-lgcc' to tell the linker to do the search. This macro is similar to
- `LINK_LIBGCC_SPECIAL', except that it does not affect `-L' options. */
-/* #define LINK_LIBGCC_SPECIAL_1 */
-
-/* Define this macro to provide additional specifications to put in the `specs'
- file that can be used in various specifications like `CC1_SPEC'.
-
- The definition should be an initializer for an array of structures,
- containing a string constant, that defines the specification name, and a
- string constant that provides the specification.
-
- Do not define this macro if it does not need to do anything. */
-/* #define EXTRA_SPECS {{}} */
-
-/* Define this macro as a C expression for the initializer of an array of
- string to tell the driver program which options are defaults for this target
- and thus do not need to be handled specially when using `MULTILIB_OPTIONS'.
-
- Do not define this macro if `MULTILIB_OPTIONS' is not defined in the target
- makefile fragment or if none of the options listed in `MULTILIB_OPTIONS' are
- set by default. */
-/* #define MULTILIB_DEFAULTS {} */
-
-/* Define this macro to tell `gcc' that it should only translate a `-B' prefix
- into a `-L' linker option if the prefix indicates an absolute file name. */
-/* #define RELATIVE_PREFIX_NOT_LINKDIR */
-
-/* Define this macro as a C string constant if you wish to override the
- standard choice of `/usr/local/lib/gcc-lib/' as the default prefix to try
- when searching for the executable files of the compiler. */
-/* #define STANDARD_EXEC_PREFIX "" */
-
-/* If defined, this macro is an additional prefix to try after
- `STANDARD_EXEC_PREFIX'. `MD_EXEC_PREFIX' is not searched when the `-b'
- option is used, or the compiler is built as a cross compiler.
-
- Defined in svr4.h for host compilers. */
+/* Defined in svr4.h for host compilers. */
/* #define MD_EXEC_PREFIX "" */
-/* Define this macro as a C string constant if you wish to override the
- standard choice of `/usr/local/lib/' as the default prefix to try when
- searching for startup files such as `crt0.o'. */
-/* #define STANDARD_STARTFILE_PREFIX "" */
-
-/* If defined, this macro supplies an additional prefix to try after the
- standard prefixes. `MD_EXEC_PREFIX' is not searched when the `-b' option is
- used, or when the compiler is built as a cross compiler.
-
- Defined in svr4.h for host compilers. */
+/* Defined in svr4.h for host compilers. */
/* #define MD_STARTFILE_PREFIX "" */
-/* If defined, this macro supplies yet another prefix to try after the standard
- prefixes. It is not searched when the `-b' option is used, or when the
- compiler is built as a cross compiler. */
-/* #define MD_STARTFILE_PREFIX_1 "" */
-
-/* Define this macro as a C string constant if you with to set environment
- variables for programs called by the driver, such as the assembler and
- loader. The driver passes the value of this macro to `putenv' to initialize
- the necessary environment variables. */
-/* #define INIT_ENVIRONMENT "" */
-
-/* Define this macro as a C string constant if you wish to override the
- standard choice of `/usr/local/include' as the default prefix to try when
- searching for local header files. `LOCAL_INCLUDE_DIR' comes before
- `SYSTEM_INCLUDE_DIR' in the search order.
-
- Cross compilers do not use this macro and do not search either
- `/usr/local/include' or its replacement. */
-/* #define LOCAL_INCLUDE_DIR "" */
-
-/* Define this macro as a C string constant if you wish to specify a
- system-specific directory to search for header files before the standard
- directory. `SYSTEM_INCLUDE_DIR' comes before `STANDARD_INCLUDE_DIR' in the
- search order.
-
- Cross compilers do not use this macro and do not search the directory
- specified. */
-/* #define SYSTEM_INCLUDE_DIR "" */
-
-/* Define this macro as a C string constant if you wish to override the
- standard choice of `/usr/include' as the default prefix to try when
- searching for header files.
-
- Cross compilers do not use this macro and do not search either
- `/usr/include' or its replacement. */
-/* #define STANDARD_INCLUDE_DIR "" */
-
-/* Define this macro if you wish to override the entire default search path for
- include files. The default search path includes `GCC_INCLUDE_DIR',
- `LOCAL_INCLUDE_DIR', `SYSTEM_INCLUDE_DIR', `GPLUSPLUS_INCLUDE_DIR', and
- `STANDARD_INCLUDE_DIR'. In addition, `GPLUSPLUS_INCLUDE_DIR' and
- `GCC_INCLUDE_DIR' are defined automatically by `Makefile', and specify
- private search areas for GCC. The directory `GPLUSPLUS_INCLUDE_DIR' is used
- only for C++ programs.
-
- The definition should be an initializer for an array of structures. Each
- array element should have two elements: the directory name (a string
- constant) and a flag for C++-only directories. Mark the end of the array
- with a null element. For example, here is the definition used for VMS:
-
- #define INCLUDE_DEFAULTS \
- { \
- { "GNU_GXX_INCLUDE:", 1}, \
- { "GNU_CC_INCLUDE:", 0}, \
- { "SYS$SYSROOT:[SYSLIB.]", 0}, \
- { ".", 0}, \
- { 0, 0} \
- }
-
- Here is the order of prefixes tried for exec files:
-
- 1. Any prefixes specified by the user with `-B'.
-
- 2. The environment variable `GCC_EXEC_PREFIX', if any.
-
- 3. The directories specified by the environment variable
- `COMPILER_PATH'.
-
- 4. The macro `STANDARD_EXEC_PREFIX'.
-
- 5. `/usr/lib/gcc/'.
-
- 6. The macro `MD_EXEC_PREFIX', if any.
-
- Here is the order of prefixes tried for startfiles:
-
- 1. Any prefixes specified by the user with `-B'.
-
- 2. The environment variable `GCC_EXEC_PREFIX', if any.
-
- 3. The directories specified by the environment variable
- `LIBRARY_PATH' (native only, cross compilers do not use this).
-
- 4. The macro `STANDARD_EXEC_PREFIX'.
-
- 5. `/usr/lib/gcc/'.
-
- 6. The macro `MD_EXEC_PREFIX', if any.
-
- 7. The macro `MD_STARTFILE_PREFIX', if any.
-
- 8. The macro `STANDARD_STARTFILE_PREFIX'.
-
- 9. `/lib/'.
-
- 10. `/usr/lib/'. */
-/* #define INCLUDE_DEFAULTS {{ }} */
-
\f
/* Run-time target specifications */
-/* Define this to be a string constant containing `-D' options to define the
- predefined macros that identify this machine and system. These macros will
- be predefined unless the `-ansi' option is specified.
-
- In addition, a parallel set of macros are predefined, whose names are made
- by appending `__' at the beginning and at the end. These `__' macros are
- permitted by the ANSI standard, so they are predefined regardless of whether
- `-ansi' is specified.
-
- For example, on the Sun, one can use the following value:
-
- "-Dmc68000 -Dsun -Dunix"
-
- The result is to define the macros `__mc68000__', `__sun__' and `__unix__'
- unconditionally, and the macros `mc68000', `sun' and `unix' provided `-ansi'
- is not specified. */
-#define CPP_PREDEFINES "-Dstormy16 -Amachine=stormy16 -D__INT_MAX__=32767"
+#define CPP_PREDEFINES "-Dxstormy16 -Amachine=xstormy16"
/* This declaration should be present. */
extern int target_flags;
-/* This series of macros is to allow compiler command arguments to enable or
- 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 TARGET_... */
-
-/* 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, as seen 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 \
{{ "sim", 0, "Provide libraries for the simulator" }, \
{ "", 0, "" }}
-/* 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 */
-
-/* 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, " (stormy16 cpu core)");
-
-/* 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 */
-
-/* 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 non-zero 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) */
-
-/* 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. */
+#define TARGET_VERSION fprintf (stderr, " (xstormy16 cpu core)");
+
#define CAN_DEBUG_WITHOUT_FP
\f
/* 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 0
-/* 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 0
-/* Define this macro if WORDS_BIG_ENDIAN is not constant. This must be a
- constant value with the same meaning as WORDS_BIG_ENDIAN, which will be used
- only when compiling libgcc2.c. Typically the value will be set based on
- preprocessor defines. */
-/* #define LIBGCC2_WORDS_BIG_ENDIAN */
-
-/* Define this macro to have the value 1 if `DFmode', `XFmode' or `TFmode'
- floating point numbers are stored in memory with the word containing the
- sign bit at the lowest address; otherwise define it to have the value 0.
- This macro need not be a constant.
-
- You need not define this macro if the ordering is the same as for multi-word
- integers. */
-/* #define FLOAT_WORDS_BIG_ENDIAN */
-
-/* Define this macro to be the number of bits in an addressable storage unit
- (byte); normally 8. */
-#define BITS_PER_UNIT 8
-
-/* Number of bits in a word; normally 32. */
-#define BITS_PER_WORD 16
-
-/* Maximum number of bits in a word. If this is undefined, the default is
- `BITS_PER_WORD'. Otherwise, it is the constant value that is the largest
- value that `BITS_PER_WORD' can have at run-time. */
-/* #define MAX_BITS_PER_WORD */
-
-/* Number of storage units in a word; normally 4. */
#define UNITS_PER_WORD 2
-/* Minimum number of units in a word. If this is undefined, the default is
- `UNITS_PER_WORD'. Otherwise, it is the constant value that is the smallest
- value that `UNITS_PER_WORD' can have at run-time. */
-/* #define MIN_UNITS_PER_WORD */
-
-/* Width of a pointer, in bits. You must specify a value no wider than the
- width of `Pmode'. If it is not equal to the width of `Pmode', you must
- define `POINTERS_EXTEND_UNSIGNED'. */
-#define POINTER_SIZE 16
-
-/* A C expression whose value is nonzero if pointers that need to be extended
- from being `POINTER_SIZE' bits wide to `Pmode' are sign-extended and zero if
- they are zero-extended.
-
- You need not define this macro if the `POINTER_SIZE' is equal to the width
- of `Pmode'. */
-/* #define POINTERS_EXTEND_UNSIGNED */
-
-/* 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
- narrower than `BITS_PER_WORD'. In most cases, only integer modes should be
- widened because wider-precision floating-point operations are usually more
- expensive than their narrower counterparts.
-
- For most machines, the macro definition does not change UNSIGNEDP. However,
- some machines, have instructions that preferentially handle either signed or
- unsigned quantities of certain modes. For example, on the DEC Alpha, 32-bit
- loads from memory and 32-bit add instructions sign-extend the result to 64
- bits. On such machines, set UNSIGNEDP according to which kind of extension
- is more efficient.
-
- Do not define this macro if it would never modify MODE. */
#define PROMOTE_MODE(MODE,UNSIGNEDP,TYPE) \
do { \
if (GET_MODE_CLASS (MODE) == MODE_INT \
(MODE) = HImode; \
} while (0)
-/* Define this macro if the promotion described by `PROMOTE_MODE' should also
- be done for outgoing function arguments. */
#define PROMOTE_FUNCTION_ARGS 1
-/* Define this macro if the promotion described by `PROMOTE_MODE' should also
- be done for the return value of functions.
-
- If this macro is defined, `FUNCTION_VALUE' must perform the same promotions
- done by `PROMOTE_MODE'. */
#define PROMOTE_FUNCTION_RETURN 1
-/* Define this macro if the promotion described by `PROMOTE_MODE' should *only*
- be performed for outgoing function arguments or function return values, as
- specified by `PROMOTE_FUNCTION_ARGS' and `PROMOTE_FUNCTION_RETURN',
- respectively. */
-/* #define PROMOTE_FOR_CALL_ONLY */
-
-/* Normal alignment required for function parameters on the stack, in bits.
- All stack parameters receive at least this much alignment regardless of data
- type. On most machines, this is the same as the size of an integer. */
#define PARM_BOUNDARY 16
-/* Define this macro if you wish to preserve a certain alignment for the stack
- pointer. The definition is a C expression for the desired alignment
- (measured in bits).
-
- If `PUSH_ROUNDING' is not defined, the stack will always be aligned to the
- specified boundary. If `PUSH_ROUNDING' is defined and specifies a less
- strict alignment than `STACK_BOUNDARY', the stack may be momentarily
- unaligned while pushing arguments. */
#define STACK_BOUNDARY 16
-/* Alignment required for a function entry point, in bits. */
#define FUNCTION_BOUNDARY 16
-/* Biggest alignment that any data type can require on this machine,
- in bits. */
#define BIGGEST_ALIGNMENT 16
-/* Biggest alignment that any structure field can require on this machine, in
- bits. If defined, this overrides `BIGGEST_ALIGNMENT' for structure fields
- only. */
-/* #define BIGGEST_FIELD_ALIGNMENT */
-
-/* An expression for the alignment of a structure field FIELD if the
- alignment computed in the usual way is COMPUTED. GNU CC uses this
- value instead of the value in `BIGGEST_ALIGNMENT' or
- `BIGGEST_FIELD_ALIGNMENT', if defined, for structure fields only. */
-/* #define ADJUST_FIELD_ALIGN(FIELD, COMPUTED) */
-
-/* Biggest alignment supported by the object file format of this machine. Use
- this macro to limit the alignment which can be specified using the
- `__attribute__ ((aligned (N)))' construct. If not defined, the default
- value is `BIGGEST_ALIGNMENT'.
-
- Defined in svr4.h. */
+/* Defined in svr4.h. */
/* #define MAX_OFILE_ALIGNMENT */
-/* If defined, a C expression to compute the alignment for a static variable.
- TYPE is the data type, and ALIGN is the alignment that the object
- would ordinarily have. The value of this macro is used instead of that
- alignment to align the object.
-
- If this macro is not defined, then ALIGN is used.
-
- One use of this macro is to increase alignment of medium-size data to make
- it all fit in fewer cache lines. Another is to cause character arrays to be
- word-aligned so that `strcpy' calls that copy constants to character arrays
- can be done inline. */
#define DATA_ALIGNMENT(TYPE, ALIGN) \
(TREE_CODE (TYPE) == ARRAY_TYPE \
&& TYPE_MODE (TREE_TYPE (TYPE)) == QImode \
&& (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN))
-/* If defined, a C expression to compute the alignment given to a constant that
- is being placed in memory. CONSTANT is the constant and ALIGN is the
- alignment that the object would ordinarily have. The value of this macro is
- used instead of that alignment to align the object.
-
- If this macro is not defined, then ALIGN is used.
-
- The typical use of this macro is to increase alignment for string constants
- to be word aligned so that `strcpy' calls that copy constants can be done
- inline. */
#define CONSTANT_ALIGNMENT(EXP, ALIGN) \
(TREE_CODE (EXP) == STRING_CST \
&& (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN))
-/* Alignment in bits to be given to a structure bit field that follows an empty
- field such as `int : 0;'.
-
- Note that `PCC_BITFIELD_TYPE_MATTERS' also affects the alignment that
- results from an empty field. */
-/* #define EMPTY_FIELD_BOUNDARY */
-
-/* Number of bits which any structure or union's size must be a multiple of.
- Each structure or union's size is rounded up to a multiple of this.
-
- If you do not define this macro, the default is the same as `BITS_PER_UNIT'. */
-/* #define STRUCTURE_SIZE_BOUNDARY */
-
-/* Define this macro to be the value 1 if instructions will fail to work if
- given data not on the nominal alignment. If instructions will merely go
- slower in that case, define this macro as 0. */
#define STRICT_ALIGNMENT 1
-/* Define this if you wish to imitate the way many other C compilers handle
- alignment of bitfields and the structures that contain them.
-
- The behavior is that the type written for a bitfield (`int', `short', or
- other integer type) imposes an alignment for the entire structure, as if the
- structure really did contain an ordinary field of that type. In addition,
- the bitfield is placed within the structure so that it would fit within such
- a field, not crossing a boundary for it.
-
- Thus, on most machines, a bitfield whose type is written as `int' would not
- cross a four-byte boundary, and would force four-byte alignment for the
- whole structure. (The alignment used may not be four bytes; it is
- controlled by the other alignment parameters.)
-
- If the macro is defined, its definition should be a C expression; a nonzero
- value for the expression enables this behavior.
-
- Note that if this macro is not defined, or its value is zero, some bitfields
- may cross more than one alignment boundary. The compiler can support such
- references if there are `insv', `extv', and `extzv' insns that can directly
- reference memory.
-
- The other known way of making bitfields work is to define
- `STRUCTURE_SIZE_BOUNDARY' as large as `BIGGEST_ALIGNMENT'. Then every
- structure can be accessed with fullwords.
-
- Unless the machine has bitfield instructions or you define
- `STRUCTURE_SIZE_BOUNDARY' that way, you must define
- `PCC_BITFIELD_TYPE_MATTERS' to have a nonzero value.
-
- If your aim is to make GNU CC use the same conventions for laying out
- bitfields as are used by another compiler, here is how to investigate what
- the other compiler does. Compile and run this program:
-
- struct foo1
- {
- char x;
- char :0;
- char y;
- };
-
- struct foo2
- {
- char x;
- int :0;
- char y;
- };
-
- main ()
- {
- printf ("Size of foo1 is %d\n",
- sizeof (struct foo1));
- printf ("Size of foo2 is %d\n",
- sizeof (struct foo2));
- exit (0);
- }
-
- If this prints 2 and 5, then the compiler's behavior is what you would get
- from `PCC_BITFIELD_TYPE_MATTERS'.
-
- Defined in svr4.h. */
+/* Defined in svr4.h. */
#define PCC_BITFIELD_TYPE_MATTERS 1
-
-/* Like PCC_BITFIELD_TYPE_MATTERS except that its effect is limited to aligning
- a bitfield within the structure. */
-/* #define BITFIELD_NBYTES_LIMITED */
-
-/* Define this macro as an expression for the overall size of a structure
- (given by STRUCT as a tree node) when the size computed from the fields is
- SIZE and the alignment is ALIGN.
-
- The default is to round SIZE up to a multiple of ALIGN. */
-/* #define ROUND_TYPE_SIZE(STRUCT, SIZE, ALIGN) */
-
-/* Define this macro as an expression for the alignment of a structure (given
- by STRUCT as a tree node) if the alignment computed in the usual way is
- COMPUTED and the alignment explicitly specified was SPECIFIED.
-
- The default is to use SPECIFIED if it is larger; otherwise, use the smaller
- of COMPUTED and `BIGGEST_ALIGNMENT' */
-/* #define ROUND_TYPE_ALIGN(STRUCT, COMPUTED, SPECIFIED) */
-
-/* An integer expression for the size in bits of the largest integer machine
- mode that should actually be used. All integer machine modes of this size
- or smaller can be used for structures and unions with the appropriate sizes.
- If this macro is undefined, `GET_MODE_BITSIZE (DImode)' is assumed. */
-/* #define MAX_FIXED_MODE_SIZE */
-
-/* A C statement to validate the value VALUE (of type `double') for mode MODE.
- This means that you check whether VALUE fits within the possible range of
- values for mode MODE on this target machine. The mode MODE is always a mode
- of class `MODE_FLOAT'. OVERFLOW is nonzero if the value is already known to
- be out of range.
-
- If VALUE is not valid or if OVERFLOW is nonzero, you should set OVERFLOW to
- 1 and then assign some valid value to VALUE. Allowing an invalid value to
- go through the compiler can produce incorrect assembler code which may even
- cause Unix assemblers to crash.
-
- This macro need not be defined if there is no work for it to do. */
-/* #define CHECK_FLOAT_VALUE(MODE, VALUE, OVERFLOW) */
-
-/* A code distinguishing the floating point format of the target machine.
- There are three defined values:
-
- IEEE_FLOAT_FORMAT'
- This code indicates IEEE floating point. It is the default;
- there is no need to define this macro when the format is IEEE.
-
- VAX_FLOAT_FORMAT'
- This code indicates the peculiar format used on the Vax.
-
- UNKNOWN_FLOAT_FORMAT'
- This code indicates any other format.
-
- The value of this macro is compared with `HOST_FLOAT_FORMAT'
- to determine whether the target machine has the same format as
- the host machine. If any other formats are actually in use on supported
- machines, new codes should be defined for them.
-
- The ordering of the component words of floating point values stored in
- memory is controlled by `FLOAT_WORDS_BIG_ENDIAN' for the target machine and
- `HOST_FLOAT_WORDS_BIG_ENDIAN' for the host. */
-#define TARGET_FLOAT_FORMAT IEEE_FLOAT_FORMAT
-
-/* GNU CC supports two ways of implementing C++ vtables: traditional or with
- so-called "thunks". The flag `-fvtable-thunk' chooses between them. Define
- this macro to be a C expression for the default value of that flag. If
- `DEFAULT_VTABLE_THUNKS' is 0, GNU CC uses the traditional implementation by
- default. The "thunk" implementation is more efficient (especially if you
- have provided an implementation of `ASM_OUTPUT_MI_THUNK', but is not binary
- compatible with code compiled using the traditional implementation. If you
- are writing a new ports, define `DEFAULT_VTABLE_THUNKS' to 1.
-
- If you do not define this macro, the default for `-fvtable-thunk' is 0. */
-#define DEFAULT_VTABLE_THUNKS 1
-
\f
/* Layout of Source Language Data Types */
-/* A C expression for the size in bits of the type `int' on the target machine.
- If you don't define this, the default is one word. */
#define INT_TYPE_SIZE 16
-/* Maximum number for the size in bits of the type `int' on the target machine.
- If this is undefined, the default is `INT_TYPE_SIZE'. Otherwise, it is the
- constant value that is the largest value that `INT_TYPE_SIZE' can have at
- run-time. This is used in `cpp'. */
-/* #define MAX_INT_TYPE_SIZE */
-
-/* A C expression for the size in bits of the type `short' on the target
- machine. If you don't define this, the default is half a word. (If this
- would be less than one storage unit, it is rounded up to one unit.) */
#define SHORT_TYPE_SIZE 16
-/* A C expression for the size in bits of the type `long' on the target
- machine. If you don't define this, the default is one word. */
#define LONG_TYPE_SIZE 32
-/* Maximum number for the size in bits of the type `long' on the target
- machine. If this is undefined, the default is `LONG_TYPE_SIZE'. Otherwise,
- it is the constant value that is the largest value that `LONG_TYPE_SIZE' can
- have at run-time. This is used in `cpp'. */
-/* #define MAX_LONG_TYPE_SIZE */
-
-/* A C expression for the size in bits of the type `long long' on the target
- machine. If you don't define this, the default is two words. If you want
- to support GNU Ada on your machine, the value of macro must be at least 64. */
#define LONG_LONG_TYPE_SIZE 64
-/* A C expression for the size in bits of the type `char' on the target
- machine. If you don't define this, the default is one quarter of a word.
- (If this would be less than one storage unit, it is rounded up to one unit.) */
-#define CHAR_TYPE_SIZE 8
-
-/* Maximum number for the size in bits of the type `char' on the target
- machine. If this is undefined, the default is `CHAR_TYPE_SIZE'. Otherwise,
- it is the constant value that is the largest value that `CHAR_TYPE_SIZE' can
- have at run-time. This is used in `cpp'. */
-/* #define MAX_CHAR_TYPE_SIZE */
-
-/* A C expression for the size in bits of the type `float' on the target
- machine. If you don't define this, the default is one word. */
#define FLOAT_TYPE_SIZE 32
-/* A C expression for the size in bits of the type `double' on the target
- machine. If you don't define this, the default is two words. */
#define DOUBLE_TYPE_SIZE 64
-/* A C expression for the size in bits of the type `long double' on the target
- machine. If you don't define this, the default is two words. */
#define LONG_DOUBLE_TYPE_SIZE 64
-/* An expression whose value is 1 or 0, according to whether the type `char'
- should be signed or unsigned by default. The user can always override this
- default with the options `-fsigned-char' and `-funsigned-char'. */
#define DEFAULT_SIGNED_CHAR 0
-/* A C expression to determine whether to give an `enum' type only as many
- bytes as it takes to represent the range of possible values of that type. A
- nonzero value means to do that; a zero value means all `enum' types should
- be allocated like `int'.
-
- If you don't define the macro, the default is 0. */
-/* #define DEFAULT_SHORT_ENUMS */
-
-/* A C expression for a string describing the name of the data type to use for
- size values. The typedef name `size_t' is defined using the contents of the
- string.
-
- The string can contain more than one keyword. If so, separate them with
- spaces, and write first any length keyword, then `unsigned' if appropriate,
- and finally `int'. The string must exactly match one of the data type names
- defined in the function `init_decl_processing' in the file `c-decl.c'. You
- may not omit `int' or change the order--that would cause the compiler to
- crash on startup.
-
- If you don't define this macro, the default is `"long unsigned int"'.
-
- Defined in svr4.h. */
+/* Defined in svr4.h. */
#define SIZE_TYPE "unsigned int"
-/* A C expression for a string describing the name of the data type to use for
- the result of subtracting two pointers. The typedef name `ptrdiff_t' is
- defined using the contents of the string. See `SIZE_TYPE' above for more
- information.
-
- If you don't define this macro, the default is `"long int"'.
-
- Defined in svr4.h. */
+/* Defined in svr4.h. */
#define PTRDIFF_TYPE "int"
-/* A C expression for a string describing the name of the data type to use for
- wide characters. The typedef name `wchar_t' is defined using the contents
- of the string. See `SIZE_TYPE' above for more information.
-
- If you don't define this macro, the default is `"int"'.
-
- Defined in svr4.h, to "long int". */
+/* Defined in svr4.h, to "long int". */
/* #define WCHAR_TYPE "long int" */
-/* A C expression for the size in bits of the data type for wide characters.
- This is used in `cpp', which cannot make use of `WCHAR_TYPE'.
-
- Defined in svr4.h. */
+/* Defined in svr4.h. */
#undef WCHAR_TYPE_SIZE
#define WCHAR_TYPE_SIZE 32
-/* Maximum number for the size in bits of the data type for wide characters.
- If this is undefined, the default is `WCHAR_TYPE_SIZE'. Otherwise, it is
- the constant value that is the largest value that `WCHAR_TYPE_SIZE' can have
- at run-time. This is used in `cpp'. */
-/* #define MAX_WCHAR_TYPE_SIZE */
-
-/* Define this macro if the type of Objective C selectors should be `int'.
+/* Define this macro if the type of Objective-C selectors should be `int'.
If this macro is not defined, then selectors should have the type `struct
objc_selector *'. */
/* #define OBJC_INT_SELECTORS */
-/* Define this macro if the compiler can group all the selectors together into
- a vector and use just one label at the beginning of the vector. Otherwise,
- the compiler must give each selector its own assembler label.
-
- On certain machines, it is important to have a separate label for each
- selector because this enables the linker to eliminate duplicate selectors. */
-/* #define OBJC_SELECTORS_WITHOUT_LABELS */
-
\f
/* Register Basics */
/* #define LEAF_REG_REMAP(REGNO) */
\f
-/* Registers That Form a Stack. */
-
-/* Define this if the machine has any stack-like registers. */
-/* #define STACK_REGS */
-
-/* The number of the first stack-like register. This one is the top
- of the stack. */
-/* #define FIRST_STACK_REG */
-
-/* The number of the last stack-like register. This one is the
- bottom of the stack. */
-/* #define LAST_STACK_REG */
-
-\f
/* Register Classes */
/* An enumeral type that must be defined with all the register class names as
`hard-reg-set.h'. */
#define REG_CLASS_CONTENTS \
{ \
- 0x00000, \
- 0x00001, \
- 0x00002, \
- 0x00003, \
- 0x00004, \
- 0x000FF, \
- 0x00100, \
- 0x00300, \
- 0x6FFFF, \
- 0x10000, \
- (1 << FIRST_PSEUDO_REGISTER) - 1 \
+ { 0x00000 }, \
+ { 0x00001 }, \
+ { 0x00002 }, \
+ { 0x00003 }, \
+ { 0x00004 }, \
+ { 0x000FF }, \
+ { 0x00100 }, \
+ { 0x00300 }, \
+ { 0x6FFFF }, \
+ { 0x10000 }, \
+ { (1 << FIRST_PSEUDO_REGISTER) - 1 } \
}
/* A C expression whose value is a register class containing hard register
This declaration must be present. */
#define PREFERRED_RELOAD_CLASS(X, CLASS) \
- stormy16_preferred_reload_class (X, CLASS)
+ xstormy16_preferred_reload_class (X, CLASS)
/* Like `PREFERRED_RELOAD_CLASS', but for output reloads instead of input
reloads. If you don't define this macro, the default is to use CLASS,
unchanged. */
#define PREFERRED_OUTPUT_RELOAD_CLASS(X, CLASS) \
- stormy16_preferred_reload_class (X, CLASS)
+ xstormy16_preferred_reload_class (X, CLASS)
/* A C expression that places additional restrictions on the register class to
use when it is necessary to be able to hold a value of mode MODE in a reload
registers, but not memory. Some machines allow copying all registers to and
from memory, but require a scratch register for stores to some memory
locations (e.g., those with symbolic address on the RT, and those with
- certain symbolic address on the Sparc when compiling PIC). In some cases,
+ certain symbolic address on the SPARC when compiling PIC). In some cases,
both an intermediate and a scratch register are required.
You should define these macros to indicate to the reload phase that it may
registers can only be copied to memory and not to another class of
registers. In that case, secondary reload registers are not needed and
would not be helpful. Instead, a stack location must be used to perform the
- copy and the `movM' pattern should use memory as a intermediate storage.
+ copy and the `movM' pattern should use memory as an intermediate storage.
This case often occurs between floating-point and general registers. */
/* This chip has the interesting property that only the first eight
registers can be moved to/from memory. */
#define SECONDARY_RELOAD_CLASS(CLASS, MODE, X) \
- stormy16_secondary_reload_class (CLASS, MODE, X)
+ xstormy16_secondary_reload_class (CLASS, MODE, X)
/* #define SECONDARY_INPUT_RELOAD_CLASS(CLASS, MODE, X) */
/* #define SECONDARY_OUTPUT_RELOAD_CLASS(CLASS, MODE, X) */
/* Certain machines have the property that some registers cannot be copied to
some other registers without using memory. Define this macro on those
- machines to be a C expression that is non-zero if objects of mode M in
+ machines to be a C expression that is nonzero if objects of mode M in
registers of CLASS1 can only be copied to registers of class CLASS2 by
storing a register of CLASS1 into memory and loading that memory location
into a register of CLASS2.
few registers of certain classes that there would not be enough registers to
use as spill registers if this were done.
- Define `SMALL_REGISTER_CLASSES' to be an expression with a non-zero value on
- these machines. When this macro has a non-zero value, the compiler allows
+ Define `SMALL_REGISTER_CLASSES' to be an expression with a nonzero value on
+ these machines. When this macro has a nonzero value, the compiler allows
registers explicitly used in the rtl to be used as spill registers but
avoids extending the lifetime of these registers.
- It is always safe to define this macro with a non-zero value, but if you
+ It is always safe to define this macro with a nonzero value, but if you
unnecessarily define it, you will reduce the amount of optimizations that
can be performed in some cases. If you do not define this macro with a
- non-zero value when it is required, the compiler will run out of spill
+ nonzero value when it is required, the compiler will run out of spill
registers and print a fatal error message. For most machines, you should
not define this macro at all. */
/* #define SMALL_REGISTER_CLASSES */
input and `r' on the output. The next alternative specifies `m' on the
input and a register class that does not include r0 on the output. */
#define EXTRA_CONSTRAINT(VALUE, C) \
- stormy16_extra_constraint_p (VALUE, C)
+ xstormy16_extra_constraint_p (VALUE, C)
\f
/* Basic Stack Layout */
/* If defined, a C expression that produces the machine-specific code to setup
the stack so that arbitrary frames can be accessed. For example, on the
- Sparc, we must flush all of the register windows to the stack before we can
+ SPARC, we must flush all of the register windows to the stack before we can
access arbitrary stack frames. This macro will seldom need to be defined. */
/* #define SETUP_FRAME_ADDRESSES() */
You only need to define this macro if you want to support call frame
debugging information like that provided by DWARF 2. */
-#define INCOMING_FRAME_SP_OFFSET (stormy16_interrupt_function_p () ? 6 : 4)
+#define INCOMING_FRAME_SP_OFFSET (xstormy16_interrupt_function_p () ? 6 : 4)
\f
/* Stack Checking. */
{ARG_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM}, \
}
-/* A C expression that returns non-zero if the compiler is allowed to try to
+/* A C expression that returns nonzero if the compiler is allowed to try to
replace register number FROM with register number TO. This macro need only
be defined if `ELIMINABLE_REGS' is defined, and will usually be the constant
1, since most of the cases preventing register elimination are things that
initial difference between the specified pair of registers. This macro must
be defined if `ELIMINABLE_REGS' is defined. */
#define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET) \
- (OFFSET) = stormy16_initial_elimination_offset (FROM, TO)
-
-/* Define this macro if the `longjmp' function restores registers from the
- stack frames, rather than from those saved specifically by `setjmp'.
- Certain quantities must not be kept in registers across a call to `setjmp'
- on such machines. */
-/* #define LONGJMP_RESTORE_FROM_STACK */
+ (OFFSET) = xstormy16_initial_elimination_offset (FROM, TO)
\f
/* Passing Function Arguments on the Stack */
variable number of bytes is passed, it is zero, and argument popping will
always be the responsibility of the calling function.
- On the Vax, all functions always pop their arguments, so the definition of
+ On the VAX, all functions always pop their arguments, so the definition of
this macro is STACK-SIZE. On the 68000, using the standard calling
convention, no functions pop their arguments, so the value of the macro is
always 0 in this case. But an alternative calling convention is available
#define NUM_ARGUMENT_REGISTERS 6
#define FIRST_ARGUMENT_REGISTER 2
-#define STORMY16_WORD_SIZE(TYPE, MODE) \
+#define XSTORMY16_WORD_SIZE(TYPE, MODE) \
((((TYPE) ? int_size_in_bytes (TYPE) : GET_MODE_SIZE (MODE)) \
+ 1) \
/ 2)
register in which to pass the argument, or zero to pass the argument on the
stack.
- For machines like the Vax and 68000, where normally all arguments are
+ For machines like the VAX and 68000, where normally all arguments are
pushed, zero suffices as a definition.
The usual way to make the ANSI library `stdarg.h' work on a machine where
You may use the macro `MUST_PASS_IN_STACK (MODE, TYPE)' in the definition of
this macro to determine if this argument is of a type that must be passed in
the stack. If `REG_PARM_STACK_SPACE' is not defined and `FUNCTION_ARG'
- returns non-zero for such an argument, the compiler will abort. If
+ returns nonzero for such an argument, the compiler will abort. If
`REG_PARM_STACK_SPACE' is defined, the argument will be computed in the
stack and then loaded into a register. */
#define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \
((MODE) == VOIDmode ? const0_rtx \
- : (CUM) + STORMY16_WORD_SIZE (TYPE, MODE) > NUM_ARGUMENT_REGISTERS ? 0 \
+ : (CUM) + XSTORMY16_WORD_SIZE (TYPE, MODE) > NUM_ARGUMENT_REGISTERS ? 0 \
: gen_rtx_REG (MODE, (CUM) + 2))
/* Define this macro if the target machine has "register windows", so that the
For this platform, the value of CUMULATIVE_ARGS is the number of words
of arguments that have been passed in registers so far. */
-typedef int CUMULATIVE_ARGS;
+#define CUMULATIVE_ARGS int
/* A C statement (sans semicolon) for initializing the variable CUM for the
state at the beginning of the argument list. The variable has type
the stack. The compiler knows how to track the amount of stack space used
for arguments without any special help. */
#define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED) \
- ((CUM) = stormy16_function_arg_advance (CUM, MODE, TYPE, NAMED))
+ ((CUM) = xstormy16_function_arg_advance (CUM, MODE, TYPE, NAMED))
/* If defined, a C expression which determines whether, and in which direction,
to pad out an argument with extra space. The value should be of type `enum
function call. */
#define RETURN_VALUE_REGNUM FIRST_ARGUMENT_REGISTER
-/* Define this macro if `-traditional' should not cause functions declared to
- return `float' to convert the value to `double'. */
-/* #define TRADITIONAL_RETURN_FLOAT */
-
/* A C expression to create an RTX representing the place where a function
returns a value of data type VALTYPE. VALTYPE is a tree node representing a
data type. Write `TYPE_MODE (VALTYPE)' to get the machine mode used to
because these are returned in another way. See `STRUCT_VALUE_REGNUM' and
related macros, below. */
#define FUNCTION_VALUE(VALTYPE, FUNC) \
- stormy16_function_value (VALTYPE, FUNC)
+ xstormy16_function_value (VALTYPE, FUNC)
/* Define this macro if the target machine has "register windows" so that the
frame pointer registers are already be assumed to be used as
needed. */
#define EPILOGUE_USES(REGNO) \
- stormy16_epilogue_uses (REGNO)
+ xstormy16_epilogue_uses (REGNO)
/* Define this macro if the function epilogue contains delay slots to which
instructions from the rest of the function can be "moved". The definition
FUNCTION instead of jumping to it. The generic approach does not support
varargs. */
#define ASM_OUTPUT_MI_THUNK(FILE, THUNK_FNDECL, DELTA, FUNCTION) \
-{ \
- fprintf (FILE, "\tadd r2,#0x%x\n", (DELTA) & 0xFFFF); \
- fputs ("\tjmpf ", FILE); \
- assemble_name (FILE, XSTR (XEXP (DECL_RTL (function), 0), 0)); \
- putc ('\n', FILE); \
-}
+ xstormy16_asm_output_mi_thunk (FILE, THUNK_FNDECL, DELTA, FUNCTION)
\f
/* Generating Code for Profiling. */
function prologue. Normally, the profiling code comes after. */
/* #define PROFILE_BEFORE_PROLOGUE */
-/* A C statement or compound statement to output to FILE some assembler code to
- initialize basic-block profiling for the current object module. The global
- compile flag `profile_block_flag' distingishes two profile modes.
-
- profile_block_flag != 2'
- Output code to call the subroutine `__bb_init_func' once per
- object module, passing it as its sole argument the address of
- a block allocated in the object module.
-
- The name of the block is a local symbol made with this
- statement:
-
- ASM_GENERATE_INTERNAL_LABEL (BUFFER, "LPBX", 0);
-
- Of course, since you are writing the definition of
- `ASM_GENERATE_INTERNAL_LABEL' as well as that of this macro,
- you can take a short cut in the definition of this macro and
- use the name that you know will result.
-
- The first word of this block is a flag which will be nonzero
- if the object module has already been initialized. So test
- this word first, and do not call `__bb_init_func' if the flag
- is nonzero. BLOCK_OR_LABEL contains a unique number which
- may be used to generate a label as a branch destination when
- `__bb_init_func' will not be called.
-
- Described in assembler language, the code to be output looks
- like:
-
- cmp (LPBX0),0
- bne local_label
- parameter1 <- LPBX0
- call __bb_init_func
- local_label:
-
- profile_block_flag == 2'
- Output code to call the subroutine `__bb_init_trace_func' and
- pass two parameters to it. The first parameter is the same as
- for `__bb_init_func'. The second parameter is the number of
- the first basic block of the function as given by
- BLOCK_OR_LABEL. Note that `__bb_init_trace_func' has to be
- called, even if the object module has been initialized
- already.
-
- Described in assembler language, the code to be output looks
- like:
- parameter1 <- LPBX0
- parameter2 <- BLOCK_OR_LABEL
- call __bb_init_trace_func */
-/* #define FUNCTION_BLOCK_PROFILER (FILE, LABELNO) */
-
-/* A C statement or compound statement to output to FILE some assembler code to
- increment the count associated with the basic block number BLOCKNO. The
- global compile flag `profile_block_flag' distingishes two profile modes.
-
- profile_block_flag != 2'
- Output code to increment the counter directly. Basic blocks
- are numbered separately from zero within each compilation.
- The count associated with block number BLOCKNO is at index
- BLOCKNO in a vector of words; the name of this array is a
- local symbol made with this statement:
-
- ASM_GENERATE_INTERNAL_LABEL (BUFFER, "LPBX", 2);
-
- Of course, since you are writing the definition of
- `ASM_GENERATE_INTERNAL_LABEL' as well as that of this macro,
- you can take a short cut in the definition of this macro and
- use the name that you know will result.
-
- Described in assembler language, the code to be output looks
- like:
-
- inc (LPBX2+4*BLOCKNO)
-
- profile_block_flag == 2'
- Output code to initialize the global structure `__bb' and
- call the function `__bb_trace_func', which will increment the
- counter.
-
- `__bb' consists of two words. In the first word, the current
- basic block number, as given by BLOCKNO, has to be stored. In
- the second word, the address of a block allocated in the
- object module has to be stored. The address is given by the
- label created with this statement:
-
- ASM_GENERATE_INTERNAL_LABEL (BUFFER, "LPBX", 0);
-
- Described in assembler language, the code to be output looks
- like:
- move BLOCKNO -> (__bb)
- move LPBX0 -> (__bb+4)
- call __bb_trace_func */
-/* #define BLOCK_PROFILER(FILE, BLOCKNO) */
-
-/* A C statement or compound statement to output to FILE assembler
- code to call function `__bb_trace_ret'. The assembler code should
- only be output if the global compile flag `profile_block_flag' ==
- 2. This macro has to be used at every place where code for
- returning from a function is generated
- (e.g. `TARGET_ASM_FUNCTION_EPILOGUE'). Although you have to write
- the definition of `TARGET_ASM_FUNCTION_EPILOGUE' as well, you have
- to define this macro to tell the compiler, that the proper call to
- `__bb_trace_ret' is produced. */
-/* #define FUNCTION_BLOCK_PROFILER_EXIT(FILE) */
-
-/* A C statement or compound statement to save all registers, which may be
- clobbered by a function call, including condition codes. The `asm'
- statement will be mostly likely needed to handle this task. Local labels in
- the assembler code can be concatenated with the string ID, to obtain a
- unique lable name.
-
- Registers or condition codes clobbered by
- `TARGET_ASM_FUNCTION_PROLOGUE' or `TARGET_ASM_FUNCTION_EPILOGUE'
- must be saved in the macros `FUNCTION_BLOCK_PROFILER',
- `FUNCTION_BLOCK_PROFILER_EXIT' and `BLOCK_PROFILER' prior calling
- `__bb_init_trace_func', `__bb_trace_ret' and `__bb_trace_func'
- respectively. */
-/* #define MACHINE_STATE_SAVE(ID) */
-
-/* A C statement or compound statement to restore all registers, including
- condition codes, saved by `MACHINE_STATE_SAVE'.
-
- Registers or condition codes clobbered by `TARGET_ASM_FUNCTION_PROLOGUE' or
- `TARGET_ASM_FUNCTION_EPILOGUE' must be restored in the macros
- `FUNCTION_BLOCK_PROFILER', `FUNCTION_BLOCK_PROFILER_EXIT' and
- `BLOCK_PROFILER' after calling `__bb_init_trace_func', `__bb_trace_ret' and
- `__bb_trace_func' respectively. */
-/* #define MACHINE_STATE_RESTORE(ID) */
-
-/* A C function or functions which are needed in the library to support block
- profiling. */
-/* #define BLOCK_PROFILER_CODE */
-
\f
/* If the target has particular reasons why a function cannot be inlined,
it may define the TARGET_CANNOT_INLINE_P. This macro takes one argument,
a message describing why the function could not be inlined. The message will
displayed if the '-Winline' command line switch has been given. If the message
contains a '%s' sequence, this will be replaced by the name of the function. */
-/* #define TARGET_CANNOT_INLINE_P(FN_DECL) stormy16_cannot_inline_p (FN_DECL) */
+/* #define TARGET_CANNOT_INLINE_P(FN_DECL) xstormy16_cannot_inline_p (FN_DECL) */
\f
/* Implementing the Varargs Macros. */
this case. */
#define SETUP_INCOMING_VARARGS(ARGS_SO_FAR, MODE, TYPE, PRETEND_ARGS_SIZE, SECOND_TIME) \
if (! SECOND_TIME) \
- stormy16_setup_incoming_varargs (ARGS_SO_FAR, MODE, TYPE, & PRETEND_ARGS_SIZE)
+ xstormy16_setup_incoming_varargs (ARGS_SO_FAR, MODE, TYPE, & PRETEND_ARGS_SIZE)
/* Define this macro if the location where a function argument is passed
depends on whether or not it is a named argument.
/* Build up the stdarg/varargs va_list type tree, assinging it to NODE. If not
defined, it is assumed that va_list is a void * pointer. */
#define BUILD_VA_LIST_TYPE(NODE) \
- ((NODE) = stormy16_build_va_list ())
+ ((NODE) = xstormy16_build_va_list ())
-/* Implement the stdarg/varargs va_start macro. STDARG_P is non-zero if this
+/* Implement the stdarg/varargs va_start macro. STDARG_P is nonzero if this
is stdarg.h instead of varargs.h. VALIST is the tree of the va_list
variable to initialize. NEXTARG is the machine independent notion of the
'next' argument after the variable arguments. If not defined, a standard
implementation will be defined that works for arguments passed on the stack. */
-#define EXPAND_BUILTIN_VA_START(STDARG_P, VALIST, NEXTARG) \
- stormy16_expand_builtin_va_start (STDARG_P, VALIST, NEXTARG)
+#define EXPAND_BUILTIN_VA_START(VALIST, NEXTARG) \
+ xstormy16_expand_builtin_va_start (VALIST, NEXTARG)
/* Implement the stdarg/varargs va_arg macro. VALIST is the variable of type
va_list as a tree, TYPE is the type passed to va_arg. */
#define EXPAND_BUILTIN_VA_ARG(VALIST, TYPE) \
- stormy16_expand_builtin_va_arg (VALIST, TYPE)
+ xstormy16_expand_builtin_va_arg (VALIST, TYPE)
/* Implement the stdarg/varargs va_end macro. VALIST is the variable of type
va_list as a tree. */
the nested function; STATIC_CHAIN is an RTX for the static chain value that
should be passed to the function when it is called. */
#define INITIALIZE_TRAMPOLINE(ADDR, FNADDR, STATIC_CHAIN) \
- stormy16_initialize_trampoline (ADDR, FNADDR, STATIC_CHAIN)
+ xstormy16_initialize_trampoline (ADDR, FNADDR, STATIC_CHAIN)
/* A C expression to allocate run-time space for a trampoline. The expression
value should be an RTX representing a memory reference to the space for the
On most machines, you don't need to define any of these macros, because the
C compiler that comes with the system takes care of doing them. */
-/* #define perform_... */
+/* #define perform_... */
-/* Define this macro to generate code for Objective C message sending using the
+/* Define this macro to generate code for Objective-C message sending using the
calling convention of the NeXT system. This calling convention involves
passing the object, the selector and the method arguments all at once to the
method-lookup library function.
/* A C compound statement with a conditional `goto LABEL;' executed if X (an
RTX) is a legitimate memory address on the target machine for a memory
- operand of mode MODE.
-
- It usually pays to define several simpler macros to serve as subroutines for
- this one. Otherwise it may be too complicated to understand.
-
- This macro must exist in two variants: a strict variant and a non-strict
- one. The strict variant is used in the reload pass. It must be defined so
- that any pseudo-register that has not been allocated a hard register is
- considered a memory reference. In contexts where some kind of register is
- required, a pseudo-register with no hard register must be rejected.
-
- The non-strict variant is used in other passes. It must be defined to
- accept all pseudo-registers in every context where some kind of register is
- required.
-
- Compiler source files that want to use the strict variant of this macro
- define the macro `REG_OK_STRICT'. You should use an `#ifdef REG_OK_STRICT'
- conditional to define the strict variant in that case and the non-strict
- variant otherwise.
-
- Subroutines to check for acceptable registers for various purposes (one for
- base registers, one for index registers, and so on) are typically among the
- subroutines used to define `GO_IF_LEGITIMATE_ADDRESS'. Then only these
- subroutine macros need have two variants; the higher levels of macros may be
- the same whether strict or not.
-
- Normally, constant addresses which are the sum of a `symbol_ref' and an
- integer are stored inside a `const' RTX to mark them as constant.
- Therefore, there is no need to recognize such sums specifically as
- legitimate addresses. Normally you would simply recognize any `const' as
- legitimate.
-
- Usually `PRINT_OPERAND_ADDRESS' is not prepared to handle constant sums that
- are not marked with `const'. It assumes that a naked `plus' indicates
- indexing. If so, then you *must* reject such naked constant sums as
- illegitimate addresses, so that none of them will be given to
- `PRINT_OPERAND_ADDRESS'.
-
- On some machines, whether a symbolic address is legitimate depends on the
- section that the address refers to. On these machines, define the macro
- `ENCODE_SECTION_INFO' to store the information into the `symbol_ref', and
- then check for it here. When you see a `const', you will have to look
- inside it to find the `symbol_ref' in order to determine the section.
-
- The best way to modify the name string is by adding text to the beginning,
- with suitable punctuation to prevent any ambiguity. Allocate the new name
- in `saveable_obstack'. You will have to modify `ASM_OUTPUT_LABELREF' to
- remove and decode the added text and output the name accordingly, and define
- `STRIP_NAME_ENCODING' to access the original name string.
-
- You can check the information stored here into the `symbol_ref' in the
- definitions of the macros `GO_IF_LEGITIMATE_ADDRESS' and
- `PRINT_OPERAND_ADDRESS'. */
+ operand of mode MODE. */
#ifdef REG_OK_STRICT
#define GO_IF_LEGITIMATE_ADDRESS(MODE, X, LABEL) \
do { \
- if (stormy16_legitimate_address_p (MODE, X, 1)) \
+ if (xstormy16_legitimate_address_p (MODE, X, 1)) \
goto LABEL; \
} while (0)
#else
#define GO_IF_LEGITIMATE_ADDRESS(MODE, X, LABEL) \
do { \
- if (stormy16_legitimate_address_p (MODE, X, 0)) \
+ if (xstormy16_legitimate_address_p (MODE, X, 0)) \
goto LABEL; \
} while (0)
#endif
or pre-decrement address.
*/
#define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR,LABEL) \
- if (stormy16_mode_dependent_address_p (ADDR)) \
+ if (xstormy16_mode_dependent_address_p (ADDR)) \
goto LABEL
/* A C expression that is nonzero if X is a legitimate constant for an
/* #define EXTRA_CC_MODES */
/* Returns a mode from class `MODE_CC' to be used when comparison operation
- code OP is applied to rtx X and Y. For example, on the Sparc,
+ code OP is applied to rtx X and Y. For example, on the SPARC,
`SELECT_CC_MODE' is defined as (see *note Jump Patterns::. for a
description of the reason for this definition)
You need not define this macro if it would always returns zero or if the
floating-point format is anything other than `IEEE_FLOAT_FORMAT'. For
- example, here is the definition used on the Sparc, where floating-point
+ example, here is the definition used on the SPARC, where floating-point
inequality comparisons are always given `CCFPEmode':
#define REVERSIBLE_CC_MODE(MODE) ((MODE) != CCFPEmode) */
CODE is the expression code--redundant, since it can be obtained with
`GET_CODE (X)'. */
-/* #define CONST_COSTS(X, CODE, OUTER_CODE) */
+#define CONST_COSTS(X, CODE, OUTER_CODE) \
+ case CONST_INT: \
+ if (INTVAL (X) < 16 && INTVAL (X) >= 0) \
+ return COSTS_N_INSNS (1)/2; \
+ if (INTVAL (X) < 256 && INTVAL (X) >= 0) \
+ return COSTS_N_INSNS (1); \
+ case CONST_DOUBLE: \
+ case CONST: \
+ case SYMBOL_REF: \
+ case LABEL_REF: \
+ return COSTS_N_INSNS(2);
/* Like `CONST_COSTS' but applies to nonconstant RTL expressions. This can be
used, for example, to indicate how costly a multiply instruction is. In
This macro is optional; do not define it if the default cost assumptions are
adequate for the target machine. */
-/* #define RTX_COSTS(X, CODE, OUTER_CODE) */
+#define RTX_COSTS(X, CODE, OUTER_CODE) \
+ case MULT: \
+ return COSTS_N_INSNS (35 + 6); \
+ case DIV: \
+ return COSTS_N_INSNS (51 - 6);
/* An expression giving the cost of an addressing mode that contains ADDRESS.
If not defined, the cost is computed from the ADDRESS expression and the
Equivalent costs should probably only be given to addresses with different
numbers of registers on machines with lots of registers.
- This macro will normally either not be defined or be defined as a constant. */
-/* #define ADDRESS_COST(ADDRESS) */
+ This macro will normally either not be defined or be defined as a
+ constant. */
+#define ADDRESS_COST(ADDRESS) \
+ (GET_CODE (ADDRESS) == CONST_INT ? 2 \
+ : GET_CODE (ADDRESS) == PLUS ? 7 \
+ : 5)
/* A C expression for the cost of moving data of mode MODE from a
register in class FROM to one in class TO. The classes are
If moving between registers and memory is more expensive than between two
registers, you should define this macro to express the relative cost. */
-#define MEMORY_MOVE_COST(M,C,I) 5
+#define MEMORY_MOVE_COST(M,C,I) (5 + memory_move_secondary_cost (M, C, I))
/* A C expression for the cost of a branch instruction. A value of 1 is the
default; other values are interpreted relative to that. */
same word of the structure, but to different bytes. */
#define SLOW_BYTE_ACCESS 0
-/* Define this macro if zero-extension (of a `char' or `short' to an `int') can
- be done faster if the destination is a register that is known to be zero.
-
- If you define this macro, you must have instruction patterns that recognize
- RTL structures like this:
-
- (set (strict_low_part (subreg:QI (reg:SI ...) 0)) ...)
-
- and likewise for `HImode'. */
-#define SLOW_ZERO_EXTEND 0
-
/* Define this macro to be the value 1 if unaligned accesses have a cost many
times greater than aligned accesses, for example if they are emulated in a
trap handler.
- When this macro is non-zero, the compiler will act as if `STRICT_ALIGNMENT'
- were non-zero when generating code for block moves. This can cause
+ When this macro is nonzero, the compiler will act as if `STRICT_ALIGNMENT'
+ were nonzero when generating code for block moves. This can cause
significantly more instructions to be produced. Therefore, do not set this
- macro non-zero if unaligned accesses only add a cycle or two to the time for
+ macro nonzero if unaligned accesses only add a cycle or two to the time for
a memory access.
If the value of this macro is always zero, it need not be defined. */
uninitialized global data will be output in the data section if
`-fno-common' is passed, otherwise `ASM_OUTPUT_COMMON' will be
used. */
-#define BSS_SECTION_ASM_OP ".bss"
+#define BSS_SECTION_ASM_OP "\t.section\t.bss"
/* If defined, a C expression whose value is a string containing the
assembler operation to identify the following data as
Defined in svr4.h. */
/* #define EXTRA_SECTION_FUNCTIONS */
-/* On most machines, read-only variables, constants, and jump tables are placed
- in the text section. If this is not the case on your machine, this macro
- should be defined to be the name of a function (either `data_section' or a
- function defined in `EXTRA_SECTIONS') that switches to the section to be
- used for read-only items.
-
- If these items should be placed in the text section, this macro should not
- be defined. */
-/* #define READONLY_DATA_SECTION */
-
-/* A C statement or statements to switch to the appropriate section for output
- of EXP. You can assume that EXP is either a `VAR_DECL' node or a constant
- of some sort. RELOC indicates whether the initial value of EXP requires
- link-time relocations. Select the section by calling `text_section' or one
- of the alternatives for other sections.
-
- Do not define this macro if you put all read-only variables and constants in
- the read-only data section (usually the text section).
-
- Defined in svr4.h. */
-/* #define SELECT_SECTION(EXP, RELOC, ALIGN) */
-
-/* A C statement or statements to switch to the appropriate section for output
- of RTX in mode MODE. You can assume that RTX is some kind of constant in
- RTL. The argument MODE is redundant except in the case of a `const_int'
- rtx. Select the section by calling `text_section' or one of the
- alternatives for other sections.
-
- Do not define this macro if you put all constants in the read-only data
- section.
-
- Defined in svr4.h. */
-/* #define SELECT_RTX_SECTION(MODE, RTX, ALIGN) */
-
/* Define this macro if jump tables (for `tablejump' insns) should be output in
the text section, along with the assembler instructions. Otherwise, the
readonly data section is used.
This macro is irrelevant if there is no separate readonly data section. */
#define JUMP_TABLES_IN_TEXT_SECTION 1
-
-/* Define this macro if references to a symbol must be treated differently
- depending on something about the variable or function named by the symbol
- (such as what section it is in).
-
- The macro definition, if any, is executed immediately after the rtl for DECL
- has been created and stored in `DECL_RTL (DECL)'. The value of the rtl will
- be a `mem' whose address is a `symbol_ref'.
-
- The usual thing for this macro to do is to record a flag in the `symbol_ref'
- (such as `SYMBOL_REF_FLAG') or to store a modified name string in the
- `symbol_ref' (if one bit is not enough information). */
-#define ENCODE_SECTION_INFO(DECL) stormy16_encode_section_info(DECL)
-
-/* Decode SYM_NAME and store the real name part in VAR, sans the characters
- that encode section info. Define this macro if `ENCODE_SECTION_INFO' alters
- the symbol's name string. */
-/* #define STRIP_NAME_ENCODING(VAR, SYM_NAME) */
-
-/* A C statement to build up a unique section name, expressed as a
- STRING_CST node, and assign it to `DECL_SECTION_NAME (DECL)'.
- RELOC indicates whether the initial value of EXP requires
- link-time relocations. If you do not define this macro, GNU CC
- will use the symbol name prefixed by `.' as the section name.
-
- Defined in svr4.h. */
-/* #define UNIQUE_SECTION(DECL, RELOC) */
-
\f
/* Position Independent Code. */
Defined in svr4.h. */
/* #define ASM_FILE_END(STREAM) */
-/* A C statement to output assembler commands which will identify the object
- file as having been compiled with GNU CC (or another GNU compiler).
-
- If you don't define this macro, the string `gcc_compiled.:' is output. This
- string is calculated to define a symbol which, on BSD systems, will never be
- defined for any other reason. GDB checks for the presence of this symbol
- when reading the symbol table of an executable.
-
- On non-BSD systems, you must arrange communication with GDB in some other
- fashion. If GDB is not used on your system, you can define this macro with
- an empty body.
-
- Defined in svr4.h. */
-/* #define ASM_IDENTIFY_GCC(FILE) */
-
-/* Like ASM_IDENTIFY_GCC, but used when dbx debugging is selected to emit
- a stab the debugger uses to identify gcc as the compiler that is emitted
- after the stabs for the filename, which makes it easier for GDB to parse.
-
- Defined in svr4.h. */
-/* #define ASM_IDENTIFY_GCC_AFTER_SOURCE(FILE) */
-
/* A C string constant describing how to begin a comment in the target
assembler language. The compiler assumes that the comment will end at the
end of the line. */
/* #define ASM_OUTPUT_SECTION_NAME(STREAM, DECL, NAME) */
/* A C statement to output any assembler statements which are required to
- precede any Objective C object definitions or message sending. The
- statement is executed only when compiling an Objective C program. */
+ precede any Objective-C object definitions or message sending. The
+ statement is executed only when compiling an Objective-C program. */
/* #define OBJC_PROLOGUE */
\f
/* Output of Data. */
/* A C statement to output to the stdio stream STREAM an assembler instruction
- to assemble a floating-point constant of `TFmode', `DFmode', `SFmode',
- `TQFmode', `HFmode', or `QFmode', respectively, whose value is VALUE. VALUE
- will be a C expression of type `REAL_VALUE_TYPE'. Macros such as
- `REAL_VALUE_TO_TARGET_DOUBLE' are useful for writing these definitions. */
-
-/* This is how to output an assembler line defining a `double'. */
-#define ASM_OUTPUT_DOUBLE(STREAM,VALUE) \
-do { char dstr[30]; \
- REAL_VALUE_TO_DECIMAL ((VALUE), "%.20e", dstr); \
- fprintf ((STREAM), "\t.double %s\n", dstr); \
- } while (0)
-
-/* This is how to output an assembler line defining a `float' constant. */
-#define ASM_OUTPUT_FLOAT(STREAM,VALUE) \
-do { char dstr[30]; \
- REAL_VALUE_TO_DECIMAL ((VALUE), "%.20e", dstr); \
- fprintf ((STREAM), "\t.float %s\n", dstr); \
- } while (0)
-
-/* #define ASM_OUTPUT_LONG_DOUBLE(STREAM, VALUE) */
-/* #define ASM_OUTPUT_THREE_QUARTER_FLOAT(STREAM, VALUE) */
-/* #define ASM_OUTPUT_SHORT_FLOAT(STREAM, VALUE) */
-/* #define ASM_OUTPUT_BYTE_FLOAT(STREAM, VALUE) */
-
-/* A C statement to output to the stdio stream STREAM an assembler instruction
- to assemble an integer of 16, 8, 4, 2 or 1 bytes, respectively, whose value
- is VALUE. The argument EXP will be an RTL expression which represents a
- constant value. Use `output_addr_const (STREAM, EXP)' to output this value
- as an assembler expression.
-
- For sizes larger than `UNITS_PER_WORD', if the action of a macro would be
- identical to repeatedly calling the macro corresponding to a size of
- `UNITS_PER_WORD', once for each word, you need not define the macro. */
-/* #define ASM_OUTPUT_QUADRUPLE_INT(STREAM, EXP) */
-/* #define ASM_OUTPUT_DOUBLE_INT(STREAM, EXP) */
-
-/* This is how to output an assembler line defining a `char' constant. */
-#define ASM_OUTPUT_CHAR(FILE, VALUE) \
-do { \
- fprintf (FILE, "\t.byte\t"); \
- output_addr_const (FILE, (VALUE)); \
- fprintf (FILE, "\n"); \
-} while (0)
-
-/* This is how to output an assembler line defining a `short' constant. */
-#define ASM_OUTPUT_SHORT(FILE, VALUE) \
-do { \
- fprintf (FILE, "\t.hword\t"); \
- output_addr_const (FILE, (VALUE)); \
- fprintf (FILE, "\n"); \
-} while (0)
-
-/* This is how to output an assembler line defining an `int' constant.
- We also handle symbol output here. */
-#define ASM_OUTPUT_INT(FILE, VALUE) \
-do { \
- fprintf (FILE, "\t.word\t"); \
- output_addr_const (FILE, (VALUE)); \
- fprintf (FILE, "\n"); \
-} while (0)
-
-/* A C statement to output to the stdio stream STREAM an assembler instruction
- to assemble a single byte containing the number VALUE.
-
- This declaration must be present. */
-#define ASM_OUTPUT_BYTE(STREAM, VALUE) \
- fprintf (STREAM, "\t%s\t0x%x\n", ASM_BYTE_OP, (VALUE))
-
-/* A C string constant giving the pseudo-op to use for a sequence of
- single-byte constants. If this macro is not defined, the default
- is `"byte"'.
-
- Defined in svr4.h. */
-/* #define ASM_BYTE_OP */
-
-/* A C statement to output to the stdio stream STREAM an assembler instruction
to assemble a string constant containing the LEN bytes at PTR. PTR will be
a C expression of type `char *' and LEN a C expression of type `int'.
/* #define ASM_OUTPUT_ASCII(STREAM, PTR, LEN) */
/* You may define this macro as a C expression. You should define the
- expression to have a non-zero value if GNU CC should output the
+ expression to have a nonzero value if GNU CC should output the
constant pool for a function before the code for the function, or
a zero value if GNU CC should output the constant pool after the
function. If you do not define this macro, the usual case, GNU CC
is treated as a logical line separator. */
#define IS_ASM_LOGICAL_LINE_SEPARATOR(C) ((C) == '|')
-/* These macros are provided by `real.h' for writing the definitions of
- `ASM_OUTPUT_DOUBLE' and the like: */
-
-/* These translate X, of type `REAL_VALUE_TYPE', to the target's floating point
- representation, and store its bit pattern in the array of `long int' whose
- address is L. The number of elements in the output array is determined by
- the size of the desired target floating point data type: 32 bits of it go in
- each `long int' array element. Each array element holds 32 bits of the
- result, even if `long int' is wider than 32 bits on the host machine.
-
- The array element values are designed so that you can print them out using
- `fprintf' in the order they should appear in the target machine's memory. */
-/* #define REAL_VALUE_TO_TARGET_SINGLE(X, L) */
-/* #define REAL_VALUE_TO_TARGET_DOUBLE(X, L) */
-/* #define REAL_VALUE_TO_TARGET_LONG_DOUBLE(X, L) */
-
-/* This macro converts X, of type `REAL_VALUE_TYPE', to a decimal number and
- stores it as a string into STRING. You must pass, as STRING, the address of
- a long enough block of space to hold the result.
-
- The argument FORMAT is a `printf'-specification that serves as a suggestion
- for how to format the output string. */
-/* #define REAL_VALUE_TO_DECIMAL(X, FORMAT, STRING) */
-
\f
/* Output of Uninitialized Variables. */
\f
/* Output and Generation of Labels. */
-/* A C statement (sans semicolon) to output to the stdio stream STREAM the
- assembler definition of a label named NAME. Use the expression
- `assemble_name (STREAM, NAME)' to output the name itself; before and after
- that, output the additional assembler syntax for defining the name, and a
- newline. */
-#define ASM_OUTPUT_LABEL(STREAM, NAME) \
-do { \
- assemble_name (STREAM, NAME); \
- fputs (":\n", STREAM); \
-} while (0)
-
/* A C statement to output to the stdio stream STREAM the assembler
definition of a symbol named SYMBOL. */
#define ASM_OUTPUT_SYMBOL_REF(STREAM, SYMBOL) \
do { \
if (SYMBOL_REF_FLAG (SYMBOL)) \
- { \
- fputs ("@fptr(", STREAM); \
- assemble_name (STREAM, XSTR (SYMBOL, 0)); \
- fputc (')', STREAM); \
- } \
+ ASM_OUTPUT_LABEL_REF ((STREAM), XSTR (SYMBOL, 0)); \
else \
assemble_name (STREAM, XSTR (SYMBOL, 0)); \
} while (0)
+/* A C statement to output to the stdio stream STREAM the assembler
+ definition of a label, the textual form is in 'BUF'. Not used
+ for %l. */
+#define ASM_OUTPUT_LABEL_REF(STREAM, NAME) \
+do { \
+ fputs ("@fptr(", STREAM); \
+ assemble_name (STREAM, NAME); \
+ fputc (')', STREAM); \
+} while (0)
+
/* A C statement (sans semicolon) to output to the stdio stream STREAM any text
necessary for declaring the name NAME of a function which is being defined.
This macro is responsible for outputting the label definition (perhaps using
Defined in svr4.h. */
/* #define ASM_FINISH_DECLARE_OBJECT(STREAM, DECL, TOPLEVEL, ATEND) */
-/* A C statement (sans semicolon) to output to the stdio stream STREAM some
- commands that will make the label NAME global; that is, available for
- reference from other files. Use the expression `assemble_name (STREAM,
- NAME)' to output the name itself; before and after that, output the
- additional assembler syntax for making that name global, and a newline. */
-#define ASM_GLOBALIZE_LABEL(STREAM,NAME) \
-do { \
- fputs ("\t.globl ", STREAM); \
- assemble_name (STREAM, NAME); \
- fputs ("\n", STREAM); \
-} while (0)
+/* Globalizing directive for a label. */
+#define GLOBAL_ASM_OP "\t.globl "
/* A C statement (sans semicolon) to output to the stdio stream STREAM some
commands that will make the label NAME weak; that is, available for
When the machine description has a specification `%PUNCT' (a `%' followed by
a punctuation character), this macro is called with a null pointer for X and
the punctuation character for CODE. */
-#define PRINT_OPERAND(STREAM, X, CODE) stormy16_print_operand (STREAM, X, CODE)
+#define PRINT_OPERAND(STREAM, X, CODE) xstormy16_print_operand (STREAM, X, CODE)
/* A C expression which evaluates to true if CODE is a valid punctuation
character for use in the `PRINT_OPERAND' macro. If
/* A C compound statement to output to stdio stream STREAM the assembler syntax
for an instruction operand that is a memory reference whose address is X. X
- is an RTL expression.
-
- On some machines, the syntax for a symbolic address depends on the section
- that the address refers to. On these machines, define the macro
- `ENCODE_SECTION_INFO' to store the information into the `symbol_ref', and
- then check for it here.
-
- This declaration must be present. */
-#define PRINT_OPERAND_ADDRESS(STREAM, X) stormy16_print_operand_address (STREAM, X)
+ is an RTL expression. */
+#define PRINT_OPERAND_ADDRESS(STREAM, X) xstormy16_print_operand_address (STREAM, X)
/* A C statement, to be executed after all slot-filler instructions have been
output. If necessary, call `dbr_sequence_length' to determine the number of
which would be bad. Instead, it controls the output of the table
itself. */
#define ASM_OUTPUT_ADDR_VEC(LABEL, BODY) \
- stormy16_output_addr_vec (file, LABEL, BODY)
+ xstormy16_output_addr_vec (file, LABEL, BODY)
/* Alignment for ADDR_VECs is the same as for code. */
#define ADDR_VEC_ALIGN(ADDR_VEC) 1
\f
/* Assembler Commands for Exception Regions. */
-/* A C expression to output text to mark the start of an exception region.
-
- This macro need not be defined on most platforms. */
-/* #define ASM_OUTPUT_EH_REGION_BEG() */
-
-/* A C expression to output text to mark the end of an exception region.
-
- This macro need not be defined on most platforms. */
-/* #define ASM_OUTPUT_EH_REGION_END() */
-
-/* A C expression that is nonzero if the normal exception table output should
- be omitted.
-
- This macro need not be defined on most platforms. */
-/* #define OMIT_EH_TABLE() */
-
-/* Alternate runtime support for looking up an exception at runtime and finding
- the associated handler, if the default method won't work.
-
- This macro need not be defined on most platforms. */
-/* #define EH_TABLE_LOOKUP() */
-
-/* A C expression that decides whether or not the current function needs to
- have a function unwinder generated for it. See the file `except.c' for
- details on when to define this, and how. */
-/* #define DOESNT_NEED_UNWINDER */
-
/* An rtx used to mask the return address found via RETURN_ADDR_RTX, so that it
does not contain any extraneous set bits in it. */
/* #define MASK_RETURN_ADDR */
/* Define this macro to 0 if your target supports DWARF 2 frame unwind
information, but it does not yet work with exception handling. Otherwise,
if your target supports this information (if it defines
- `INCOMING_RETURN_ADDR_RTX' and either `UNALIGNED_INT_ASM_OP' or
- `OBJECT_FORMAT_ELF'), GCC will provide a default definition of 1.
+ `INCOMING_RETURN_ADDR_RTX'), GCC will provide a default definition of 1.
If this macro is defined to 1, the DWARF 2 unwinder will be the default
exception handling mechanism; otherwise, setjmp/longjmp will be used by
\f
/* Macros Affecting all Debug Formats. */
-/* A C expression that returns the DBX register number for the compiler
- register number REGNO. In simple cases, the value of this expression may be
- REGNO itself. But sometimes there are some registers that the compiler
- knows about and DBX does not, or vice versa. In such cases, some register
- may need to have one number in the compiler and another for DBX.
-
- If two registers have consecutive numbers inside GNU CC, and they can be
- used as a pair to hold a multiword value, then they *must* have consecutive
- numbers after renumbering with `DBX_REGISTER_NUMBER'. Otherwise, debuggers
- will be unable to access such a pair, because they expect register pairs to
- be consecutive in their own numbering scheme.
-
- If you find yourself defining `DBX_REGISTER_NUMBER' in way that does not
- preserve register pairs, then what you must do instead is redefine the
- actual register numbering scheme.
-
- This declaration is required. */
-#define DBX_REGISTER_NUMBER(REGNO) (REGNO)
-
/* A C expression that returns the integer offset value for an automatic
variable having address X (an RTL expression). The default computation
assumes that X is based on the frame-pointer and gives the offset from the
This does nothing if the expected type does not exist.
See the function `init_decl_processing' in `c-decl.c' to find the names to
- use for all the built-in C types. */
+ use for all the built-in C types. */
/* #define DBX_OUTPUT_STANDARD_TYPES(SYMS) */
/* Some stabs encapsulation formats (in particular ECOFF), cannot
handle the `.stabs "",N_FUN,,0,0,Lscope-function-1' gdb dbx
- extention construct. On those machines, define this macro to turn
+ extension construct. On those machines, define this macro to turn
this feature off without disturbing the rest of the gdb extensions. */
/* #define NO_DBX_FUNCTION_END */
assembler directives. See `sdbout.c' for a list of these macros and their
arguments. If the standard syntax is used, you need not define them
yourself. */
-/* #define PUT_SDB_... */
+/* #define PUT_SDB_... */
/* Some assemblers do not support a semicolon as a delimiter, even between SDB
assembler directives. In that case, define this macro to be the delimiter
\f
/* Miscellaneous Parameters. */
-/* Define REAL_ARITHMETIC to use a software emulator for the target floating
- point mode. Otherwise the host floating point mode is used. */
-#define REAL_ARITHMETIC
-
/* Define this if you have defined special-purpose predicates in the file
`MACHINE.c'. This macro is called within an initializer of an array of
structures. The first field in the structure is the name of a predicate and
{"shift_operator", {ASHIFT, ASHIFTRT, LSHIFTRT }}, \
{"equality_operator", {EQ, NE }}, \
{"inequality_operator", {GE, GT, LE, LT, GEU, GTU, LEU, LTU }}, \
- {"stormy16_ineqsi_operator", {LT, GE, LTU, GEU }},
-
+ {"xstormy16_ineqsi_operator", {LT, GE, LTU, GEU }}, \
+ {"nonimmediate_nonstack_operand", {REG, MEM}},
/* An alias for a machine mode name. This is the machine mode that elements of
a jump-table should have. */
#define CASE_VECTOR_MODE SImode
/* Define as C expression which evaluates to nonzero if the tablejump
instruction expects the table to contain offsets from the address of the
table.
- Do not define this if the table should contain absolute addresses. */
+ Do not define this if the table should contain absolute addresses. */
/* #define CASE_VECTOR_PC_RELATIVE 1 */
/* Define this if control falls through a `case' insn when the index value is
/* Define if loading short immediate values into registers sign extends. */
/* #define SHORT_IMMEDIATES_SIGN_EXTEND */
-/* An alias for a tree code that should be used by default for conversion of
- floating point values to fixed point. Normally, `FIX_ROUND_EXPR' is used. */
-/* #define IMPLICIT_FIX_EXPR */
-
/* Define this macro if the same instructions that convert a floating point
number to a signed fixed point number also convert validly to an unsigned
one. */
/* #define FIXUNS_TRUNC_LIKE_FIX_TRUNC */
-/* An alias for a tree code that is the easiest kind of division to compile
- code for in the general case. It may be `TRUNC_DIV_EXPR', `FLOOR_DIV_EXPR',
- `CEIL_DIV_EXPR' or `ROUND_DIV_EXPR'. These four division operators differ
- in how they round the result to an integer. `EASY_DIV_EXPR' is used when it
- is permissible to use any of those kinds of division and the choice should
- be made on the basis of efficiency. */
-#define EASY_DIV_EXPR TRUNC_DIV_EXPR
-
/* The maximum number of bytes that a single instruction can move quickly from
memory to memory. */
#define MOVE_MAX 2
/* A C expression that is nonzero if on this machine the number of bits
actually used for the count of a shift operation is equal to the number of
bits needed to represent the size of the object being shifted. When this
- macro is non-zero, the compiler will assume that it is safe to omit a
+ macro is nonzero, the compiler will assume that it is safe to omit a
sign-extend, zero-extend, and certain bitwise `and' instructions that
truncates the count of a shift operation. On machines that have
instructions that act on bitfields at variable positions, which may include
instructions.
If both types of instructions truncate the count (for shifts) and position
- (for bitfield operations), or if no variable-position bitfield instructions
+ (for bit-field operations), or if no variable-position bit-field instructions
exist, you should define this macro.
However, on some machines, such as the 80386 and the 680x0, truncation only
Some machines can also perform `and' or `plus' operations on condition code
values with less instructions than the corresponding `sCOND' insn followed
by `and' or `plus'. On those machines, define the appropriate patterns.
- Use the names `incscc' and `decscc', respectively, for the the patterns
+ Use the names `incscc' and `decscc', respectively, for the patterns
which perform `plus' or `minus' operations on condition code values. See
`rs6000.md' for some examples. The GNU Superoptizer can be used to find
such instruction sequences on other machines.
instructions. */
/* #define STORE_FLAG_VALUE */
-/* A C expression that gives a non-zero floating point value that is returned
+/* A C expression that gives a nonzero floating point value that is returned
when comparison operators with floating-point results are true. Define this
macro on machine that have comparison operations that return floating-point
values. If there are no such operations, do not define this macro. */
should be used on RISC machines. */
/* #define INTEGRATE_THRESHOLD(DECL) */
-/* Define this if the preprocessor should ignore `#sccs' directives and print
- no error message.
-
- Defined in svr4.h. */
-/* #define SCCS_DIRECTIVE */
-
/* Define this macro if the system header files support C++ as well as C. This
macro inhibits the usual method of using system header files in C++, which
is to pretend that the file's contents are enclosed in `extern "C" {...}'. */
#define HANDLE_SYSV_PRAGMA
/* Define this macro if you want to support the Win32 style pragmas
- #pragma pack(push,<n>) and #pragma pack(pop). */
+ #pragma pack(push,<n>) and #pragma pack(pop). */
/* HANDLE_PRAGMA_PACK_PUSH_POP 1 */
-/* Define this macro to control use of the character `$' in identifier names.
- The value should be 0, 1, or 2. 0 means `$' is not allowed by default; 1
- means it is allowed by default if `-traditional' is used; 2 means it is
- allowed by default provided `-ansi' is not used. 1 is the default; there is
- no need to define this macro in that case. */
-/* #define DOLLARS_IN_IDENTIFIERS */
-
/* Define this macro if the assembler does not accept the character `$' in
label names. By default constructors and destructors in G++ have `$' in the
identifiers. If this macro is defined, `.' is used instead.
/* #define MAX_CONDITIONAL_EXECUTE */
/* A C statement that adds to tree CLOBBERS a set of STRING_CST trees for any
- hard regs the port wishes to automatically clobber for all asms. */
+ hard regs the port wishes to automatically clobber for all asms. */
/* #define MD_ASM_CLOBBERS(CLOBBERS) */
/* Indicate how many instructions can be issued at the same time. */
/* A C statement which is executed by the Haifa scheduler at the beginning of
each block of instructions that are to be scheduled. FILE is either a null
pointer, or a stdio stream to write any debug output to. VERBOSE is the
- verbose level provided by -fsched-verbose-<n>. */
+ verbose level provided by -fsched-verbose-<n>. */
/* #define MD_SCHED_INIT (FILE, VERBOSE) */
/* A C statement which is executed by the Haifa scheduler after it has scheduled
to write any debug output to. VERBOSE is the verbose level provided by
-fsched-verbose-<n>. INSN is the instruction that was scheduled. MORE is the
number of instructions that can be issued in the current cycle. This macro
- is responsible for updating the value of MORE (typically by (MORE)--). */
+ is responsible for updating the value of MORE (typically by (MORE)--). */
/* #define MD_SCHED_VARIABLE_ISSUE (FILE, VERBOSE, INSN, MORE) */
/* Define this to the largest integer machine mode which can be used for
/* Define this macro as a C string constant for the linker argument to link in the
system math library, or "" if the target does not have a separate math library.
- You need only define this macro if the default of "-lm" is wrong. */
+ You need only define this macro if the default of "-lm" is wrong. */
/* #define MATH_LIBRARY */
\f
/* Define the information needed to generate branch and scc insns. This is
stored from the compare operation. Note that we can't use "rtx" here
since it hasn't been defined! */
-extern struct rtx_def *stormy16_compare_op0, *stormy16_compare_op1;
+extern struct rtx_def *xstormy16_compare_op0, *xstormy16_compare_op1;
-/* End of stormy16.h */
+/* End of xstormy16.h */
OSDN Git Service
