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 / i860.h < prev    next >
C/C++ Source or Header  |  1994-02-06  |  55KB  |  1,432 lines
  1. /* Definitions of target machine for GNU compiler, for Intel 860.
  2.    Copyright (C) 1989, 1991 Free Software Foundation, Inc.
  3.  
  4.    Written by Richard Stallman (rms@ai.mit.edu).
  5.  
  6.    Hacked substantially by Ron Guilmette (rfg@ncd.com) to cater to
  7.    the whims of the System V Release 4 assembler.
  8.  
  9. This file is part of GNU CC.
  10.  
  11. GNU CC is free software; you can redistribute it and/or modify
  12. it under the terms of the GNU General Public License as published by
  13. the Free Software Foundation; either version 2, or (at your option)
  14. any later version.
  15.  
  16. GNU CC is distributed in the hope that it will be useful,
  17. but WITHOUT ANY WARRANTY; without even the implied warranty of
  18. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19. GNU General Public License for more details.
  20.  
  21. You should have received a copy of the GNU General Public License
  22. along with GNU CC; see the file COPYING.  If not, write to
  23. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  24.  
  25.  
  26. /* Note that some other tm.h files include this one and then override
  27.    many of the definitions that relate to assembler syntax.  */
  28.  
  29.  
  30. /* Names to predefine in the preprocessor for this target machine.  */
  31.  
  32. #define CPP_PREDEFINES "-Di860 -Dunix"
  33.  
  34. /* Print subsidiary information on the compiler version in use.  */
  35. #define TARGET_VERSION fprintf (stderr, " (i860)");
  36.  
  37. /* Run-time compilation parameters selecting different hardware subsets
  38.    or supersets.
  39.  
  40.    On the i860, we have one: TARGET_XP.  This option allows gcc to generate
  41.    additional instructions available only on the newer i860 XP (but not on
  42.    the older i860 XR).
  43. */
  44.  
  45. extern int target_flags;
  46.  
  47. /* Nonzero if we should generate code to use the fpu.  */
  48. #define TARGET_XP (target_flags & 1)
  49.  
  50. /* Macro to define tables used to set the flags.
  51.    This is a list in braces of pairs in braces,
  52.    each pair being { "NAME", VALUE }
  53.    where VALUE is the bits to set or minus the bits to clear.
  54.    An empty string NAME is used to identify the default VALUE.  */
  55.  
  56. #define TARGET_SWITCHES  \
  57.   { {"xp", 1},            \
  58.     {"noxp", -1},        \
  59.     {"xr", -1},            \
  60.     { "", TARGET_DEFAULT}}
  61.  
  62. #define TARGET_DEFAULT 0
  63.  
  64. /* target machine storage layout */
  65.  
  66. /* Define this if most significant bit is lowest numbered
  67.    in instructions that operate on numbered bit-fields.
  68.    This is a moot question on the i860 due to the lack of bit-field insns.  */
  69. #define BITS_BIG_ENDIAN 0
  70.  
  71. /* Define this if most significant byte of a word is the lowest numbered.  */
  72. /* That is not true on i860 in the mode we will use.  */
  73. #define BYTES_BIG_ENDIAN 0
  74.  
  75. /* Define this if most significant word of a multiword number is the lowest
  76.    numbered.  */
  77. /* For the i860 this goes with BYTES_BIG_ENDIAN.  */
  78. /* NOTE: GCC probably cannot support a big-endian i860
  79.    because GCC fundamentally assumes that the order of words
  80.    in memory as the same as the order in registers.
  81.    That's not true for the big-endian i860.
  82.    The big-endian i860 isn't important enough to
  83.    justify the trouble of changing this assumption.  */
  84. #define WORDS_BIG_ENDIAN 0
  85.  
  86. /* number of bits in an addressable storage unit */
  87. #define BITS_PER_UNIT 8
  88.  
  89. /* Width in bits of a "word", which is the contents of a machine register.
  90.    Note that this is not necessarily the width of data type `int';
  91.    if using 16-bit ints on a 68000, this would still be 32.
  92.    But on a machine with 16-bit registers, this would be 16.  */
  93. #define BITS_PER_WORD 32
  94.  
  95. /* Width of a word, in units (bytes).  */
  96. #define UNITS_PER_WORD 4
  97.  
  98. /* Width in bits of a pointer.
  99.    See also the macro `Pmode' defined below.  */
  100. #define POINTER_SIZE 32
  101.  
  102. /* Allocation boundary (in *bits*) for storing arguments in argument list.  */
  103. #define PARM_BOUNDARY 32
  104.  
  105. /* Boundary (in *bits*) on which stack pointer should be aligned.  */
  106. #define STACK_BOUNDARY 128
  107.  
  108. /* Allocation boundary (in *bits*) for the code of a function.  */
  109. #define FUNCTION_BOUNDARY 64
  110.  
  111. /* Alignment of field after `int : 0' in a structure.  */
  112. #define EMPTY_FIELD_BOUNDARY 32
  113.  
  114. /* Every structure's size must be a multiple of this.  */
  115. #define STRUCTURE_SIZE_BOUNDARY 8
  116.  
  117. /* Minimum size in bits of the largest boundary to which any
  118.    and all fundamental data types supported by the hardware
  119.    might need to be aligned. No data type wants to be aligned
  120.    rounder than this.  The i860 supports 128-bit (long double)
  121.    floating point quantities, and the System V Release 4 i860
  122.    ABI requires these to be aligned to 16-byte (128-bit)
  123.    boundaries.  */
  124. #define BIGGEST_ALIGNMENT 128
  125.  
  126. /* Set this nonzero if move instructions will actually fail to work
  127.    when given unaligned data.  */
  128. #define STRICT_ALIGNMENT 1
  129.  
  130. /* If bit field type is int, dont let it cross an int,
  131.    and give entire struct the alignment of an int.  */
  132. #define PCC_BITFIELD_TYPE_MATTERS 1
  133.  
  134. /* Standard register usage.  */
  135.  
  136. /* Number of actual hardware registers.
  137.    The hardware registers are assigned numbers for the compiler
  138.    from 0 to just below FIRST_PSEUDO_REGISTER.
  139.    All registers that the compiler knows about must be given numbers,
  140.    even those that are not normally considered general registers.
  141.  
  142.    i860 has 32 fullword registers and 32 floating point registers.  */
  143.  
  144. #define FIRST_PSEUDO_REGISTER 64
  145.  
  146. /* 1 for registers that have pervasive standard uses
  147.    and are not available for the register allocator.
  148.    On the i860, this includes the always-0 registers
  149.    and fp, sp, arg pointer, and the return address.
  150.    Also r31, used for special purposes for constant addresses.  */
  151. #define FIXED_REGISTERS  \
  152.  {1, 1, 1, 1, 0, 0, 0, 0,    \
  153.   0, 0, 0, 0, 0, 0, 0, 0,    \
  154.   0, 0, 0, 0, 0, 0, 0, 0,    \
  155.   0, 0, 0, 0, 0, 0, 0, 1,    \
  156.   1, 1, 0, 0, 0, 0, 0, 0,    \
  157.   0, 0, 0, 0, 0, 0, 0, 0,    \
  158.   0, 0, 0, 0, 0, 0, 0, 0,    \
  159.   0, 0, 0, 0, 0, 0, 0, 0}
  160.  
  161. /* 1 for registers not available across function calls.
  162.    These must include the FIXED_REGISTERS and also any
  163.    registers that can be used without being saved.
  164.    On the i860, these are r0-r3, r16-r31, f0, f1, and f16-f31.  */
  165. #define CALL_USED_REGISTERS  \
  166.  {1, 1, 1, 1, 0, 0, 0, 0,    \
  167.   0, 0, 0, 0, 0, 0, 0, 0,    \
  168.   1, 1, 1, 1, 1, 1, 1, 1,    \
  169.   1, 1, 1, 1, 1, 1, 1, 1,    \
  170.   1, 1, 0, 0, 0, 0, 0, 0,    \
  171.   1, 1, 1, 1, 1, 1, 1, 1,    \
  172.   1, 1, 1, 1, 1, 1, 1, 1,    \
  173.   1, 1, 1, 1, 1, 1, 1, 1}
  174.  
  175. /* Try to get a non-preserved register before trying to get one we will
  176.    have to preserve.  Try to get an FP register only *after* trying to
  177.    get a general register, because it is relatively expensive to move
  178.    into or out of an FP register.  */
  179.  
  180. #define REG_ALLOC_ORDER            \
  181.  {31, 30, 29, 28, 27, 26, 25, 24,    \
  182.   23, 22, 21, 20, 19, 18, 17, 16,    \
  183.   15, 14, 13, 12, 11, 10,  9,  8,    \
  184.    7,  6,  5,  4,  3,  2,  1,  0,    \
  185.   63, 62, 61, 60, 59, 58, 57, 56,    \
  186.   55, 54, 53, 52, 51, 50, 49, 48,    \
  187.   47, 46, 45, 44, 43, 42, 41, 40,    \
  188.   39, 38, 37, 36, 35, 34, 33, 32}
  189.  
  190. /* Return number of consecutive hard regs needed starting at reg REGNO
  191.    to hold something of mode MODE.
  192.    This is ordinarily the length in words of a value of mode MODE
  193.    but can be less for certain modes in special long registers.
  194.  
  195.    On the i860, all registers hold 32 bits worth.  */
  196. #define HARD_REGNO_NREGS(REGNO, MODE)   \
  197.   (((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD))
  198.  
  199. #define REGNO_MODE_ALIGNED(REGNO, MODE) \
  200.   (((REGNO) % ((GET_MODE_UNIT_SIZE (MODE) + 3) / 4)) == 0)
  201.  
  202. /* Value is 1 if hard register REGNO can hold a value of machine-mode MODE.
  203.  
  204.    On the i860, we allow anything to go into any registers, but we require
  205.    any sort of value going into the FP registers to be properly aligned
  206.    (based on its size) within the FP register set.
  207. */
  208. #define HARD_REGNO_MODE_OK(REGNO, MODE)                    \
  209.   (((REGNO) < 32)                             \
  210.    || (MODE) == VOIDmode || (MODE) == BLKmode                \
  211.    || REGNO_MODE_ALIGNED (REGNO, MODE))
  212.  
  213. /* Value is 1 if it is a good idea to tie two pseudo registers
  214.    when one has mode MODE1 and one has mode MODE2.
  215.    If HARD_REGNO_MODE_OK could produce different values for MODE1 and MODE2,
  216.    for any hard reg, then this must be 0 for correct output.  */
  217. /* I think that is not always true; alignment restrictions for doubles
  218.    should not prevent tying them with singles.  So try allowing that.
  219.    On the other hand, don't let fixed and floating be tied;
  220.    this restri