OpenCores
URL https://opencores.org/ocsvn/scarts/scarts/trunk

Subversion Repositories scarts

[/] [scarts/] [trunk/] [toolchain/] [scarts-gcc/] [gcc-4.1.1/] [gcc/] [config/] [mmix/] [mmix.h] - Blame information for rev 12

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 12 jlechner 
/* Definitions of target machine for GNU compiler, for MMIX.
2 
   Copyright (C) 2000, 2001, 2002, 2004, 2005 Free Software Foundation, Inc.
3 
   Contributed by Hans-Peter Nilsson (hp@bitrange.com)
4 
 
5 
This file is part of GCC.
6 
 
7 
GCC 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 
GCC 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 GCC; see the file COPYING.  If not, write to
19 
the Free Software Foundation, 51 Franklin Street, Fifth Floor,
20 
Boston, MA 02110-1301, USA.  */
21 
 
22 
#ifndef GCC_MMIX_H
23 
#define GCC_MMIX_H
24 
 
25 
/* First, some local helper macros.  Note that the "default" value of
26 
   FIXED_REGISTERS, CALL_USED_REGISTERS, REG_ALLOC_ORDER and
27 
   REG_CLASS_CONTENTS depend on these values.  */
28 
#define MMIX_RESERVED_GNU_ARG_0_REGNUM 231
29 
#define MMIX_FIRST_ARG_REGNUM \
30 
  (TARGET_ABI_GNU ? MMIX_RESERVED_GNU_ARG_0_REGNUM : 16)
31 
#define MMIX_FIRST_INCOMING_ARG_REGNUM \
32 
  (TARGET_ABI_GNU ? MMIX_RESERVED_GNU_ARG_0_REGNUM : 0)
33 
#define MMIX_MAX_ARGS_IN_REGS 16
34 
 
35 
/* FIXME: This one isn't fully implemented yet.  Return values larger than
36 
   one register are passed by reference in MMIX_STRUCT_VALUE_REGNUM by the
37 
   caller, except for return values of type "complex".  */
38 
#define MMIX_MAX_REGS_FOR_VALUE 16
39 
#define MMIX_RETURN_VALUE_REGNUM \
40 
  (TARGET_ABI_GNU ? MMIX_RESERVED_GNU_ARG_0_REGNUM : 15)
41 
#define MMIX_OUTGOING_RETURN_VALUE_REGNUM \
42 
  (TARGET_ABI_GNU ? MMIX_RESERVED_GNU_ARG_0_REGNUM : 0)
43 
#define MMIX_STRUCT_VALUE_REGNUM 251
44 
#define MMIX_STATIC_CHAIN_REGNUM 252
45 
#define MMIX_FRAME_POINTER_REGNUM 253
46 
#define MMIX_STACK_POINTER_REGNUM 254
47 
#define MMIX_LAST_GENERAL_REGISTER 255
48 
#define MMIX_INCOMING_RETURN_ADDRESS_REGNUM MMIX_rJ_REGNUM
49 
#define MMIX_HIMULT_REGNUM 258
50 
#define MMIX_REMAINDER_REGNUM MMIX_rR_REGNUM
51 
#define MMIX_ARG_POINTER_REGNUM 261
52 
#define MMIX_rO_REGNUM 262
53 
#define MMIX_LAST_STACK_REGISTER_REGNUM 31
54 
 
55 
/* Four registers; "ideally, these registers should be call-clobbered", so
56 
   just grab a bunch of the common clobbered registers.  FIXME: Last
57 
   registers of return-value should be used, with an error if there's a
58 
   return-value (that collides in size).  */
59 
#define MMIX_EH_RETURN_DATA_REGNO_START (MMIX_STRUCT_VALUE_REGNUM - 4)
60 
 
61 
/* Try to keep the definitions from running away on their own.  */
62 
#if (MMIX_EH_RETURN_DATA_REGNO_START \
63 
     != MMIX_RESERVED_GNU_ARG_0_REGNUM + MMIX_MAX_ARGS_IN_REGS)
64 
 #error MMIX register definition inconsistency
65 
#endif
66 
 
67 
#if (MMIX_MAX_REGS_FOR_VALUE + MMIX_MAX_ARGS_IN_REGS > 32)
68 
 #error MMIX parameters and return values bad, more than 32 registers
69 
#endif
70 
 
71 
/* This chosen as "a call-clobbered hard register that is otherwise
72 
   untouched by the epilogue".  */
73 
#define MMIX_EH_RETURN_STACKADJ_REGNUM MMIX_STATIC_CHAIN_REGNUM
74 
 
75 
#ifdef REG_OK_STRICT
76 
# define MMIX_REG_OK_STRICT 1
77 
#else
78 
# define MMIX_REG_OK_STRICT 0
79 
#endif
80 
 
81 
#define MMIX_FUNCTION_ARG_SIZE(MODE, TYPE) \
82 
 ((MODE) != BLKmode ? GET_MODE_SIZE (MODE) : int_size_in_bytes (TYPE))
83 
 
84 
/* Declarations for helper variables that are not tied to a particular
85 
   target macro.  */
86 
extern GTY(()) rtx mmix_compare_op0;
87 
extern GTY(()) rtx mmix_compare_op1;
88 
 
89 
/* Per-function machine data.  This is normally an opaque type just
90 
   defined and used in the tm.c file, but we need to see the definition in
91 
   mmix.md too.  */
92 
struct machine_function GTY(())
93 
 {
94 
   int has_landing_pad;
95 
   int highest_saved_stack_register;
96 
   int in_prologue;
97 
 };
98 
 
99 
/* For these target macros, there is no generic documentation here.  You
100 
   should read `Using and Porting GCC' for that.  Only comments specific
101 
   to the MMIX target are here.
102 
 
103 
   There are however references to the specific texinfo node (comments
104 
   with "Node:"), so there should be little or nothing amiss.  Probably
105 
   the opposite, since we don't have to care about old littering and
106 
   soon outdated generic comments.  */
107 
 
108 
/* Node: Driver */
109 
 
110 
/* User symbols are in the same name-space as built-in symbols, but we
111 
   don't need the built-in symbols, so remove those and instead apply
112 
   stricter operand checking.  Don't warn when expanding insns.  */
113 
#define ASM_SPEC "-no-predefined-syms -x"
114 
 
115 
/* Pass on -mset-program-start=N and -mset-data-start=M to the linker.
116 
   Provide default program start 0x100 unless -mno-set-program-start.
117 
   Don't do this if linking relocatably, with -r.  For a final link,
118 
   produce mmo, unless ELF is requested or when linking relocatably.  */
119 
#define LINK_SPEC \
120 
 "%{mset-program-start=*:--defsym __.MMIX.start..text=%*}\
121 
  %{mset-data-start=*:--defsym __.MMIX.start..data=%*}\
122 
  %{!mset-program-start=*:\
123 
    %{!mno-set-program-start:\
124 
     %{!r:--defsym __.MMIX.start..text=0x100}}}\
125 
  %{!melf:%{!r:-m mmo}}%{melf|r:-m elf64mmix}"
126 
 
127 
/* FIXME: There's no provision for profiling here.  */
128 
#define STARTFILE_SPEC  \
129 
  "crti%O%s crtbegin%O%s"
130 
 
131 
#define ENDFILE_SPEC "crtend%O%s crtn%O%s"
132 
 
133 
/* Node: Run-time Target */
134 
 
135 
/* Define __LONG_MAX__, since we're advised not to change glimits.h.  */
136 
#define TARGET_CPU_CPP_BUILTINS()                               \
137 
  do                                                            \
138 
    {                                                           \
139 
      builtin_define ("__mmix__");                              \
140 
      builtin_define ("__MMIX__");                              \
141 
      if (TARGET_ABI_GNU)                                       \
142 
        builtin_define ("__MMIX_ABI_GNU__");                    \
143 
      else                                                      \
144 
        builtin_define ("__MMIX_ABI_MMIXWARE__");               \
145 
    }                                                           \
146 
  while (0)
147 
 
148 
extern int target_flags;
149 
 
150 
#define TARGET_DEFAULT \
151 
 (MASK_BRANCH_PREDICT | MASK_BASE_ADDRESSES | MASK_USE_RETURN_INSN)
152 
 
153 
/* Unfortunately, this must not reference anything in "mmix.c".  */
154 
#define TARGET_VERSION \
155 
  fprintf (stderr, " (MMIX)")
156 
 
157 
#define OVERRIDE_OPTIONS mmix_override_options ()
158 
 
159 
#define OPTIMIZATION_OPTIONS(LEVEL, SIZE)       \
160 
  do                                            \
161 
    {                                           \
162 
      if (LEVEL >= 1)                           \
163 
        flag_regmove = TRUE;                    \
164 
                                                \
165 
      if (SIZE || LEVEL > 1)                    \
166 
        {                                       \
167 
          flag_omit_frame_pointer = TRUE;       \
168 
          flag_strength_reduce = FALSE;         \
169 
        }                                       \
170 
    }                                           \
171 
  while (0)
172 
 
173 
/* This one will have to wait a little bit; right now we can't debug
174 
   neither with or without a frame-pointer.  */
175 
/* #define CAN_DEBUG_WITHOUT_FP */
176 
 
177 
 
178 
/* Node: Per-Function Data */
179 
#define INIT_EXPANDERS mmix_init_expanders ()
180 
 
181 
 
182 
/* Node: Storage Layout */
183 
/* I see no bit-field instructions.  Anyway, the common order is from low
184 
   to high, as the power of two, hence little-endian.  */
185 
#define BITS_BIG_ENDIAN 0
186 
#define BYTES_BIG_ENDIAN 1
187 
#define WORDS_BIG_ENDIAN 1
188 
#define FLOAT_WORDS_BIG_ENDIAN 1
189 
#define UNITS_PER_WORD 8
190 
 
191 
/* FIXME: Promotion of modes currently generates slow code, extending
192 
   before every operation.  */
193 
/* I'm a little bit undecided about this one.  It might be beneficial to
194 
   promote all operations.  */
195 
 
196 
#define PROMOTE_FUNCTION_MODE(MODE, UNSIGNEDP, TYPE)    \
197 
 do {                                           \
198 
  if (GET_MODE_CLASS (MODE) == MODE_INT         \
199 
      && GET_MODE_SIZE (MODE) < 8)              \
200 
   {                                            \
201 
     (MODE) = DImode;                           \
202 
     /* Do the following some time later,       \
203 
        scrutinizing differences.  */           \
204 
     if (0) (UNSIGNEDP) = 0;                      \
205 
   }                                            \
206 
 } while (0)
207 
 
208 
/* We need to align everything to 64 bits that can affect the alignment
209 
   of other types.  Since address N is interpreted in MMIX as (N modulo
210 
   access_size), we must align.  */
211 
#define PARM_BOUNDARY 64
212 
#define STACK_BOUNDARY 64
213 
#define FUNCTION_BOUNDARY 32
214 
#define BIGGEST_ALIGNMENT 64
215 
 
216 
/* This one is only used in the ADA front end.  */
217 
#define MINIMUM_ATOMIC_ALIGNMENT 8
218 
 
219 
/* Copied from elfos.h.  */
220 
#define MAX_OFILE_ALIGNMENT (32768 * 8)
221 
 
222 
#define DATA_ALIGNMENT(TYPE, BASIC_ALIGN) \
223 
 mmix_data_alignment (TYPE, BASIC_ALIGN)
224 
 
225 
#define CONSTANT_ALIGNMENT(CONSTANT, BASIC_ALIGN) \
226 
 mmix_constant_alignment (CONSTANT, BASIC_ALIGN)
227 
 
228 
#define LOCAL_ALIGNMENT(TYPE, BASIC_ALIGN) \
229 
 mmix_local_alignment (TYPE, BASIC_ALIGN)
230 
 
231 
/* Following other ports, this seems to most commonly be the word-size,
232 
   so let's do that here too.  */
233 
#define EMPTY_FIELD_BOUNDARY 64
234 
 
235 
/* We chose to have this low solely for similarity with the alpha.  It has
236 
   nothing to do with passing the tests dg/c99-scope-2 and
237 
   execute/align-1.c.  Nothing.  Though the tests seem wrong.  Padding of
238 
   the structure is automatically added to get alignment when needed if we
239 
   set this to just byte-boundary.  */
240 
#define STRUCTURE_SIZE_BOUNDARY 8
241 
 
242 
/* The lower bits are ignored.  */
243 
#define STRICT_ALIGNMENT 1
244 
 
245 
 
246 
/* Node: Type Layout */
247 
 
248 
/* It might seem more natural to have 64-bit ints on a 64-bit machine,
249 
   but then an occasional MMIX programmer needs to know how to put a lot
250 
   of __attribute__ stuff to get to the 8, 16 and 32-bit modes rather
251 
   than the "intuitive" char, short and int types.  */
252 
#define INT_TYPE_SIZE 32
253 
#define SHORT_TYPE_SIZE 16
254 
#define LONG_LONG_TYPE_SIZE 64
255 
 
256 
#define FLOAT_TYPE_SIZE 32
257 
#define DOUBLE_TYPE_SIZE 64
258 
#define LONG_DOUBLE_TYPE_SIZE 64
259 
 
260 
#define DEFAULT_SIGNED_CHAR 1
261 
 
262 
 
263 
/* Node: Register Basics */
264 
/* We tell GCC about all 256 general registers, and we also include
265 
   rD, rE, rH, rJ, rR and rO (in that order) so we can describe what insns
266 
   clobber them.  We use a faked register for the argument pointer.  It is
267 
   always eliminated towards the frame-pointer or the stack-pointer, never
268 
   output in assembly.  Any fixed register would do for this, like $255,
269 
   but future debugging is easier when using a separate register.  It
270 
   counts as a global register for pseudorandom reasons.  */
271 
#define FIRST_PSEUDO_REGISTER 263
272 
 
273 
/* We treat general registers with no assigned purpose as fixed.  The
274 
   stack pointer, $254, is also fixed.  Register $255 is referred to as a
275 
   temporary register in the MMIX papers, and used as such in mmixal, so
276 
   it should not be used as a stack pointer.  We set it to fixed, and use
277 
   it "manually" at times of despair.  */
278 
#define FIXED_REGISTERS \
279 
 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
280 
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
281 
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
282 
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
283 
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
284 
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
285 
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
286 
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
287 
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
288 
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
289 
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
290 
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
291 
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
292 
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
293 
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
294 
   1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, \
295 
   1, 1, 0, 0, 0, 1, 1 \
296 
 }
297 
 
298 
/* General registers are fixed and therefore "historically" marked
299 
   call-used.  (FIXME: This has changed).  Registers $15..$31 are
300 
   call-clobbered; we'll put arguments in $16 and up, and we need $15 for
301 
   the MMIX register-stack "hole".  */
302 
#define CALL_USED_REGISTERS \
303 
 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, \
304 
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
305 
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
306 
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
307 
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
308 
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
309 
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
310 
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
311 
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
312 
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
313 
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
314 
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
315 
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
316 
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
317 
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
318 
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, \
319 
   1, 1, 1, 1, 1, 1, 1 \
320 
 }
321 
 
322 
#define CONDITIONAL_REGISTER_USAGE mmix_conditional_register_usage ()
323 
 
324 
/* No INCOMING_REGNO or OUTGOING_REGNO, since those macros are not usable
325 
   for MMIX: it doesn't have a fixed register window size.  FIXME: Perhaps
326 
   we should say something about $0..$15 may sometimes be the incoming
327 
   $16..$31.  Those macros need better documentation; it looks like
328 
   they're just bogus and that FUNCTION_INCOMING_ARG_REGNO_P and
329 
   FUNCTION_OUTGOING_VALUE should be used where they're used.  For the
330 
   moment, do nothing; things seem to work anyway.  */
331 
 
332 
/* Defining LOCAL_REGNO is necessary in presence of prologue/epilogue,
333 
   else GCC will be confused that those registers aren't saved and
334 
   restored.  */
335 
#define LOCAL_REGNO(REGNO) mmix_local_regno (REGNO)
336 
 
337 
/* Node: Allocation Order */
338 
 
339 
/* We should allocate registers from 0 to 31 by increasing number, because
340 
   I think that's what people expect.  Beyond that, just use
341 
   call-clobbered global registers first, then call-clobbered special
342 
   registers.  Last, the fixed registers.  */
343 
#define MMIX_MMIXWARE_ABI_REG_ALLOC_ORDER       \
344 
 { 0, 1, 2, 3, 4, 5, 6, 7,                       \
345 
   8, 9, 10, 11, 12, 13, 14, 15,                \
346 
   16, 17, 18, 19, 20, 21, 22, 23,              \
347 
   24, 25, 26, 27, 28, 29, 30, 31,              \
348 
                                                \
349 
   252, 251, 250, 249, 248, 247,                \
350 
                                                \
351 
   253,                                         \
352 
                                                \
353 
   258, 260, 259,                               \
354 
                                                \
355 
   32, 33, 34, 35, 36, 37, 38, 39,              \
356 
   40, 41, 42, 43, 44, 45, 46, 47,              \
357 
   48, 49, 50, 51, 52, 53, 54, 55,              \
358 
   56, 57, 58, 59, 60, 61, 62, 63,              \
359 
   64, 65, 66, 67, 68, 69, 70, 71,              \
360 
   72, 73, 74, 75, 76, 77, 78, 79,              \
361 
   80, 81, 82, 83, 84, 85, 86, 87,              \
362 
   88, 89, 90, 91, 92, 93, 94, 95,              \
363 
   96, 97, 98, 99, 100, 101, 102, 103,          \
364 
   104, 105, 106, 107, 108, 109, 110, 111,      \
365 
   112, 113, 114, 115, 116, 117, 118, 119,      \
366 
   120, 121, 122, 123, 124, 125, 126, 127,      \
367 
   128, 129, 130, 131, 132, 133, 134, 135,      \
368 
   136, 137, 138, 139, 140, 141, 142, 143,      \
369 
   144, 145, 146, 147, 148, 149, 150, 151,      \
370 
   152, 153, 154, 155, 156, 157, 158, 159,      \
371 
   160, 161, 162, 163, 164, 165, 166, 167,      \
372 
   168, 169, 170, 171, 172, 173, 174, 175,      \
373 
   176, 177, 178, 179, 180, 181, 182, 183,      \
374 
   184, 185, 186, 187, 188, 189, 190, 191,      \
375 
   192, 193, 194, 195, 196, 197, 198, 199,      \
376 
   200, 201, 202, 203, 204, 205, 206, 207,      \
377 
   208, 209, 210, 211, 212, 213, 214, 215,      \
378 
   216, 217, 218, 219, 220, 221, 222, 223,      \
379 
   224, 225, 226, 227, 228, 229, 230, 231,      \
380 
   232, 233, 234, 235, 236, 237, 238, 239,      \
381 
   240, 241, 242, 243, 244, 245, 246,           \
382 
                                                \
383 
   254, 255, 256, 257, 261, 262                 \
384 
 }
385 
 
386 
/* As a convenience, we put this nearby, for ease of comparison.
387 
   First, call-clobbered registers in reverse order of assignment as
388 
   parameters (also the top ones; not because they're parameters, but
389 
   for continuity).
390 
 
391 
   Second, saved registers that go on the register-stack.
392 
 
393 
   Third, special registers rH, rR and rJ.  They should not normally be
394 
   allocated, but since they're call-clobbered, it is cheaper to use one
395 
   of them than using a call-saved register for a call-clobbered use,
396 
   assuming it is referenced a very limited number of times.  Other global
397 
   and fixed registers come next; they are never allocated.  */
398 
#define MMIX_GNU_ABI_REG_ALLOC_ORDER            \
399 
 { 252, 251, 250, 249, 248, 247, 246,           \
400 
   245, 244, 243, 242, 241, 240, 239, 238,      \
401 
   237, 236, 235, 234, 233, 232, 231,           \
402 
                                                \
403 
   0, 1, 2, 3, 4, 5, 6, 7,                       \
404 
   8, 9, 10, 11, 12, 13, 14, 15,                \
405 
   16, 17, 18, 19, 20, 21, 22, 23,              \
406 
   24, 25, 26, 27, 28, 29, 30, 31,              \
407 
                                                \
408 
   253,                                         \
409 
                                                \
410 
   258, 260, 259,                               \
411 
                                                \
412 
   32, 33, 34, 35, 36, 37, 38, 39,              \
413 
   40, 41, 42, 43, 44, 45, 46, 47,              \
414 
   48, 49, 50, 51, 52, 53, 54, 55,              \
415 
   56, 57, 58, 59, 60, 61, 62, 63,              \
416 
   64, 65, 66, 67, 68, 69, 70, 71,              \
417 
   72, 73, 74, 75, 76, 77, 78, 79,              \
418 
   80, 81, 82, 83, 84, 85, 86, 87,              \
419 
   88, 89, 90, 91, 92, 93, 94, 95,              \
420 
   96, 97, 98, 99, 100, 101, 102, 103,          \
421 
   104, 105, 106, 107, 108, 109, 110, 111,      \
422 
   112, 113, 114, 115, 116, 117, 118, 119,      \
423 
   120, 121, 122, 123, 124, 125, 126, 127,      \
424 
   128, 129, 130, 131, 132, 133, 134, 135,      \
425 
   136, 137, 138, 139, 140, 141, 142, 143,      \
426 
   144, 145, 146, 147, 148, 149, 150, 151,      \
427 
   152, 153, 154, 155, 156, 157, 158, 159,      \
428 
   160, 161, 162, 163, 164, 165, 166, 167,      \
429 
   168, 169, 170, 171, 172, 173, 174, 175,      \
430 
   176, 177, 178, 179, 180, 181, 182, 183,      \
431 
   184, 185, 186, 187, 188, 189, 190, 191,      \
432 
   192, 193, 194, 195, 196, 197, 198, 199,      \
433 
   200, 201, 202, 203, 204, 205, 206, 207,      \
434 
   208, 209, 210, 211, 212, 213, 214, 215,      \
435 
   216, 217, 218, 219, 220, 221, 222, 223,      \
436 
   224, 225, 226, 227, 228, 229, 230,           \
437 
                                                \
438 
   254, 255, 256, 257, 261, 262                 \
439 
 }
440 
 
441 
/* The default one.  */
442 
#define REG_ALLOC_ORDER MMIX_MMIXWARE_ABI_REG_ALLOC_ORDER
443 
 
444 
/* Node: Values in Registers */
445 
 
446 
#define HARD_REGNO_NREGS(REGNO, MODE)                   \
447 
   ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1)         \
448 
    / UNITS_PER_WORD)
449 
 
450 
#define HARD_REGNO_MODE_OK(REGNO, MODE) 1
451 
 
452 
/* Note that no register can really be accessed in single-float mode, so
453 
   we *can* say 1 here.  FIXME:  Will TRT happen for single-float, or do
454 
   we have to punt to libgcc1.asm?  */
455 
#define MODES_TIEABLE_P(MODE1, MODE2) 1
456 
 
457 
 
458 
/* Node: Leaf Functions */
459 
/* (empty) */
460 
 
461 
 
462 
/* Node: Register Classes */
463 
 
464 
enum reg_class
465 
 {
466 
   NO_REGS, GENERAL_REGS, REMAINDER_REG, HIMULT_REG,
467 
   SYSTEM_REGS, ALL_REGS, LIM_REG_CLASSES
468 
 };
469 
 
470 
#define N_REG_CLASSES (int) LIM_REG_CLASSES
471 
 
472 
#define REG_CLASS_NAMES                                         \
473 
 {"NO_REGS", "GENERAL_REGS", "REMAINDER_REG", "HIMULT_REG",     \
474 
  "SYSTEM_REGS", "ALL_REGS"}
475 
 
476 
/* Note that the contents of each item is always 32 bits.  */
477 
#define REG_CLASS_CONTENTS                      \
478 
 {{0, 0, 0, 0, 0, 0, 0, 0, 0},                   \
479 
  {~0, ~0, ~0, ~0, ~0, ~0, ~0, ~0, 0x20},       \
480 
  {0, 0, 0, 0, 0, 0, 0, 0, 0x10},               \
481 
  {0, 0, 0, 0, 0, 0, 0, 0, 4},                  \
482 
  {0, 0, 0, 0, 0, 0, 0, 0, 0x7f},               \
483 
  {~0, ~0, ~0, ~0, ~0, ~0, ~0, ~0, 0x7f}}
484 
 
485 
#define REGNO_REG_CLASS(REGNO)                                  \
486 
 ((REGNO) <= MMIX_LAST_GENERAL_REGISTER                         \
487 
  || (REGNO) == MMIX_ARG_POINTER_REGNUM                         \
488 
  ? GENERAL_REGS                                                \
489 
  : (REGNO) == MMIX_REMAINDER_REGNUM ? REMAINDER_REG            \
490 
  : (REGNO) == MMIX_HIMULT_REGNUM ? HIMULT_REG : SYSTEM_REGS)
491 
 
492 
#define BASE_REG_CLASS GENERAL_REGS
493 
 
494 
#define INDEX_REG_CLASS GENERAL_REGS
495 
 
496 
#define REG_CLASS_FROM_LETTER(CHAR)             \
497 
 ((CHAR) == 'x' ? SYSTEM_REGS                   \
498 
  : (CHAR) == 'y' ? REMAINDER_REG               \
499 
  : (CHAR) == 'z' ? HIMULT_REG : NO_REGS)
500 
 
501 
#define REGNO_OK_FOR_BASE_P(REGNO)                              \
502 
 ((REGNO) <= MMIX_LAST_GENERAL_REGISTER                         \
503 
  || (REGNO) == MMIX_ARG_POINTER_REGNUM                         \
504 
  || (reg_renumber[REGNO] > 0                                    \
505 
      && reg_renumber[REGNO] <= MMIX_LAST_GENERAL_REGISTER))
506 
 
507 
#define REGNO_OK_FOR_INDEX_P(REGNO) REGNO_OK_FOR_BASE_P (REGNO)
508 
 
509 
#define PREFERRED_RELOAD_CLASS(X, CLASS) \
510 
 mmix_preferred_reload_class (X, CLASS)
511 
 
512 
#define PREFERRED_OUTPUT_RELOAD_CLASS(X, CLASS) \
513 
 mmix_preferred_output_reload_class (X, CLASS)
514 
 
515 
#define SECONDARY_INPUT_RELOAD_CLASS(CLASS, MODE, X) \
516 
 mmix_secondary_reload_class (CLASS, MODE, X, 1)
517 
 
518 
#define SECONDARY_OUTPUT_RELOAD_CLASS(CLASS, MODE, X) \
519 
 mmix_secondary_reload_class (CLASS, MODE, X, 0)
520 
 
521 
#define CLASS_MAX_NREGS(CLASS, MODE) HARD_REGNO_NREGS (CLASS, MODE)
522 
 
523 
#define CONST_OK_FOR_LETTER_P(VALUE, C) \
524 
 mmix_const_ok_for_letter_p (VALUE, C)
525 
 
526 
#define EXTRA_CONSTRAINT(VALUE, C)      \
527 
 mmix_extra_constraint (VALUE, C, MMIX_REG_OK_STRICT)
528 
 
529 
/* Do we need anything serious here?  Yes, any FLOT constant.  */
530 
#define CONST_DOUBLE_OK_FOR_LETTER_P(VALUE, C)                  \
531 
 mmix_const_double_ok_for_letter_p (VALUE, C)
532 
 
533 
 
534 
/* Node: Frame Layout */
535 
 
536 
#define STACK_GROWS_DOWNWARD
537 
#define FRAME_GROWS_DOWNWARD 1
538 
 
539 
#define STARTING_FRAME_OFFSET \
540 
  mmix_starting_frame_offset ()
541 
 
542 
#define FIRST_PARM_OFFSET(FUNDECL) 0
543 
 
544 
#define DYNAMIC_CHAIN_ADDRESS(FRAMEADDR) \
545 
 mmix_dynamic_chain_address (FRAMEADDR)
546 
 
547 
/* FIXME: It seems RETURN_ADDR_OFFSET is undocumented.  */
548 
 
549 
#define SETUP_FRAME_ADDRESSES() \
550 
 mmix_setup_frame_addresses ()
551 
 
552 
#define RETURN_ADDR_RTX(COUNT, FRAME)           \
553 
 mmix_return_addr_rtx (COUNT, FRAME)
554 
 
555 
/* It's in rJ before we store it somewhere.  */
556 
#define INCOMING_RETURN_ADDR_RTX \
557 
 gen_rtx_REG (Pmode, MMIX_INCOMING_RETURN_ADDRESS_REGNUM)
558 
 
559 
/* FIXME: This does not seem properly documented or cross-indexed.
560 
   Nowhere except in the code does it say it *has* to be in the range
561 
   0..255, or else it will be truncated.  That goes for the default too.  */
562 
#define DWARF_FRAME_RETURN_COLUMN \
563 
 DWARF_FRAME_REGNUM (MMIX_INCOMING_RETURN_ADDRESS_REGNUM)
564 
 
565 
/* No return address is stored there.  */
566 
#define INCOMING_FRAME_SP_OFFSET 0
567 
 
568 
/* Node: Stack Checking */
569 
/* (empty) */
570 
 
571 
 
572 
/* Node: Exception Handling */
573 
 
574 
#define EH_RETURN_DATA_REGNO(N) \
575 
 mmix_eh_return_data_regno (N)
576 
 
577 
#define EH_RETURN_STACKADJ_RTX \
578 
 mmix_eh_return_stackadj_rtx ()
579 
 
580 
#define EH_RETURN_HANDLER_RTX \
581 
 mmix_eh_return_handler_rtx ()
582 
 
583 
#define ASM_PREFERRED_EH_DATA_FORMAT(CODE, GLOBAL) \
584 
 mmix_asm_preferred_eh_data_format (CODE, GLOBAL)
585 
 
586 
/* Node: Frame Registers */
587 
#define STACK_POINTER_REGNUM MMIX_STACK_POINTER_REGNUM
588 
 
589 
/* Perhaps we can use HARD_FRAME_POINTER_REGNUM and decide later on
590 
   what register we want to use.  */
591 
#define FRAME_POINTER_REGNUM MMIX_FRAME_POINTER_REGNUM
592 
#define ARG_POINTER_REGNUM MMIX_ARG_POINTER_REGNUM
593 
 
594 
#define STATIC_CHAIN_REGNUM MMIX_STATIC_CHAIN_REGNUM
595 
 
596 
 
597 
/* Node: Elimination */
598 
/* FIXME: Is this requirement built-in?  Anyway, we should try to get rid
599 
   of it; we can deduce the value.  */
600 
#define FRAME_POINTER_REQUIRED  current_function_has_nonlocal_label
601 
 
602 
/* The frame-pointer is stored in a location that either counts to the
603 
   offset of incoming parameters, or that counts to the offset of the
604 
   frame, so we can't use a single offset.  We therefore eliminate those
605 
   two separately.  */
606 
#define ELIMINABLE_REGS                         \
607 
 {{ARG_POINTER_REGNUM, STACK_POINTER_REGNUM},   \
608 
  {ARG_POINTER_REGNUM, FRAME_POINTER_REGNUM},   \
609 
  {FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM}}
610 
 
611 
/* We need not worry about when the frame-pointer is required for other
612 
   reasons; GCC takes care of those cases.  */
613 
#define CAN_ELIMINATE(FROM, TO) 1
614 
 
615 
#define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET) \
616 
 (OFFSET) = mmix_initial_elimination_offset (FROM, TO)
617 
 
618 
 
619 
/* Node: Stack Arguments */
620 
 
621 
#define ACCUMULATE_OUTGOING_ARGS 1
622 
 
623 
#define RETURN_POPS_ARGS(FUNDECL, FUNTYPE, STACKSIZE) 0
624 
 
625 
 
626 
/* Node: Register Arguments */
627 
#define FUNCTION_ARG(CUM, MODE, TYPE, NAMED)    \
628 
 mmix_function_arg (&(CUM), MODE, TYPE, NAMED, 0)
629 
 
630 
#define FUNCTION_INCOMING_ARG(CUM, MODE, TYPE, NAMED)   \
631 
 mmix_function_arg (&(CUM), MODE, TYPE, NAMED, 1)
632 
 
633 
typedef struct { int regs; int lib; } CUMULATIVE_ARGS;
634 
 
635 
#define INIT_CUMULATIVE_ARGS(CUM, FNTYPE, LIBNAME, INDIRECT, N_NAMED_ARGS) \
636 
 ((CUM).regs = 0, (CUM).lib = ((LIBNAME) != 0))
637 
 
638 
#define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED)            \
639 
 ((CUM).regs                                                    \
640 
  = ((targetm.calls.must_pass_in_stack (MODE, TYPE))            \
641 
     || (MMIX_FUNCTION_ARG_SIZE (MODE, TYPE) > 8                \
642 
         && !TARGET_LIBFUNC && !(CUM).lib))                     \
643 
  ? (MMIX_MAX_ARGS_IN_REGS) + 1                                 \
644 
  : (CUM).regs + (7 + (MMIX_FUNCTION_ARG_SIZE (MODE, TYPE))) / 8)
645 
 
646 
#define FUNCTION_ARG_REGNO_P(REGNO)             \
647 
 mmix_function_arg_regno_p (REGNO, 0)
648 
 
649 
#define FUNCTION_INCOMING_ARG_REGNO_P(REGNO)            \
650 
 mmix_function_arg_regno_p (REGNO, 1)
651 
 
652 
 
653 
/* Node: Register Arguments */
654 
 
655 
#define FUNCTION_VALUE(VALTYPE, FUNC)  \
656 
 gen_rtx_REG (TYPE_MODE (VALTYPE), MMIX_RETURN_VALUE_REGNUM)
657 
 
658 
/* This needs to take care of the register hole for complex return values.  */
659 
#define FUNCTION_OUTGOING_VALUE(VALTYPE, FUNC)  \
660 
 mmix_function_outgoing_value (VALTYPE, FUNC)
661 
 
662 
#define LIBCALL_VALUE(MODE) \
663 
 gen_rtx_REG (MODE, MMIX_RETURN_VALUE_REGNUM)
664 
 
665 
#define FUNCTION_VALUE_REGNO_P(REGNO) \
666 
 mmix_function_value_regno_p (REGNO)
667 
 
668 
 
669 
/* Node: Caller Saves */
670 
/* (empty) */
671 
 
672 
 
673 
/* Node: Function Entry */
674 
 
675 
/* See mmix.c for TARGET_ASM_FUNCTION_PROLOGUE and
676 
   TARGET_ASM_FUNCTION_EPILOGUE.  */
677 
 
678 
/* We need to say that the epilogue uses the return address, so the
679 
   initial-value machinery restores it.  FIXME: Some targets
680 
   conditionalize on "reload_completed &&".  Investigate difference.
681 
   FIXME: Not needed if nonlocal_goto_stack_level.  */
682 
#define EPILOGUE_USES(REGNO) \
683 
 ((REGNO) == MMIX_INCOMING_RETURN_ADDRESS_REGNUM)
684 
 
685 
/* Node: Profiling */
686 
#define FUNCTION_PROFILER(FILE, LABELNO)        \
687 
 mmix_function_profiler (FILE, LABELNO)
688 
 
689 
/* Node: Trampolines */
690 
 
691 
#define TRAMPOLINE_TEMPLATE(FILE) \
692 
 mmix_trampoline_template (FILE)
693 
 
694 
#define TRAMPOLINE_SIZE mmix_trampoline_size
695 
#define INITIALIZE_TRAMPOLINE(ADDR, FNADDR, STATIC_CHAIN) \
696 
 mmix_initialize_trampoline (ADDR, FNADDR, STATIC_CHAIN)
697 
 
698 
 
699 
/* Node: Addressing Modes */
700 
 
701 
#define CONSTANT_ADDRESS_P(X) \
702 
 mmix_constant_address_p (X)
703 
 
704 
#define MAX_REGS_PER_ADDRESS 2
705 
 
706 
#define GO_IF_LEGITIMATE_ADDRESS(MODE, X, LABEL)                \
707 
 if (mmix_legitimate_address (MODE, X, MMIX_REG_OK_STRICT))     \
708 
   goto LABEL
709 
 
710 
#ifndef REG_OK_STRICT
711 
# define REG_OK_FOR_BASE_P(X)                   \
712 
  (REGNO (X) <= MMIX_LAST_GENERAL_REGISTER      \
713 
   || REGNO (X) == MMIX_ARG_POINTER_REGNUM      \
714 
   || REGNO (X) >= FIRST_PSEUDO_REGISTER)
715 
#else
716 
# define REG_OK_FOR_BASE_P(X) REGNO_OK_FOR_BASE_P (REGNO (X))
717 
#endif /* REG_OK_STRICT */
718 
 
719 
#define REG_OK_FOR_INDEX_P(X) REG_OK_FOR_BASE_P (X)
720 
 
721 
#define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR, LABEL)
722 
 
723 
#define LEGITIMATE_CONSTANT_P(X) \
724 
 mmix_legitimate_constant_p (X)
725 
 
726 
 
727 
/* Node: Condition Code */
728 
 
729 
#define SELECT_CC_MODE(OP, X, Y)                \
730 
 mmix_select_cc_mode (OP, X, Y)
731 
 
732 
/* A definition of CANONICALIZE_COMPARISON that changed LE and GT
733 
   comparisons with -1 to LT and GE respectively, and LT, LTU, GE or GEU
734 
   comparisons with 256 to 255 and LE, LEU, GT and GTU has been
735 
   ineffective; the code path for performing the changes did not trig for
736 
   neither the GCC testsuite nor ghostscript-6.52 nor Knuth's mmix.tar.gz
737 
   itself (core GCC functionality supposedly handling it) with sources
738 
   from 2002-06-06.  */
739 
 
740 
#define REVERSIBLE_CC_MODE(MODE)                \
741 
 mmix_reversible_cc_mode (MODE)
742 
 
743 
 
744 
/* Node: Costs */
745 
 
746 
/* The special registers can only move to and from general regs, and we
747 
   need to check that their constraints match, so say 3 for them.  */
748 
/* WARNING: gcc-2.7.2.2 i686-pc-linux-gnulibc1 (as shipped with RH 4.2)
749 
   miscompiles reload1.c:reload_cse_simplify_set; a call to
750 
   reload_cse_regno_equal_p is missing when checking if a substitution of
751 
   a register setting is valid if this is defined to just the expression
752 
   in mmix_register_move_cost.
753 
 
754 
   Symptom: a (all?) register setting is optimized away for e.g.
755 
   "char *p1(char *p) { return p+1; }" and the value of register zero ($0)
756 
   is returned.
757 
 
758 
   We can workaround by making this a function call - unknown if this
759 
   causes dire speed effects.  */
760 
#define REGISTER_MOVE_COST(MODE, FROM, TO) \
761 
 mmix_register_move_cost (MODE, FROM, TO)
762 
 
763 
#define SLOW_BYTE_ACCESS 0
764 
 
765 
 
766 
/* Node: Sections */
767 
 
768 
/* This must be a constant string, since it's used in crtstuff.c.  */
769 
#define TEXT_SECTION_ASM_OP \
770 
 "\t.text ! mmixal:= 9H LOC 8B"
771 
 
772 
/* FIXME: Not documented.  */
773 
#define DATA_SECTION_ASM_OP \
774 
 mmix_data_section_asm_op ()
775 
 
776 
#define READONLY_DATA_SECTION_ASM_OP    "\t.section\t.rodata"
777 
 
778 
/* Node: PIC */
779 
/* (empty) */
780 
 
781 
 
782 
/* Node: File Framework */
783 
 
784 
/* While any other punctuation character but ";" would do, we prefer "%"
785 
   or "!"; "!" is an unary operator and so will not be mistakenly included
786 
   in correctly formed expressions.  The hash character adds mass; catches
787 
   the eye.  We can't have it as a comment char by itself, since it's a
788 
   hex-number prefix.  */
789 
#define ASM_COMMENT_START "!#"
790 
 
791 
/* These aren't currently functional.  We just keep them as markers.  */
792 
#define ASM_APP_ON "%APP\n"
793 
#define ASM_APP_OFF "%NO_APP\n"
794 
 
795 
#define ASM_OUTPUT_SOURCE_FILENAME(STREAM, NAME) \
796 
 mmix_asm_output_source_filename (STREAM, NAME)
797 
 
798 
#define OUTPUT_QUOTED_STRING(STREAM, STRING) \
799 
 mmix_output_quoted_string (STREAM, STRING, strlen (STRING))
800 
 
801 
#define TARGET_ASM_NAMED_SECTION default_elf_asm_named_section
802 
 
803 
/* Node: Data Output */
804 
 
805 
#define ASM_OUTPUT_ASCII(STREAM, PTR, LEN) \
806 
 mmix_asm_output_ascii (STREAM, PTR, LEN)
807 
 
808 
/* Node: Uninitialized Data */
809 
 
810 
#define ASM_OUTPUT_ALIGNED_COMMON(ST, N, S, A) \
811 
 mmix_asm_output_aligned_common (ST, N, S, A)
812 
 
813 
#define ASM_OUTPUT_ALIGNED_LOCAL(ST, N, S, A) \
814 
 mmix_asm_output_aligned_local (ST, N, S, A)
815 
 
816 
 
817 
/* Node: Label Output */
818 
 
819 
#define ASM_OUTPUT_LABEL(STREAM, NAME) \
820 
 mmix_asm_output_label (STREAM, NAME)
821 
 
822 
#define ASM_OUTPUT_INTERNAL_LABEL(STREAM, NAME) \
823 
 mmix_asm_output_internal_label (STREAM, NAME)
824 
 
825 
#define ASM_DECLARE_REGISTER_GLOBAL(STREAM, DECL, REGNO, NAME) \
826 
 mmix_asm_declare_register_global (STREAM, DECL, REGNO, NAME)
827 
 
828 
#define GLOBAL_ASM_OP "\t.global "
829 
 
830 
#define ASM_WEAKEN_LABEL(STREAM, NAME) \
831 
 mmix_asm_weaken_label (STREAM, NAME)
832 
 
833 
#define MAKE_DECL_ONE_ONLY(DECL) \
834 
 mmix_make_decl_one_only (DECL)
835 
 
836 
#define ASM_OUTPUT_LABELREF(STREAM, NAME) \
837 
 mmix_asm_output_labelref (STREAM, NAME)
838 
 
839 
/* We insert a ":" to disambiguate against user symbols like L5.  */
840 
#define ASM_GENERATE_INTERNAL_LABEL(LABEL, PREFIX, NUM) \
841 
 sprintf (LABEL, "*%s:%ld", PREFIX, (long)(NUM))
842 
 
843 
/* Insert "::"; these are rarer than internal labels.  FIXME: Make sure no
844 
   ":" is seen in the object file; we don't really want that mmixal
845 
   feature visible there.  We don't want the default, which uses a dot;
846 
   that'd be incompatible with mmixal.  */
847 
#define ASM_PN_FORMAT "%s::%lu"
848 
 
849 
#define ASM_OUTPUT_DEF(STREAM, NAME, VALUE) \
850 
 mmix_asm_output_def (STREAM, NAME, VALUE)
851 
 
852 
/* Node: Macros for Initialization */
853 
/* We're compiling to ELF and linking to MMO; fundamental ELF features
854 
   that GCC depend on are there.  */
855 
 
856 
/* These must be constant strings, since they're used in crtstuff.c.  */
857 
#define INIT_SECTION_ASM_OP "\t.section .init,\"ax\" ! mmixal-incompatible"
858 
 
859 
#define FINI_SECTION_ASM_OP "\t.section .fini,\"ax\" ! mmixal-incompatible"
860 
 
861 
#define OBJECT_FORMAT_ELF
862 
 
863 
 
864 
/* Node: Instruction Output */
865 
 
866 
/* The non-$ register names must be prefixed with ":", since they're
867 
   affected by PREFIX.  We provide the non-colon names as additional
868 
   names.  */
869 
#define REGISTER_NAMES                                                  \
870 
 {"$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",                       \
871 
  "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",                 \
872 
  "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",               \
873 
  "$24", "$25", "$26", "$27", "$28", "$29", "$30", "$31",               \
874 
  "$32", "$33", "$34", "$35", "$36", "$37", "$38", "$39",               \
875 
  "$40", "$41", "$42", "$43", "$44", "$45", "$46", "$47",               \
876 
  "$48", "$49", "$50", "$51", "$52", "$53", "$54", "$55",               \
877 
  "$56", "$57", "$58", "$59", "$60", "$61", "$62", "$63",               \
878 
  "$64", "$65", "$66", "$67", "$68", "$69", "$70", "$71",               \
879 
  "$72", "$73", "$74", "$75", "$76", "$77", "$78", "$79",               \
880 
  "$80", "$81", "$82", "$83", "$84", "$85", "$86", "$87",               \
881 
  "$88", "$89", "$90", "$91", "$92", "$93", "$94", "$95",               \
882 
  "$96", "$97", "$98", "$99", "$100", "$101", "$102", "$103",           \
883 
  "$104", "$105", "$106", "$107", "$108", "$109", "$110", "$111",       \
884 
  "$112", "$113", "$114", "$115", "$116", "$117", "$118", "$119",       \
885 
  "$120", "$121", "$122", "$123", "$124", "$125", "$126", "$127",       \
886 
  "$128", "$129", "$130", "$131", "$132", "$133", "$134", "$135",       \
887 
  "$136", "$137", "$138", "$139", "$140", "$141", "$142", "$143",       \
888 
  "$144", "$145", "$146", "$147", "$148", "$149", "$150", "$151",       \
889 
  "$152", "$153", "$154", "$155", "$156", "$157", "$158", "$159",       \
890 
  "$160", "$161", "$162", "$163", "$164", "$165", "$166", "$167",       \
891 
  "$168", "$169", "$170", "$171", "$172", "$173", "$174", "$175",       \
892 
  "$176", "$177", "$178", "$179", "$180", "$181", "$182", "$183",       \
893 
  "$184", "$185", "$186", "$187", "$188", "$189", "$190", "$191",       \
894 
  "$192", "$193", "$194", "$195", "$196", "$197", "$198", "$199",       \
895 
  "$200", "$201", "$202", "$203", "$204", "$205", "$206", "$207",       \
896 
  "$208", "$209", "$210", "$211", "$212", "$213", "$214", "$215",       \
897 
  "$216", "$217", "$218", "$219", "$220", "$221", "$222", "$223",       \
898 
  "$224", "$225", "$226", "$227", "$228", "$229", "$230", "$231",       \
899 
  "$232", "$233", "$234", "$235", "$236", "$237", "$238", "$239",       \
900 
  "$240", "$241", "$242", "$243", "$244", "$245", "$246", "$247",       \
901 
  "$248", "$249", "$250", "$251", "$252", "$253", "$254", "$255",       \
902 
  ":rD",  ":rE",  ":rH",  ":rJ",  ":rR",  "ap_!BAD!", ":rO"}
903 
 
904 
#define ADDITIONAL_REGISTER_NAMES                       \
905 
 {{"sp", 254}, {":sp", 254}, {"rD", 256}, {"rE", 257},  \
906 
  {"rH", 258}, {"rJ", MMIX_rJ_REGNUM}, {"rO", MMIX_rO_REGNUM}}
907 
 
908 
#define PRINT_OPERAND(STREAM, X, CODE) \
909 
 mmix_print_operand (STREAM, X, CODE)
910 
 
911 
#define PRINT_OPERAND_PUNCT_VALID_P(CODE) \
912 
 mmix_print_operand_punct_valid_p (CODE)
913 
 
914 
#define PRINT_OPERAND_ADDRESS(STREAM, X) \
915 
 mmix_print_operand_address (STREAM, X)
916 
 
917 
#define ASM_OUTPUT_REG_PUSH(STREAM, REGNO) \
918 
 mmix_asm_output_reg_push (STREAM, REGNO)
919 
 
920 
#define ASM_OUTPUT_REG_POP(STREAM, REGNO) \
921 
 mmix_asm_output_reg_pop (STREAM, REGNO)
922 
 
923 
 
924 
/* Node: Dispatch Tables */
925 
 
926 
/* We define both types, since SImode is the better, but DImode the only
927 
   possible for mmixal so that's the one actually used.  */
928 
#define ASM_OUTPUT_ADDR_DIFF_ELT(STREAM, BODY, VALUE, REL) \
929 
 mmix_asm_output_addr_diff_elt (STREAM, BODY, VALUE, REL)
930 
 
931 
#define ASM_OUTPUT_ADDR_VEC_ELT(STREAM, VALUE) \
932 
 mmix_asm_output_addr_vec_elt (STREAM, VALUE)
933 
 
934 
 
935 
/* Node: Exception Region Output */
936 
/* (empty) */
937 
 
938 
/* Node: Alignment Output */
939 
 
940 
#define ASM_OUTPUT_SKIP(STREAM, NBYTES) \
941 
 mmix_asm_output_skip (STREAM, NBYTES)
942 
 
943 
#define ASM_OUTPUT_ALIGN(STREAM, POWER) \
944 
 mmix_asm_output_align (STREAM, POWER)
945 
 
946 
 
947 
/* Node: All Debuggers */
948 
 
949 
#define DBX_REGISTER_NUMBER(REGNO) \
950 
 mmix_dbx_register_number (REGNO)
951 
 
952 
 
953 
/* Node: DBX Options */
954 
/* (empty) */
955 
/* Node: DBX Hooks */
956 
/* (empty) */
957 
/* Node: File Names and DBX */
958 
/* (empty) */
959 
 
960 
 
961 
/* Node: SDB and DWARF */
962 
#define DWARF2_DEBUGGING_INFO 1
963 
#define DWARF2_ASM_LINE_DEBUG_INFO 1
964 
 
965 
/* Node: Misc */
966 
 
967 
/* There's no way to get a PC-relative offset into tables for SImode, so
968 
   for the moment we have absolute entries in DImode.
969 
   When we're going ELF, these should be SImode and 1.  */
970 
#define CASE_VECTOR_MODE DImode
971 
#define CASE_VECTOR_PC_RELATIVE 0
972 
 
973 
#define WORD_REGISTER_OPERATIONS
974 
 
975 
/* We have a choice, which makes this yet another parameter to tweak.  The
976 
   gut feeling is currently that SIGN_EXTEND wins; "int" is more frequent
977 
   than "unsigned int", and we have signed characters.  FIXME: measure.  */
978 
#define LOAD_EXTEND_OP(MODE) (TARGET_ZERO_EXTEND ? ZERO_EXTEND : SIGN_EXTEND)
979 
 
980 
#define MOVE_MAX 8
981 
 
982 
#define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1
983 
 
984 
/* ??? MMIX allows a choice of STORE_FLAG_VALUE.  Revisit later,
985 
   we don't have scc expanders yet.  */
986 
 
987 
#define Pmode DImode
988 
 
989 
#define FUNCTION_MODE QImode
990 
 
991 
#define NO_IMPLICIT_EXTERN_C
992 
 
993 
#define HANDLE_SYSV_PRAGMA 1
994 
 
995 
/* These are checked.  */
996 
#define DOLLARS_IN_IDENTIFIERS 0
997 
#define NO_DOLLAR_IN_LABEL
998 
#define NO_DOT_IN_LABEL
999 
 
1000 
#endif /* GCC_MMIX_H */
1001 
/*
1002 
 * Local variables:
1003 
 * eval: (c-set-style "gnu")
1004 
 * indent-tabs-mode: t
1005 
 * End:
1006 
 */

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.