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 / arm.h < prev    next >
C/C++ Source or Header  |  1994-02-06  |  49KB  |  1,309 lines
  1. /* Definitions of target machine for GNU compiler, for Acorn RISC Machine.
  2.    Copyright (C) 1991 Free Software Foundation, Inc.
  3.    Contributed by Pieter `Tiggr' Schoenmakers (rcpieter@win.tue.nl)
  4.               and Martin Simmons (@harleqn.co.uk).
  5.  
  6. This file is part of GNU CC.
  7.  
  8. GNU CC is free software; you can redistribute it and/or modify
  9. it under the terms of the GNU General Public License as published by
  10. the Free Software Foundation; either version 2, or (at your option)
  11. any later version.
  12.  
  13. GNU CC is distributed in the hope that it will be useful,
  14. but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16. GNU General Public License for more details.
  17.  
  18. You should have received a copy of the GNU General Public License
  19. along with GNU CC; see the file COPYING.  If not, write to
  20. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  21.  
  22. /* Sometimes the directive `riscos' is checked.  This does not imply that this
  23.    tm file can be used unchanged to build a GCC for RISC OS.
  24.    (Since in fact, it can't.)  */
  25.  
  26. extern void output_prologue ();
  27. extern void output_epilogue ();
  28. extern char *arm_output_asm_insn ();
  29. extern char *arm_output_llc ();
  30. extern char *output_add_immediate ();
  31. extern char *output_call ();
  32. extern char *output_move_double ();
  33. extern char *output_mov_double_fpu_from_arm ();
  34. extern char *output_mov_double_arm_from_fpu ();
  35. extern char *output_mov_immediate ();
  36. extern char *output_multi_immediate ();
  37. extern char *output_shifted_move ();
  38.  
  39. /* Translation to find startup files.  On RISCiX boxes, gcrt0.o is in
  40.    /usr/lib.  */
  41. #define STARTFILE_SPEC  \
  42.   "%{pg:/usr/lib/gcrt0.o%s}%{!pg:%{p:mcrt0.o%s}%{!p:crt0.o%s}}"
  43.  
  44. #ifdef riscos
  45. #define CPP_PREDEFINES  "-Darm -Driscos"
  46. #else
  47. #define CPP_PREDEFINES  "-Darm -Driscix -Dunix"
  48. #endif
  49.  
  50. /* Run-time Target Specification.  */
  51. #define TARGET_VERSION  \
  52.   fputs (" (ARM/RISCiX)", stderr);
  53.  
  54. /* Run-time compilation parameters selecting different hardware subsets.
  55.    On the ARM, misuse it in a different way.  */
  56. extern int target_flags;
  57.  
  58. /* Nonzero if the function prologue (and epilogue) should obey
  59.    the ARM Procedure Call Standard.  */
  60. #define TARGET_APCS    (target_flags & 1)
  61.  
  62. /* Nonzero if the function prologue should output the function name to enable
  63.    the post mortem debugger to print a backtrace (very useful on RISCOS,
  64.    unused on RISCiX).  Specifying this flag also enables -mapcs.
  65.    XXX Must still be implemented in the prologue.  */
  66. #define TARGET_POKE_FUNCTION_NAME    (target_flags & 2)
  67.  
  68. /* Nonzero if floating point instructions are emulated by the FPE, in which
  69.    case instruction scheduling becomes very uninteresting.  */
  70. #define TARGET_FPE    (target_flags & 4)
  71.  
  72. #define TARGET_SWITCHES  \
  73. {                                     \
  74.   {"apcs",         1},            \
  75.   {"poke-function-name", 2},            \
  76.   {"fpe",         4},            \
  77.   {"",            TARGET_DEFAULT }    \
  78. }
  79.  
  80. #define TARGET_DEFAULT  0
  81.  
  82. #define TARGET_MEM_FUNCTIONS 1
  83.  
  84. /* OVERRIDE_OPTIONS takes care of the following:
  85.    - if -mpoke-function-name, then -mapcs.
  86.    - if doing debugging, then -mapcs; if RISCOS, then -mpoke-function-name.
  87.    - if floating point is done by emulation, forget about instruction
  88.      scheduling.  Note that this only saves compilation time; it doesn't
  89.      matter for the final code.  */
  90. #ifdef riscos
  91. #define TARGET_WHEN_DEBUGGING  3
  92. #else
  93. #define TARGET_WHEN_DEBUGGING  1
  94. #endif
  95.  
  96. #define OVERRIDE_OPTIONS  \
  97. {                                \
  98.   if (write_symbols != NO_DEBUG)                \
  99.     target_flags |= TARGET_WHEN_DEBUGGING;            \
  100.   else if (TARGET_POKE_FUNCTION_NAME)                \
  101.     target_flags |= 1;                        \
  102.   if (TARGET_FPE)                        \
  103.     flag_schedule_insns = flag_schedule_insns_after_reload = 0;    \
  104. }
  105.  
  106. /* Omitting the frame pointer is a very good idea on the ARM, especially if
  107.    not TARGET_APCS, in which case all that pushing on function entry isn't
  108.    mandatory anymore.  */
  109. #define OPTIMIZATION_OPTIONS(OPTIMIZE)  \
  110. {                    \
  111.   if (OPTIMIZE)                \
  112.     flag_omit_frame_pointer = 1;    \
  113. }
  114.  
  115. /* Target machine storage Layout.  */
  116.  
  117. /* Define this if most significant bit is lowest numbered
  118.    in instructions that operate on numbered bit-fields.  */
  119. #define BITS_BIG_ENDIAN  0
  120.  
  121. /* Define this if most significant byte of a word is the lowest numbered.  */
  122. #define BYTES_BIG_ENDIAN  0
  123.  
  124. /* Define this if most significant word of a multiword number is the lowest
  125.    numbered.  */
  126. #define WORDS_BIG_ENDIAN  0
  127.  
  128. /* Number of bits in an addressable storage unit */
  129. #define BITS_PER_UNIT  8
  130.  
  131. #define BITS_PER_WORD  32
  132.  
  133. #define UNITS_PER_WORD    4
  134.  
  135. #define POINTER_SIZE  32
  136.  
  137. #define PARM_BOUNDARY      32
  138.  
  139. #define STACK_BOUNDARY  32
  140.  
  141. #define FUNCTION_BOUNDARY  32
  142.  
  143. #define EMPTY_FIELD_BOUNDARY  32
  144.  
  145. #define BIGGEST_ALIGNMENT  32
  146.  
  147. /* Every structures size must be a multiple of 32 bits.  */
  148. #define STRUCTURE_SIZE_BOUNDARY 32
  149.  
  150. #define STRICT_ALIGNMENT 1
  151.  
  152. /* Define number of bits in most basic integer type.
  153.    (If undefined, default is BITS_PER_WORD).  */
  154. /* #define INT_TYPE_SIZE */
  155.  
  156. /* Standard register usage.  */
  157.  
  158. /* Register allocation in ARM Procedure Call Standard (as used on RISCiX):
  159.    (S - saved over call).
  160.  
  161.     r0       *    argument word/integer result
  162.     r1-r3        argument word
  163.  
  164.     r4-r8         S    register variable
  165.     r9         S    (rfp) register variable (real frame pointer)
  166.  
  167.     r10         F S    (sl) stack limit (not currently used)
  168.     r11        F S    (fp) argument pointer
  169.     r12        (ip) temp workspace
  170.     r13         F S    (sp) lower end of current stack frame
  171.     r14        (lr) link address/workspace
  172.     r15       F    (pc) program counter
  173.  
  174.     f0        floating point result
  175.     f1-f3        floating point scratch
  176.  
  177.     f4-f7         S    floating point variable
  178.  
  179.    *: See CONDITIONAL_REGISTER_USAGE  */
  180.  
  181. /* The number of hard registers is 16 ARM + 8 FPU.  */
  182. #define FIRST_PSEUDO_REGISTER  24
  183.  
  184. /* 1 for registers that have pervasive standard uses
  185.    and are not available for the register allocator.  */
  186. #define FIXED_REGISTERS  \
  187. {                        \
  188.   0,0,0,0,0,0,0,0,     \
  189.   0,0,1,1,0,1,0,1,     \
  190.   0,0,0,0,0,0,0,0     \
  191. }
  192.  
  193. /* 1 for registers not available across function calls.
  194.    These must include the FIXED_REGISTERS and also any
  195.    registers that can be used without being saved.
  196.    The latter must include the registers where values are returned
  197.    and the register where structure-value addresses are passed.
  198.    Aside from that, you can include as many other registers as you like.  */
  199. #define CALL_USED_REGISTERS  \
  200. {                            \
  201.   1,1,1,1,0,0,0,0,         \
  202.   0,0,1,1,1,1,1,1,         \
  203.   1,1,1,1,0,0,0,0         \
  204. }
  205.  
  206. /* If doing stupid life analysis, avoid a bug causing a return value r0 to be
  207.    trampled.  This effectively reduces the number of available registers by 1.
  208.    XXX It is a hack, I know.
  209.    XXX Is this still needed?  */
  210. #define CONDITIONAL_REGISTER_USAGE  \
  211. {            \
  212.   if (obey_regdecls)    \
  213.     fixed_regs[0] = 1;    \
  214. }
  215.  
  216. /* Return number of consecutive hard regs needed starting at reg REGNO
  217.    to hold something of mode MODE.
  218.    This is ordinarily the length in words of a value of mode MODE
  219.    but can be less for certain modes in special long registers.
  220.  
  221.    On the ARM regs are UNITS_PER_WORD bits wide; FPU regs can hold any FP
  222.    mode.  */
  223. #define HARD_REGNO_NREGS(REGNO, MODE)  \
  224.     ((REGNO) >= 16 ? 1                            \
  225.      : ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD))
  226.  
  227. /* Value is 1 if hard register REGNO can hold a value of machine-mode MODE.
  228.    This is TRUE for ARM regs since they can hold anything, and TRUE for FPU
  229.    regs holding FP.  */
  230. #define HARD_REGNO_MODE_OK(REGNO, MODE)  \
  231.   ((REGNO) < 16 || GET_MODE_CLASS (MODE) == MODE_FLOAT)
  232.  
  233. /* Value is 1 if it is a good idea to tie two pseudo registers
  234.    when one has mode MODE1 and one has mode MODE2.
  235.    If HARD_REGNO_MODE_OK could produce different values for MODE1 and MODE2,
  236.    for any hard reg, then this must be 0 for correct output.  */
  237. #define MODES_TIEABLE_P(MODE1, MODE2)  \
  238.   (((MODE1) == SFmode || (MODE1) == DFmode)      \
  239.    == ((MODE2) == SFmode || (MODE2) == DFmode))
  240.  
  241. /* Specify the registers used for certain standard purposes.
  242.    The values of these macros are register numbers.  */
  243.  
  244. /* Define this if the program counter is overloaded on a register.  */
  245. #define PC_REGNUM        15
  246.  
  247. /* Register to use for pushing function arguments.  */
  248. #define STACK_POI