home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 7 / FreshFishVol7.bin / bbs / gnu / gcc-2.3.3-src.lha / GNU / src / amiga / gcc-2.3.3 / config / a29k.h < prev    next >
C/C++ Source or Header  |  1994-02-06  |  61KB  |  1,593 lines
  1. /* Definitions of target machine for GNU compiler, for AMD Am29000 CPU.
  2.    Copyright (C) 1988, 1990, 1991, 1992 Free Software Foundation, Inc.
  3.    Contributed by Richard Kenner (kenner@nyu.edu)
  4.  
  5. This file is part of GNU CC.
  6.  
  7. GNU CC is free software; you can redistribute it and/or modify
  8. it under the terms of the GNU General Public License as published by
  9. the Free Software Foundation; either version 2, or (at your option)
  10. any later version.
  11.  
  12. GNU CC is distributed in the hope that it will be useful,
  13. but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. GNU General Public License for more details.
  16.  
  17. You should have received a copy of the GNU General Public License
  18. along with GNU CC; see the file COPYING.  If not, write to
  19. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20.  
  21.  
  22. /* Names to predefine in the preprocessor for this target machine.  */
  23.  
  24. #define CPP_PREDEFINES "-D_AM29K -D_AM29000 -D_EPI"
  25.  
  26. /* Print subsidiary information on the compiler version in use.  */
  27. #define TARGET_VERSION
  28.  
  29. /* Pass -w to assembler.  */
  30. #define ASM_SPEC "-w"
  31.  
  32. /* Run-time compilation parameters selecting different hardware subsets.  */
  33.  
  34. extern int target_flags;
  35.  
  36. /* Macro to define tables used to set the flags.
  37.    This is a list in braces of pairs in braces,
  38.    each pair being { "NAME", VALUE }
  39.    where VALUE is the bits to set or minus the bits to clear.
  40.    An empty string NAME is used to identify the default VALUE.  */
  41.  
  42. /* This means that the DW bit will be enabled, to allow direct loads
  43.    of bytes.  */
  44.  
  45. #define TARGET_DW_ENABLE    (target_flags & 1)
  46.  
  47. /* This means that the external hardware does supports byte writes.  */
  48.  
  49. #define TARGET_BYTE_WRITES    (target_flags & 2)
  50.  
  51. /* This means that a "small memory model" has been selected where all
  52.    function addresses are known to be within 256K.  This allows CALL to be
  53.    used.  */
  54.  
  55. #define TARGET_SMALL_MEMORY    (target_flags & 4)
  56.  
  57. /* This means that we are compiling for a 29050.  */
  58.  
  59. #define TARGET_29050        (target_flags & 8)
  60.  
  61. /* This means that we are compiling for the kernel which means that we use
  62.    gr64-gr95 instead of gr96-126.  */
  63.  
  64. #define TARGET_KERNEL_REGISTERS    (target_flags & 16)
  65.  
  66. /* This means that a call to "__msp_check" should be inserted after each stack
  67.    adjustment to check for stack overflow.  */
  68.  
  69. #define TARGET_STACK_CHECK    (target_flags & 32)
  70.  
  71. /* This handles 29k processors which cannot handle the separation
  72.    of a mtsrim insns and a storem insn (most 29000 chips to date, but
  73.    not the 29050.  */
  74.  
  75. #define TARGET_NO_STOREM_BUG    (target_flags & 64)
  76.  
  77. /* This forces the compiler not to use incoming argument registers except
  78.    for copying out arguments.  It helps detect problems when a function is
  79.    called with fewer arguments than it is declared with.  */
  80.  
  81. #define TARGET_NO_REUSE_ARGS    (target_flags & 128)
  82.  
  83. #define TARGET_SWITCHES            \
  84.   { {"dw", 1},                \
  85.     {"ndw", -1},            \
  86.     {"bw", 2},                \
  87.     {"nbw", - (1|2)},            \
  88.     {"small", 4},            \
  89.     {"large", -4},            \
  90.     {"29050", 8+64},            \
  91.     {"29000", -8},            \
  92.     {"kernel-registers", 16},        \
  93.     {"user-registers", -16},        \
  94.     {"stack-check", 32},        \
  95.     {"no-stack-check", - 32},        \
  96.     {"storem-bug", -64},        \
  97.     {"no-storem-bug", 64},        \
  98.     {"reuse-arg-regs", -128},        \
  99.     {"no-reuse-arg-regs", 128},        \
  100.     {"", TARGET_DEFAULT}}
  101.  
  102. #define TARGET_DEFAULT 3
  103.  
  104. /* Define this to change the optimizations performed by default.  */
  105.  
  106. #define OPTIMIZATION_OPTIONS(LEVEL)    \
  107. {                    \
  108.   if ((LEVEL) > 0)            \
  109.     {                    \
  110.       flag_force_addr = 1;        \
  111.       flag_force_mem = 1;        \
  112.       flag_omit_frame_pointer = 1;    \
  113.     }                    \
  114. }
  115.  
  116. /* target machine storage layout */
  117.  
  118. /* Define the types for size_t, ptrdiff_t, and wchar_t.  These are the
  119.    same as those used by EPI.  The type for wchar_t does not make much
  120.    sense, but is what is used.  */
  121.  
  122. #define SIZE_TYPE "unsigned int"
  123. #define PTRDIFF_TYPE "int"
  124. #define WCHAR_TYPE "char"
  125. #define WCHAR_TYPE_SIZE BITS_PER_UNIT
  126.  
  127. /* Define this macro if it is advisible to hold scalars in registers
  128.    in a wider mode than that declared by the program.  In such cases, 
  129.    the value is constrained to be within the bounds of the declared
  130.    type, but kept valid in the wider mode.  The signedness of the
  131.    extension may differ from that of the type.  */
  132.  
  133. #define PROMOTE_MODE(MODE,UNSIGNEDP,TYPE)  \
  134.   if (GET_MODE_CLASS (MODE) == MODE_INT    \
  135.       && GET_MODE_SIZE (MODE) < 4)      \
  136.     (MODE) == SImode;
  137.  
  138. /* Define this if most significant bit is lowest numbered
  139.    in instructions that operate on numbered bit-fields.
  140.    This is arbitrary on the 29k since it has no actual bit-field insns.
  141.    It is better to define this as TRUE because BYTES_BIG_ENDIAN is TRUE
  142.    and we want to be able to convert BP position to bit position with
  143.    just a shift.  */
  144. #define BITS_BIG_ENDIAN 1
  145.  
  146. /* Define this if most significant byte of a word is the lowest numbered.
  147.    This is true on 29k.  */
  148. #define BYTES_BIG_ENDIAN 1
  149.  
  150. /* Define this if most significant word of a multiword number is lowest
  151.    numbered. 
  152.  
  153.    For 29k we can decide arbitrarily since there are no machine instructions
  154.    for them.  Might as well be consistent with bytes. */
  155. #define WORDS_BIG_ENDIAN 1
  156.  
  157. /* number of bits in an addressable storage unit */
  158. #define BITS_PER_UNIT 8
  159.  
  160. /* Width in bits of a "word", which is the contents of a machine register.
  161.    Note that this is not necessarily the width of data type `int';
  162.    if using 16-bit ints on a 68000, this would still be 32.
  163.    But on a machine with 16-bit registers, this would be 16.  */
  164. #define BITS_PER_WORD 32
  165.  
  166. /* Width of a word, in units (bytes).  */
  167. #define UNITS_PER_WORD 4
  168.  
  169. /* Width in bits of a pointer.
  170.    See also the macro `Pmode' defined below.  */
  171. #define POINTER_SIZE 32
  172.  
  173. /* Allocation boundary (in *bits*) for storing arguments in argument list.  */
  174. #define PARM_BOUNDARY 32
  175.  
  176. /* Boundary (in *bits*) on which stack pointer should be aligned.  */
  177. #define STACK_BOUNDARY 64
  178.  
  179. /* Allocation boundary (in *bits*) for the code of a function.  */
  180. #define FUNCTION_BOUNDARY 32
  181.  
  182. /* Alignment of field after `int : 0' in a structure.  */
  183. #define EMPTY_FIELD_BOUNDARY 32
  184.  
  185. /* Every structure's size must be a multiple of this.  */
  186. #define STRUCTURE_SIZE_BOUNDARY 8
  187.  
  188. /* A bitfield declared as `int' forces `int' alignment for the struct.  */
  189. #define PCC_BITFIELD_TYPE_MATTERS 1
  190.  
  191. /* No data type wants to be aligned rounder than this.  */
  192. #define BIGGEST_ALIGNMENT 32
  193.  
  194. /* Make strings word-aligned so strcpy from constants will be faster.  */
  195. #define CONSTANT_ALIGNMENT(EXP, ALIGN)  \
  196.   (TREE_CODE (EXP) == STRING_CST    \
  197.    && (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN))
  198.  
  199. /* Make arrays of chars word-aligned for the same reasons.  */
  200. #define DATA_ALIGNMENT(TYPE, ALIGN)        \
  201.   (TREE_CODE (TYPE) == ARRAY_TYPE        \
  202.    && TYPE_MODE (TREE_TYPE (TYPE)) == QImode    \
  203.    && (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN))
  204.  
  205. /* Set this non-zero if move instructions will actually fail to work
  206.    when given unaligned data.  */
  207. #define STRICT_ALIGNMENT 0
  208.  
  209. /* Set this non-zero if unaligned move instructions are extremely slow.
  210.  
  211.    On the 29k, they trap.  */
  212. #define SLOW_UNALIGNED_ACCESS 1
  213.  
  214. /* Standard register usage.  */
  215.  
  216. /* Number of actual hardware registers.
  217.    The hardware registers are assigned numbers for the compiler
  218.    from 0 to just below FIRST_PSEUDO_REGISTER.
  219.    All registers that the compiler knows about must be given numbers,
  220.    even those that are not normally considered general registers.
  221.  
  222.    29k has 256 registers, of which 62 are not defined.  gr0 and gr1 are
  223.    not produced in generated RTL so we can start at gr96, and call it
  224.    register zero.
  225.  
  226.    So 0-31 are gr96-gr127, lr0-lr127 are 32-159.  To represent the input
  227.    arguments, whose register numbers we won't know until we are done,
  228.    use register 160-175.  They cannot be modified.  Similarly, 176 is used
  229.    for the frame pointer.  It is assigned the last local register number
  230.    once the number of registers used is known.
  231.  
  232.    We use 177, 178, 179, and 180 for the special registers BP, FC, CR, and Q,
  233.    respectively.  Registers 181 through 199 are used for the other special
  234.    registers that may be used by the programm