OSDN Git Service

82357d85f53427ce2ecac2fc2315047c3fdd1e01
[pf3gnuchains/gcc-fork.git] / gcc / config / sparc / sparc.h
1 /* Definitions of target machine for GNU compiler, for Sun SPARC.
2    Copyright (C) 1987, 88, 89, 92, 94-6, 1997 Free Software Foundation, Inc.
3    Contributed by Michael Tiemann (tiemann@cygnus.com).
4    64 bit SPARC V9 support by Michael Tiemann, Jim Wilson, and Doug Evans,
5    at Cygnus Support.
6
7 This file is part of GNU CC.
8
9 GNU CC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2, or (at your option)
12 any later version.
13
14 GNU CC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with GNU CC; see the file COPYING.  If not, write to
21 the Free Software Foundation, 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA.  */
23
24 /* Note that some other tm.h files include this one and then override
25    whatever definitions are necessary.  */
26
27 /* Specify this in a cover file to provide bi-architecture (32/64) support.  */
28 /* #define SPARC_BI_ARCH */
29
30 /* Macro used later in this file to determine default architecture.  */
31 #define DEFAULT_ARCH32_P ((TARGET_DEFAULT & MASK_64BIT) == 0)
32
33 /* TARGET_ARCH{32,64} are the main macros to decide which of the two
34    architectures to compile for.  We allow targets to choose compile time or
35    runtime selection.  */
36 #ifdef SPARC_BI_ARCH
37 #define TARGET_ARCH32 (! TARGET_64BIT)
38 #else
39 #define TARGET_ARCH32 (DEFAULT_ARCH32_P)
40 #endif
41 #define TARGET_ARCH64 (! TARGET_ARCH32)
42
43 /* Code model selection.
44    -mcmodel is used to select the v9 code model.
45    Different code models aren't supported for v8 code.
46
47    TARGET_CM_32:     32 bit address space, top 32 bits = 0,
48                      pointers are 32 bits.  Note that this isn't intended
49                      to imply a v8 abi.
50
51    TARGET_CM_MEDLOW: 32 bit address space, top 32 bits = 0,
52                      avoid generating %uhi and %ulo terms,
53                      pointers are 64 bits.
54
55    TARGET_CM_MEDMID: 64 bit address space.
56                      The executable must be in the low 16 TB of memory.
57                      This corresponds to the low 44 bits, and the %[hml]44
58                      relocs are used.
59
60    TARGET_CM_MEDANY: 64 bit address space.
61                      The text and data segments have a maximum size of 31
62                      bits and may be located anywhere.  The maximum offset
63                      from any instruction to the label _GLOBAL_OFFSET_TABLE_
64                      is 31 bits.
65
66    TARGET_CM_EMBMEDANY: 64 bit address space.
67                      The text and data segments have a maximum size of 31 bits
68                      and may be located anywhere.  Register %g4 contains
69                      the start address of the data segment.
70 */
71
72 enum cmodel {
73   CM_32,
74   CM_MEDLOW,
75   CM_MEDMID,
76   CM_MEDANY,
77   CM_EMBMEDANY
78 };
79
80 /* Value of -mcmodel specified by user.  */
81 extern char *sparc_cmodel_string;
82 /* One of CM_FOO.  */
83 extern enum cmodel sparc_cmodel;
84
85 /* V9 code model selection.  */
86 #define TARGET_CM_MEDLOW    (sparc_cmodel == CM_MEDLOW)
87 #define TARGET_CM_MEDMID    (sparc_cmodel == CM_MEDMID)
88 #define TARGET_CM_MEDANY    (sparc_cmodel == CM_MEDANY)
89 #define TARGET_CM_EMBMEDANY (sparc_cmodel == CM_EMBMEDANY)
90
91 #define SPARC_DEFAULT_CMODEL CM_MEDLOW
92
93 /* This is call-clobbered in the normal ABI, but is reserved in the
94    home grown (aka upward compatible) embedded ABI.  */
95 #define EMBMEDANY_BASE_REG "%g4"
96 \f
97 /* Values of TARGET_CPU_DEFAULT, set via -D in the Makefile,
98    and specified by the user via --with-cpu=foo.
99    This specifies the cpu implementation, not the architecture size.  */
100 #define TARGET_CPU_sparc        0
101 #define TARGET_CPU_v7           0       /* alias for previous */
102 #define TARGET_CPU_sparclet     1
103 #define TARGET_CPU_sparclite    2
104 #define TARGET_CPU_v8           3       /* generic v8 implementation */
105 #define TARGET_CPU_supersparc   4
106 #define TARGET_CPU_v9           5       /* generic v9 implementation */
107 #define TARGET_CPU_sparc64      5       /* alias */
108 #define TARGET_CPU_ultrasparc   6
109
110 #if TARGET_CPU_DEFAULT == TARGET_CPU_sparc || TARGET_CPU_DEFAULT == TARGET_CPU_v8 || TARGET_CPU_DEFAULT == TARGET_CPU_supersparc
111 #define CPP_CPU_DEFAULT_SPEC ""
112 #define ASM_CPU_DEFAULT_SPEC ""
113 #endif
114 #if TARGET_CPU_DEFAULT == TARGET_CPU_sparclet
115 #define CPP_CPU_DEFAULT_SPEC "-D__sparclet__"
116 #define ASM_CPU_DEFAULT_SPEC "-Asparclet"
117 #endif
118 #if TARGET_CPU_DEFAULT == TARGET_CPU_sparclite
119 #define CPP_CPU_DEFAULT_SPEC "-D__sparclite__"
120 #define ASM_CPU_DEFAULT_SPEC "-Asparclite"
121 #endif
122 #if TARGET_CPU_DEFAULT == TARGET_CPU_v9
123 /* ??? What does Sun's CC pass?  */
124 #define CPP_CPU_DEFAULT_SPEC "-D__sparc_v9__"
125 /* ??? It's not clear how other assemblers will handle this, so by default
126    use GAS.  Sun's Solaris assembler recognizes -xarch=v8plus, but this case
127    is handled in sol2.h.  */
128 #define ASM_CPU_DEFAULT_SPEC "-Av9"
129 #endif
130 #if TARGET_CPU_DEFAULT == TARGET_CPU_ultrasparc
131 #define CPP_CPU_DEFAULT_SPEC "-D__sparc_v9__"
132 #define ASM_CPU_DEFAULT_SPEC "-Av9a"
133 #endif
134 #ifndef CPP_CPU_DEFAULT_SPEC
135 Unrecognized value in TARGET_CPU_DEFAULT.
136 #endif
137
138 /* Names to predefine in the preprocessor for this target machine.
139    ??? It would be nice to not include any subtarget specific values here,
140    however there's no way to portably provide subtarget values to
141    CPP_PREFINES.  Also, -D values in CPP_SUBTARGET_SPEC don't get turned into
142    into foo, __foo and __foo__.  */
143
144 #define CPP_PREDEFINES "-Dsparc -Dsun -Dunix -Asystem(unix) -Asystem(bsd)"
145
146 /* Define macros to distinguish architectures.  */
147
148 /* Common CPP definitions used by CPP_SPEC amongst the various targets
149    for handling -mcpu=xxx switches.  */
150 #define CPP_CPU_SPEC "\
151 %{mcypress:} \
152 %{msparclite:-D__sparclite__} \
153 %{mf930:-D__sparclite__} %{mf934:-D__sparclite__} \
154 %{mv8:-D__sparc_v8__} \
155 %{msupersparc:-D__supersparc__ -D__sparc_v8__} \
156 %{mcpu=sparclet:-D__sparclet__} %{mcpu=tsc701:-D__sparclet__} \
157 %{mcpu=sparclite:-D__sparclite__} \
158 %{mcpu=f930:-D__sparclite__} %{mcpu=f934:-D__sparclite__} \
159 %{mcpu=v8:-D__sparc_v8__} \
160 %{mcpu=supersparc:-D__supersparc__ -D__sparc_v8__} \
161 %{mcpu=v8plus:-D__sparc_v9__} \
162 %{mcpu=v9:-D__sparc_v9__} \
163 %{mcpu=ultrasparc:-D__sparc_v9__} \
164 %{!mcpu*:%{!mcypress:%{!msparclite:%{!mf930:%{!mf934:%{!mv8:%{!msupersparc:%(cpp_cpu_default)}}}}}}} \
165 "
166
167 /* ??? The GCC_NEW_VARARGS macro is now obsolete, because gcc always uses
168    the right varags.h file when bootstrapping.  */
169 /* ??? It's not clear what value we want to use for -Acpu/machine for
170    sparc64 in 32 bit environments, so for now we only use `sparc64' in
171    64 bit environments.  */
172
173 #define CPP_ARCH32_SPEC "-D__GCC_NEW_VARARGS__ -Acpu(sparc) -Amachine(sparc)"
174 #define CPP_ARCH64_SPEC "-D__arch64__ -Acpu(sparc64) -Amachine(sparc64)"
175 #define CPP_ARCH_DEFAULT_SPEC \
176 (DEFAULT_ARCH32_P ? CPP_ARCH32_SPEC : CPP_ARCH64_SPEC)
177
178 #define CPP_ARCH_SPEC "\
179 %{m32:%(cpp_arch32)} \
180 %{m64:%(cpp_arch64)} \
181 %{!m32:%{!m64:%(cpp_arch_default)}} \
182 "
183
184 /* Macros to distinguish endianness.  */
185 #define CPP_ENDIAN_SPEC "%{mlittle-endian:-D__LITTLE_ENDIAN__}"
186
187 /* Macros to distinguish the particular subtarget.  */
188 #define CPP_SUBTARGET_SPEC ""
189
190 #define CPP_SPEC "%(cpp_cpu) %(cpp_arch) %(cpp_endian) %(cpp_subtarget)"
191
192 /* Prevent error on `-sun4' and `-target sun4' options.  */
193 /* This used to translate -dalign to -malign, but that is no good
194    because it can't turn off the usual meaning of making debugging dumps.  */
195 /* Translate old style -m<cpu> into new style -mcpu=<cpu>.
196    ??? Delete support for -m<cpu> for 2.9.  */
197
198 #define CC1_SPEC "\
199 %{sun4:} %{target:} \
200 %{mcypress:-mcpu=cypress} \
201 %{msparclite:-mcpu=sparclite} %{mf930:-mcpu=f930} %{mf934:-mcpu=f934} \
202 %{mv8:-mcpu=v8} %{msupersparc:-mcpu=supersparc} \
203 "
204
205 /* Override in target specific files.  */
206 #define ASM_CPU_SPEC "\
207 %{mcpu=sparclet:-Asparclet} %{mcpu=tsc701:-Asparclet} \
208 %{msparclite:-Asparclite} \
209 %{mf930:-Asparclite} %{mf934:-Asparclite} \
210 %{mcpu=sparclite:-Asparclite} \
211 %{mcpu=f930:-Asparclite} %{mcpu=f934:-Asparclite} \
212 %{mcpu=v8plus:-Av8plus} \
213 %{mcpu=v9:-Av9} \
214 %{mcpu=ultrasparc:-Av9a} \
215 %{!mcpu*:%{!mcypress:%{!msparclite:%{!mf930:%{!mf934:%{!mv8:%{!msupersparc:%(asm_cpu_default)}}}}}}} \
216 "
217
218 /* Word size selection, among other things.  */
219 #define ASM_ARCH32_SPEC "-32"
220 #define ASM_ARCH64_SPEC "-64"
221 #define ASM_ARCH_DEFAULT_SPEC \
222 (DEFAULT_ARCH32_P ?  ASM_ARCH32_SPEC : ASM_ARCH64_SPEC)
223
224 #define ASM_ARCH_SPEC "\
225 %{m32:%(asm_arch32)} \
226 %{m64:%(asm_arch64)} \
227 %{!m32:%{!m64:%(asm_arch_default)}} \
228 "
229
230 /* Special flags to the Sun-4 assembler when using pipe for input.  */
231
232 #define ASM_SPEC "\
233 %| %{R} %{!pg:%{!p:%{fpic:-k} %{fPIC:-k}}} %{keep-local-as-symbols:-L} \
234 %(asm_cpu) %(asm_arch) \
235 "
236
237 #define LIB_SPEC "%{!shared:%{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p} %{g:-lg}}"
238
239 /* Provide required defaults for linker -e and -d switches.  */
240
241 #define LINK_SPEC \
242  "%{!shared:%{!nostdlib:%{!r*:%{!e*:-e start}}} -dc -dp} %{static:-Bstatic} \
243   %{assert*} %{shared:%{!mimpure-text:-assert pure-text}}"
244
245 /* This macro defines names of additional specifications to put in the specs
246    that can be used in various specifications like CC1_SPEC.  Its definition
247    is an initializer with a subgrouping for each command option.
248
249    Each subgrouping contains a string constant, that defines the
250    specification name, and a string constant that used by the GNU CC driver
251    program.
252
253    Do not define this macro if it does not need to do anything.  */
254
255 #define EXTRA_SPECS \
256   { "cpp_cpu",          CPP_CPU_SPEC },                 \
257   { "cpp_cpu_default",  CPP_CPU_DEFAULT_SPEC },         \
258   { "cpp_arch32",       CPP_ARCH32_SPEC },              \
259   { "cpp_arch64",       CPP_ARCH64_SPEC },              \
260   { "cpp_arch_default", CPP_ARCH_DEFAULT_SPEC },        \
261   { "cpp_arch",         CPP_ARCH_SPEC },                \
262   { "cpp_endian",       CPP_ENDIAN_SPEC },              \
263   { "cpp_subtarget",    CPP_SUBTARGET_SPEC },           \
264   { "asm_cpu",          ASM_CPU_SPEC },                 \
265   { "asm_cpu_default",  ASM_CPU_DEFAULT_SPEC },         \
266   { "asm_arch32",       ASM_ARCH32_SPEC },              \
267   { "asm_arch64",       ASM_ARCH64_SPEC },              \
268   { "asm_arch_default", ASM_ARCH_DEFAULT_SPEC },        \
269   { "asm_arch",         ASM_ARCH_SPEC },                \
270   SUBTARGET_EXTRA_SPECS
271
272 #define SUBTARGET_EXTRA_SPECS
273 \f
274 #ifdef SPARC_BI_ARCH
275 #define NO_BUILTIN_PTRDIFF_TYPE
276 #define NO_BUILTIN_SIZE_TYPE
277 #endif
278 #define PTRDIFF_TYPE (TARGET_ARCH64 ? "long long int" : "int")
279 #define SIZE_TYPE (TARGET_ARCH64 ? "long long unsigned int" : "unsigned int")
280
281 /* ??? This should be 32 bits for v9 but what can we do?  */
282 #define WCHAR_TYPE "short unsigned int"
283 #define WCHAR_TYPE_SIZE 16
284 #define MAX_WCHAR_TYPE_SIZE 16
285
286 /* Show we can debug even without a frame pointer.  */
287 #define CAN_DEBUG_WITHOUT_FP
288
289 /* To make profiling work with -f{pic,PIC}, we need to emit the profiling
290    code into the rtl.  Also, if we are profiling, we cannot eliminate
291    the frame pointer (because the return address will get smashed).  */
292
293 void sparc_override_options ();
294
295 #define OVERRIDE_OPTIONS \
296   do {                                                                  \
297     if (profile_flag || profile_block_flag || profile_arc_flag)         \
298       {                                                                 \
299         if (flag_pic)                                                   \
300           {                                                             \
301             char *pic_string = (flag_pic == 1) ? "-fpic" : "-fPIC";     \
302             warning ("%s and profiling conflict: disabling %s",         \
303                      pic_string, pic_string);                           \
304             flag_pic = 0;                                               \
305           }                                                             \
306         flag_omit_frame_pointer = 0;                                    \
307       }                                                                 \
308     sparc_override_options ();                                          \
309     SUBTARGET_OVERRIDE_OPTIONS;                                         \
310   } while (0)
311
312 /* This is meant to be redefined in the host dependent files.  */
313 #define SUBTARGET_OVERRIDE_OPTIONS
314
315 /* These compiler options take an argument.  We ignore -target for now.  */
316
317 #define WORD_SWITCH_TAKES_ARG(STR)                              \
318  (DEFAULT_WORD_SWITCH_TAKES_ARG (STR)                           \
319   || !strcmp (STR, "target") || !strcmp (STR, "assert"))
320
321 /* Print subsidiary information on the compiler version in use.  */
322
323 #define TARGET_VERSION fprintf (stderr, " (sparc)");
324
325 /* Generate DBX debugging information.  */
326
327 #define DBX_DEBUGGING_INFO
328 \f
329 /* Run-time compilation parameters selecting different hardware subsets.  */
330
331 extern int target_flags;
332
333 /* Nonzero if we should generate code to use the fpu.  */
334 #define MASK_FPU 1
335 #define TARGET_FPU (target_flags & MASK_FPU)
336
337 /* Nonzero if we should use FUNCTION_EPILOGUE.  Otherwise, we
338    use fast return insns, but lose some generality.  */
339 #define MASK_EPILOGUE 2
340 #define TARGET_EPILOGUE (target_flags & MASK_EPILOGUE)
341
342 /* Nonzero if we should assume that double pointers might be unaligned.
343    This can happen when linking gcc compiled code with other compilers,
344    because the ABI only guarantees 4 byte alignment.  */
345 #define MASK_UNALIGNED_DOUBLES 4
346 #define TARGET_UNALIGNED_DOUBLES (target_flags & MASK_UNALIGNED_DOUBLES)
347
348 /* Nonzero means that we should generate code for a v8 sparc.  */
349 #define MASK_V8 0x8
350 #define TARGET_V8 (target_flags & MASK_V8)
351
352 /* Nonzero means that we should generate code for a sparclite.
353    This enables the sparclite specific instructions, but does not affect
354    whether FPU instructions are emitted.  */
355 #define MASK_SPARCLITE 0x10
356 #define TARGET_SPARCLITE (target_flags & MASK_SPARCLITE)
357
358 /* Nonzero if we're compiling for the sparclet.  */
359 #define MASK_SPARCLET 0x20
360 #define TARGET_SPARCLET (target_flags & MASK_SPARCLET)
361
362 /* Nonzero if we're compiling for v9 sparc.
363    Note that v9's can run in 32 bit mode so this doesn't necessarily mean
364    the word size is 64.  */
365 #define MASK_V9 0x40
366 #define TARGET_V9 (target_flags & MASK_V9)
367
368 /* Non-zero to generate code that uses the instructions deprecated in
369    the v9 architecture.  This option only applies to v9 systems.  */
370 /* ??? This isn't user selectable yet.  It's used to enable such insns
371    on 32 bit v9 systems and for the moment they're permanently disabled
372    on 64 bit v9 systems.  */
373 #define MASK_DEPRECATED_V8_INSNS 0x80
374 #define TARGET_DEPRECATED_V8_INSNS (target_flags & MASK_DEPRECATED_V8_INSNS)
375
376 /* Mask of all CPU selection flags.  */
377 #define MASK_ISA \
378 (MASK_V8 + MASK_SPARCLITE + MASK_SPARCLET + MASK_V9 + MASK_DEPRECATED_V8_INSNS)
379
380 /* Non-zero means don't pass `-assert pure-text' to the linker.  */
381 #define MASK_IMPURE_TEXT 0x100
382 #define TARGET_IMPURE_TEXT (target_flags & MASK_IMPURE_TEXT)
383
384 /* Nonzero means that we should generate code using a flat register window
385    model, i.e. no save/restore instructions are generated, which is
386    compatible with normal sparc code.
387    The frame pointer is %i7 instead of %fp.  */
388 #define MASK_FLAT 0x200
389 #define TARGET_FLAT (target_flags & MASK_FLAT)
390
391 /* Nonzero means use the registers that the Sparc ABI reserves for
392    application software.  This must be the default to coincide with the
393    setting in FIXED_REGISTERS.  */
394 #define MASK_APP_REGS 0x400
395 #define TARGET_APP_REGS (target_flags & MASK_APP_REGS)
396
397 /* Option to select how quad word floating point is implemented.
398    When TARGET_HARD_QUAD is true, we use the hardware quad instructions.
399    Otherwise, we use the SPARC ABI quad library functions.  */
400 #define MASK_HARD_QUAD 0x800
401 #define TARGET_HARD_QUAD (target_flags & MASK_HARD_QUAD)
402
403 /* Non-zero on little-endian machines.  */
404 /* ??? Little endian support currently only exists for sparclet-aout and
405    sparc64-elf configurations.  May eventually want to expand the support
406    to all targets, but for now it's kept local to only those two.  */
407 #define MASK_LITTLE_ENDIAN 0x1000
408 #define TARGET_LITTLE_ENDIAN (target_flags & MASK_LITTLE_ENDIAN)
409
410 /* 0x2000, 0x4000 are unused */
411
412 /* Nonzero if pointers are 64 bits.
413    This is not a user selectable option, though it may be one day -
414    so it is used to determine pointer size instead of an architecture flag.  */
415 #define MASK_PTR64 0x8000
416 #define TARGET_PTR64 (target_flags & MASK_PTR64)
417
418 /* Nonzero if generating code to run in a 64 bit environment.
419    This is intended to only be used by TARGET_ARCH{32,64} as they are the
420    mechanism used to control compile time or run time selection.  */
421 #define MASK_64BIT 0x10000
422 #define TARGET_64BIT (target_flags & MASK_64BIT)
423
424 /* 0x20000,0x40000 unused */
425
426 /* Non-zero means use a stack bias of 2047.  Stack offsets are obtained by
427    adding 2047 to %sp.  This option is for v9 only and is the default.  */
428 #define MASK_STACK_BIAS 0x80000
429 #define TARGET_STACK_BIAS (target_flags & MASK_STACK_BIAS)
430
431 /* Non-zero means %g0 is a normal register.
432    We still clobber it as necessary, but we can't rely on it always having
433    a zero value.
434    We don't bother to support this in true 64 bit mode.  */
435 #define MASK_LIVE_G0 0x100000
436 #define TARGET_LIVE_G0 (target_flags & MASK_LIVE_G0)
437
438 /* Non-zero means the cpu has broken `save' and `restore' insns, only
439    the trivial versions work (save %g0,%g0,%g0; restore %g0,%g0,%g0).
440    We assume the environment will properly handle or otherwise avoid
441    trouble associated with an interrupt occuring after the `save' or trap
442    occuring during it.  */
443 #define MASK_BROKEN_SAVERESTORE 0x200000
444 #define TARGET_BROKEN_SAVERESTORE (target_flags & MASK_BROKEN_SAVERESTORE)
445
446 /* Non-zero means -m{,no-}fpu was passed on the command line.  */
447 #define MASK_FPU_SET 0x400000
448 #define TARGET_FPU_SET (target_flags & MASK_FPU_SET)
449
450 /* Macro to define tables used to set the flags.
451    This is a list in braces of pairs in braces,
452    each pair being { "NAME", VALUE }
453    where VALUE is the bits to set or minus the bits to clear.
454    An empty string NAME is used to identify the default VALUE.  */
455
456 #define TARGET_SWITCHES  \
457   { {"fpu", MASK_FPU | MASK_FPU_SET},   \
458     {"no-fpu", -MASK_FPU},              \
459     {"no-fpu", MASK_FPU_SET},           \
460     {"hard-float", MASK_FPU | MASK_FPU_SET}, \
461     {"soft-float", -MASK_FPU},          \
462     {"soft-float", MASK_FPU_SET},       \
463     {"epilogue", MASK_EPILOGUE},        \
464     {"no-epilogue", -MASK_EPILOGUE},    \
465     {"unaligned-doubles", MASK_UNALIGNED_DOUBLES}, \
466     {"no-unaligned-doubles", -MASK_UNALIGNED_DOUBLES}, \
467     {"impure-text", MASK_IMPURE_TEXT},  \
468     {"no-impure-text", -MASK_IMPURE_TEXT}, \
469     {"flat", MASK_FLAT},                \
470     {"no-flat", -MASK_FLAT},            \
471     {"app-regs", MASK_APP_REGS},        \
472     {"no-app-regs", -MASK_APP_REGS},    \
473     {"hard-quad-float", MASK_HARD_QUAD}, \
474     {"soft-quad-float", -MASK_HARD_QUAD}, \
475     /* ??? These are deprecated, coerced to -mcpu=.  Delete in 2.9.  */ \
476     {"cypress", 0},                     \
477     {"sparclite", 0},                   \
478     {"f930", 0},                        \
479     {"f934", 0},                        \
480     {"v8", 0},                          \
481     {"supersparc", 0},                  \
482     /* End of deprecated options.  */   \
483     /* -mptrNN exists for *experimental* purposes.  */ \
484 /*  {"ptr64", MASK_PTR64}, */           \
485 /*  {"ptr32", -MASK_PTR64}, */          \
486     {"32", -MASK_64BIT},                \
487     {"64", MASK_64BIT},                 \
488     {"stack-bias", MASK_STACK_BIAS},    \
489     {"no-stack-bias", -MASK_STACK_BIAS}, \
490     SUBTARGET_SWITCHES                  \
491     { "", TARGET_DEFAULT}}
492
493 /* MASK_APP_REGS must always be the default because that's what
494    FIXED_REGISTERS is set to and -ffixed- is processed before
495    CONDITIONAL_REGISTER_USAGE is called (where we process -mno-app-regs).  */
496 #define TARGET_DEFAULT (MASK_APP_REGS + MASK_EPILOGUE + MASK_FPU)
497
498 /* This is meant to be redefined in target specific files.  */
499 #define SUBTARGET_SWITCHES
500
501 /* Processor type.
502    These must match the values for the cpu attribute in sparc.md.  */
503 enum processor_type {
504   PROCESSOR_V7,
505   PROCESSOR_CYPRESS,
506   PROCESSOR_V8,
507   PROCESSOR_SUPERSPARC,
508   PROCESSOR_SPARCLITE,
509   PROCESSOR_F930,
510   PROCESSOR_F934,
511   PROCESSOR_SPARCLET,
512   PROCESSOR_TSC701,
513   PROCESSOR_V8PLUS,
514   PROCESSOR_V9,
515   PROCESSOR_ULTRASPARC
516 };
517
518 /* This is set from -m{cpu,tune}=xxx.  */
519 extern enum processor_type sparc_cpu;
520
521 /* Recast the cpu class to be the cpu attribute.
522    Every file includes us, but not every file includes insn-attr.h.  */
523 #define sparc_cpu_attr ((enum attr_cpu) sparc_cpu)
524
525 /* This macro is similar to `TARGET_SWITCHES' but defines names of
526    command options that have values.  Its definition is an
527    initializer with a subgrouping for each command option.
528
529    Each subgrouping contains a string constant, that defines the
530    fixed part of the option name, and the address of a variable. 
531    The variable, type `char *', is set to the variable part of the
532    given option if the fixed part matches.  The actual option name
533    is made by appending `-m' to the specified name.
534
535    Here is an example which defines `-mshort-data-NUMBER'.  If the
536    given option is `-mshort-data-512', the variable `m88k_short_data'
537    will be set to the string `"512"'.
538
539         extern char *m88k_short_data;
540         #define TARGET_OPTIONS { { "short-data-", &m88k_short_data } }  */
541
542 #define TARGET_OPTIONS \
543 {                                                       \
544   { "cpu=",  &sparc_select[1].string },                 \
545   { "tune=", &sparc_select[2].string },                 \
546   { "cmodel=", &sparc_cmodel_string },                  \
547   { "align-loops=",     &sparc_align_loops_string },    \
548   { "align-jumps=",     &sparc_align_jumps_string },    \
549   { "align-functions=", &sparc_align_funcs_string },    \
550   SUBTARGET_OPTIONS                                     \
551 }
552
553 /* This is meant to be redefined in target specific files.  */
554 #define SUBTARGET_OPTIONS
555
556 /* sparc_select[0] is reserved for the default cpu.  */
557 struct sparc_cpu_select
558 {
559   char *string;
560   char *name;
561   int set_tune_p;
562   int set_arch_p;
563 };
564
565 extern struct sparc_cpu_select sparc_select[];
566
567 /* Variables to record values the user passes.  */
568 extern char *sparc_align_loops_string;
569 extern char *sparc_align_jumps_string;
570 extern char *sparc_align_funcs_string;
571 /* Parsed values as a power of two.  */
572 extern int sparc_align_loops;
573 extern int sparc_align_jumps;
574 extern int sparc_align_funcs;
575
576 #define DEFAULT_SPARC_ALIGN_FUNCS \
577 (sparc_cpu == PROCESSOR_ULTRASPARC ? 5 : 2)
578 \f
579 /* target machine storage layout */
580
581 /* Define for cross-compilation to a sparc target with no TFmode from a host
582    with a different float format (e.g. VAX).  */
583 #define REAL_ARITHMETIC
584
585 /* Define this if most significant bit is lowest numbered
586    in instructions that operate on numbered bit-fields.  */
587 #define BITS_BIG_ENDIAN 1
588
589 /* Define this if most significant byte of a word is the lowest numbered.  */
590 #define BYTES_BIG_ENDIAN 1
591
592 /* Define this if most significant word of a multiword number is the lowest
593    numbered.  */
594 #define WORDS_BIG_ENDIAN 1
595
596 /* Define this to set the endianness to use in libgcc2.c, which can
597    not depend on target_flags.  */
598 #if defined (__LITTLE_ENDIAN__)
599 #define LIBGCC2_WORDS_BIG_ENDIAN 0
600 #else
601 #define LIBGCC2_WORDS_BIG_ENDIAN 1
602 #endif
603
604 /* number of bits in an addressable storage unit */
605 #define BITS_PER_UNIT 8
606
607 /* Width in bits of a "word", which is the contents of a machine register.
608    Note that this is not necessarily the width of data type `int';
609    if using 16-bit ints on a 68000, this would still be 32.
610    But on a machine with 16-bit registers, this would be 16.  */
611 #define BITS_PER_WORD           (TARGET_ARCH64 ? 64 : 32)
612 #define MAX_BITS_PER_WORD       64
613
614 /* Width of a word, in units (bytes).  */
615 #define UNITS_PER_WORD          (TARGET_ARCH64 ? 8 : 4)
616 #define MIN_UNITS_PER_WORD      4
617
618 /* Now define the sizes of the C data types.  */
619
620 #define SHORT_TYPE_SIZE         16
621 #define INT_TYPE_SIZE           32
622 #define LONG_TYPE_SIZE          (TARGET_ARCH64 ? 64 : 32)
623 #define LONG_LONG_TYPE_SIZE     64
624 #define FLOAT_TYPE_SIZE         32
625 #define DOUBLE_TYPE_SIZE        64
626
627 #if defined (SPARC_BI_ARCH)
628 #define MAX_LONG_TYPE_SIZE      64
629 #endif
630
631 #if 0
632 /* ??? This does not work in SunOS 4.x, so it is not enabled here.
633    Instead, it is enabled in sol2.h, because it does work under Solaris.  */
634 /* Define for support of TFmode long double and REAL_ARITHMETIC.
635    Sparc ABI says that long double is 4 words.  */
636 #define LONG_DOUBLE_TYPE_SIZE 128
637 #endif
638
639 /* Width in bits of a pointer.
640    See also the macro `Pmode' defined below.  */
641 #define POINTER_SIZE (TARGET_PTR64 ? 64 : 32)
642
643 /* A macro to update MODE and UNSIGNEDP when an object whose type
644    is TYPE and which has the specified mode and signedness is to be
645    stored in a register.  This macro is only called when TYPE is a
646    scalar type.  */
647 #define PROMOTE_MODE(MODE, UNSIGNEDP, TYPE) \
648 if (TARGET_ARCH64                               \
649     && GET_MODE_CLASS (MODE) == MODE_INT        \
650     && GET_MODE_SIZE (MODE) < UNITS_PER_WORD)   \
651 {                                               \
652   (MODE) = DImode;                              \
653 }
654
655 /* Define this macro if the promotion described by PROMOTE_MODE
656    should also be done for outgoing function arguments.  */
657 /* This is only needed for TARGET_ARCH64, but since PROMOTE_MODE is a no-op
658    for TARGET_ARCH32 this is ok.  Otherwise we'd need to add a runtime test
659    for this value.  */
660 #define PROMOTE_FUNCTION_ARGS
661
662 /* Define this macro if the promotion described by PROMOTE_MODE
663    should also be done for the return value of functions.
664    If this macro is defined, FUNCTION_VALUE must perform the same
665    promotions done by PROMOTE_MODE.  */
666 /* This is only needed for TARGET_ARCH64, but since PROMOTE_MODE is a no-op
667    for TARGET_ARCH32 this is ok.  Otherwise we'd need to add a runtime test
668    for this value.  */
669 #define PROMOTE_FUNCTION_RETURN
670
671 /* Allocation boundary (in *bits*) for storing arguments in argument list.  */
672 #define PARM_BOUNDARY (TARGET_ARCH64 ? 64 : 32)
673
674 /* Boundary (in *bits*) on which stack pointer should be aligned.  */
675 #define STACK_BOUNDARY (TARGET_ARCH64 ? 128 : 64)
676
677 /* ALIGN FRAMES on double word boundaries */
678
679 #define SPARC_STACK_ALIGN(LOC) \
680   (TARGET_ARCH64 ? (((LOC)+15) & ~15) : (((LOC)+7) & ~7))
681
682 /* Allocation boundary (in *bits*) for the code of a function.  */
683 #define FUNCTION_BOUNDARY (1 << (sparc_align_funcs + 3))
684
685 /* Alignment of field after `int : 0' in a structure.  */
686 #define EMPTY_FIELD_BOUNDARY (TARGET_ARCH64 ? 64 : 32)
687
688 /* Every structure's size must be a multiple of this.  */
689 #define STRUCTURE_SIZE_BOUNDARY 8
690
691 /* A bitfield declared as `int' forces `int' alignment for the struct.  */
692 #define PCC_BITFIELD_TYPE_MATTERS 1
693
694 /* No data type wants to be aligned rounder than this.  */
695 #define BIGGEST_ALIGNMENT (TARGET_ARCH64 ? 128 : 64)
696
697 /* The best alignment to use in cases where we have a choice.  */
698 #define FASTEST_ALIGNMENT 64
699
700 /* Make strings word-aligned so strcpy from constants will be faster.  */
701 #define CONSTANT_ALIGNMENT(EXP, ALIGN)  \
702   ((TREE_CODE (EXP) == STRING_CST       \
703     && (ALIGN) < FASTEST_ALIGNMENT)     \
704    ? FASTEST_ALIGNMENT : (ALIGN))
705
706 /* Make arrays of chars word-aligned for the same reasons.  */
707 #define DATA_ALIGNMENT(TYPE, ALIGN)             \
708   (TREE_CODE (TYPE) == ARRAY_TYPE               \
709    && TYPE_MODE (TREE_TYPE (TYPE)) == QImode    \
710    && (ALIGN) < FASTEST_ALIGNMENT ? FASTEST_ALIGNMENT : (ALIGN))
711
712 /* Set this nonzero if move instructions will actually fail to work
713    when given unaligned data.  */
714 #define STRICT_ALIGNMENT 1
715
716 /* Things that must be doubleword aligned cannot go in the text section,
717    because the linker fails to align the text section enough!
718    Put them in the data section.  This macro is only used in this file.  */
719 #define MAX_TEXT_ALIGN 32
720
721 /* This forces all variables and constants to the data section when PIC.
722    This is because the SunOS 4 shared library scheme thinks everything in
723    text is a function, and patches the address to point to a loader stub.  */
724 /* This is defined to zero for every system which doesn't use the a.out object
725    file format.  */
726 #ifndef SUNOS4_SHARED_LIBRARIES
727 #define SUNOS4_SHARED_LIBRARIES 0
728 #endif
729
730 /* This is defined differently for v9 in a cover file.  */
731 #define SELECT_SECTION(T,RELOC)                                         \
732 {                                                                       \
733   if (TREE_CODE (T) == VAR_DECL)                                        \
734     {                                                                   \
735       if (TREE_READONLY (T) && ! TREE_SIDE_EFFECTS (T)                  \
736           && DECL_INITIAL (T)                                           \
737           && (DECL_INITIAL (T) == error_mark_node                       \
738               || TREE_CONSTANT (DECL_INITIAL (T)))                      \
739           && DECL_ALIGN (T) <= MAX_TEXT_ALIGN                           \
740           && ! (flag_pic && ((RELOC) || SUNOS4_SHARED_LIBRARIES)))      \
741         text_section ();                                                \
742       else                                                              \
743         data_section ();                                                \
744     }                                                                   \
745   else if (TREE_CODE (T) == CONSTRUCTOR)                                \
746     {                                                                   \
747       if (flag_pic && ((RELOC) || SUNOS4_SHARED_LIBRARIES))             \
748         data_section ();                                                \
749     }                                                                   \
750   else if (TREE_CODE_CLASS (TREE_CODE (T)) == 'c')                      \
751     {                                                                   \
752       if ((TREE_CODE (T) == STRING_CST && flag_writable_strings)        \
753           || TYPE_ALIGN (TREE_TYPE (T)) > MAX_TEXT_ALIGN                \
754           || (flag_pic && ((RELOC) || SUNOS4_SHARED_LIBRARIES)))        \
755         data_section ();                                                \
756       else                                                              \
757         text_section ();                                                \
758     }                                                                   \
759 }
760
761 /* Use text section for a constant
762    unless we need more alignment than that offers.  */
763 /* This is defined differently for v9 in a cover file.  */
764 #define SELECT_RTX_SECTION(MODE, X)             \
765 {                                               \
766   if (GET_MODE_BITSIZE (MODE) <= MAX_TEXT_ALIGN \
767       && ! (flag_pic && (symbolic_operand (X) || SUNOS4_SHARED_LIBRARIES)))  \
768     text_section ();                            \
769   else                                          \
770     data_section ();                            \
771 }
772 \f
773 /* Standard register usage.  */
774
775 /* Number of actual hardware registers.
776    The hardware registers are assigned numbers for the compiler
777    from 0 to just below FIRST_PSEUDO_REGISTER.
778    All registers that the compiler knows about must be given numbers,
779    even those that are not normally considered general registers.
780
781    SPARC has 32 integer registers and 32 floating point registers.
782    64 bit SPARC has 32 additional fp regs, but the odd numbered ones are not
783    accessible.  We still account for them to simplify register computations
784    (eg: in CLASS_MAX_NREGS).  There are also 4 fp condition code registers, so
785    32+32+32+4 == 100.
786    Register 100 is used as the integer condition code register.  */
787
788 #define FIRST_PSEUDO_REGISTER 101
789
790 #define SPARC_FIRST_FP_REG     32
791 /* Additional V9 fp regs.  */
792 #define SPARC_FIRST_V9_FP_REG  64
793 #define SPARC_LAST_V9_FP_REG   95
794 /* V9 %fcc[0123].  V8 uses (figuratively) %fcc0.  */
795 #define SPARC_FIRST_V9_FCC_REG 96
796 #define SPARC_LAST_V9_FCC_REG  99
797 /* V8 fcc reg.  */
798 #define SPARC_FCC_REG 96
799 /* Integer CC reg.  We don't distinguish %icc from %xcc.  */
800 #define SPARC_ICC_REG 100
801
802 /* Nonzero if REGNO is an fp reg.  */
803 #define SPARC_FP_REG_P(REGNO) \
804 ((REGNO) >= SPARC_FIRST_FP_REG && (REGNO) <= SPARC_LAST_V9_FP_REG)
805
806 /* Argument passing regs.  */
807 #define SPARC_OUTGOING_INT_ARG_FIRST 8
808 #define SPARC_INCOMING_INT_ARG_FIRST 24
809 #define SPARC_FP_ARG_FIRST           32
810
811 /* 1 for registers that have pervasive standard uses
812    and are not available for the register allocator.
813
814    On non-v9 systems:
815    g1 is free to use as temporary.
816    g2-g4 are reserved for applications.  Gcc normally uses them as
817    temporaries, but this can be disabled via the -mno-app-regs option.
818    g5 through g7 are reserved for the operating system.
819
820    On v9 systems:
821    g1,g5 are free to use as temporaries, and are free to use between calls
822    if the call is to an external function via the PLT.
823    g4 is free to use as a temporary in the non-embedded case.
824    g4 is reserved in the embedded case.
825    g2-g3 are reserved for applications.  Gcc normally uses them as
826    temporaries, but this can be disabled via the -mno-app-regs option.
827    g6-g7 are reserved for the operating system (or application in
828    embedded case).
829    ??? Register 1 is used as a temporary by the 64 bit sethi pattern, so must
830    currently be a fixed register until this pattern is rewritten.
831    Register 1 is also used when restoring call-preserved registers in large
832    stack frames.
833
834    Registers fixed in arch32 and not arch64 (or vice-versa) are marked in
835    CONDITIONAL_REGISTER_USAGE in order to properly handle -ffixed-.
836 */
837
838 #define FIXED_REGISTERS  \
839  {1, 0, 0, 0, 0, 0, 1, 1,       \
840   0, 0, 0, 0, 0, 0, 1, 0,       \
841   0, 0, 0, 0, 0, 0, 0, 0,       \
842   0, 0, 0, 0, 0, 0, 1, 1,       \
843                                 \
844   0, 0, 0, 0, 0, 0, 0, 0,       \
845   0, 0, 0, 0, 0, 0, 0, 0,       \
846   0, 0, 0, 0, 0, 0, 0, 0,       \
847   0, 0, 0, 0, 0, 0, 0, 0,       \
848                                 \
849   0, 0, 0, 0, 0, 0, 0, 0,       \
850   0, 0, 0, 0, 0, 0, 0, 0,       \
851   0, 0, 0, 0, 0, 0, 0, 0,       \
852   0, 0, 0, 0, 0, 0, 0, 0,       \
853                                 \
854   0, 0, 0, 0, 0}
855
856 /* 1 for registers not available across function calls.
857    These must include the FIXED_REGISTERS and also any
858    registers that can be used without being saved.
859    The latter must include the registers where values are returned
860    and the register where structure-value addresses are passed.
861    Aside from that, you can include as many other registers as you like.  */
862
863 #define CALL_USED_REGISTERS  \
864  {1, 1, 1, 1, 1, 1, 1, 1,       \
865   1, 1, 1, 1, 1, 1, 1, 1,       \
866   0, 0, 0, 0, 0, 0, 0, 0,       \
867   0, 0, 0, 0, 0, 0, 1, 1,       \
868                                 \
869   1, 1, 1, 1, 1, 1, 1, 1,       \
870   1, 1, 1, 1, 1, 1, 1, 1,       \
871   1, 1, 1, 1, 1, 1, 1, 1,       \
872   1, 1, 1, 1, 1, 1, 1, 1,       \
873                                 \
874   1, 1, 1, 1, 1, 1, 1, 1,       \
875   1, 1, 1, 1, 1, 1, 1, 1,       \
876   1, 1, 1, 1, 1, 1, 1, 1,       \
877   1, 1, 1, 1, 1, 1, 1, 1,       \
878                                 \
879   1, 1, 1, 1, 1}
880
881 /* If !TARGET_FPU, then make the fp registers and fp cc regs fixed so that
882    they won't be allocated.  */
883
884 #define CONDITIONAL_REGISTER_USAGE                              \
885 do                                                              \
886   {                                                             \
887     if (TARGET_ARCH32)                                          \
888       {                                                         \
889         fixed_regs[5] = 1;                                      \
890       }                                                         \
891     else                                                        \
892       {                                                         \
893         fixed_regs[1] = 1;                                      \
894       }                                                         \
895     if (! TARGET_V9)                                            \
896       {                                                         \
897         int regno;                                              \
898         for (regno = SPARC_FIRST_V9_FP_REG;                     \
899              regno <= SPARC_LAST_V9_FP_REG;                     \
900              regno++)                                           \
901           fixed_regs[regno] = 1;                                \
902         /* %fcc0 is used by v8 and v9.  */                      \
903         for (regno = SPARC_FIRST_V9_FCC_REG + 1;                \
904              regno <= SPARC_LAST_V9_FCC_REG;                    \
905              regno++)                                           \
906           fixed_regs[regno] = 1;                                \
907       }                                                         \
908     if (! TARGET_FPU)                                           \
909       {                                                         \
910         int regno;                                              \
911         for (regno = 32; regno < SPARC_LAST_V9_FCC_REG; regno++) \
912           fixed_regs[regno] = 1;                                \
913       }                                                         \
914     /* Don't unfix g2-g4 if they were fixed with -ffixed-.  */  \
915     fixed_regs[2] |= ! TARGET_APP_REGS;                         \
916     fixed_regs[3] |= ! TARGET_APP_REGS;                         \
917     fixed_regs[4] |= ! TARGET_APP_REGS || TARGET_CM_EMBMEDANY;  \
918     if (TARGET_FLAT)                                            \
919       {                                                         \
920         /* Let the compiler believe the frame pointer is still  \
921            %fp, but output it as %i7.  */                       \
922         fixed_regs[31] = 1;                                     \
923         reg_names[FRAME_POINTER_REGNUM] = "%i7";                \
924         /* ??? This is a hack to disable leaf functions.  */    \
925         global_regs[7] = 1;                                     \
926       }                                                         \
927     if (profile_block_flag)                                     \
928       {                                                         \
929         /* %g1 and %g2 must be fixed, because BLOCK_PROFILER    \
930             uses them.  */                                      \
931         fixed_regs[1] = 1;                                      \
932         fixed_regs[2] = 1;                                      \
933       }                                                         \
934   }                                                             \
935 while (0)
936
937 /* Return number of consecutive hard regs needed starting at reg REGNO
938    to hold something of mode MODE.
939    This is ordinarily the length in words of a value of mode MODE
940    but can be less for certain modes in special long registers.
941
942    On SPARC, ordinary registers hold 32 bits worth;
943    this means both integer and floating point registers.
944    On v9, integer regs hold 64 bits worth; floating point regs hold
945    32 bits worth (this includes the new fp regs as even the odd ones are
946    included in the hard register count).  */
947
948 #define HARD_REGNO_NREGS(REGNO, MODE) \
949   (TARGET_ARCH64                                                        \
950    ?  ((REGNO) < 32                                                     \
951        ? (GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD   \
952        : (GET_MODE_SIZE (MODE) + 3) / 4)                                \
953    : ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD))
954
955 /* Value is 1 if hard register REGNO can hold a value of machine-mode MODE.
956    See sparc.c for how we initialize this.  */
957 extern int *hard_regno_mode_classes;
958 extern int sparc_mode_class[];
959 #define HARD_REGNO_MODE_OK(REGNO, MODE) \
960   ((hard_regno_mode_classes[REGNO] & sparc_mode_class[MODE]) != 0)
961
962 /* Value is 1 if it is a good idea to tie two pseudo registers
963    when one has mode MODE1 and one has mode MODE2.
964    If HARD_REGNO_MODE_OK could produce different values for MODE1 and MODE2,
965    for any hard reg, then this must be 0 for correct output.
966
967    For V9: SFmode can't be combined with other float modes, because they can't
968    be allocated to the %d registers.  Also, DFmode won't fit in odd %f
969    registers, but SFmode will.  */
970 #define MODES_TIEABLE_P(MODE1, MODE2) \
971   ((MODE1) == (MODE2)                                           \
972    || (GET_MODE_CLASS (MODE1) == GET_MODE_CLASS (MODE2)         \
973        && (! TARGET_V9                                          \
974            || (GET_MODE_CLASS (MODE1) != MODE_FLOAT             \
975                || (MODE1 != SFmode && MODE2 != SFmode)))))
976
977 /* Specify the registers used for certain standard purposes.
978    The values of these macros are register numbers.  */
979
980 /* SPARC pc isn't overloaded on a register that the compiler knows about.  */
981 /* #define PC_REGNUM  */
982
983 /* Register to use for pushing function arguments.  */
984 #define STACK_POINTER_REGNUM 14
985
986 /* Actual top-of-stack address is 92/176 greater than the contents of the
987    stack pointer register for !v9/v9.  That is:
988    - !v9: 64 bytes for the in and local registers, 4 bytes for structure return
989      address, and 6*4 bytes for the 6 register parameters.
990    - v9: 128 bytes for the in and local registers + 6*8 bytes for the integer
991      parameter regs.  */
992 #define STACK_POINTER_OFFSET FIRST_PARM_OFFSET(0)
993
994 /* The stack bias (amount by which the hardware register is offset by).  */
995 #define SPARC_STACK_BIAS ((TARGET_ARCH64 && TARGET_STACK_BIAS) ? 2047 : 0)
996
997 /* Is stack biased? */
998 #define STACK_BIAS SPARC_STACK_BIAS
999
1000 /* Base register for access to local variables of the function.  */
1001 #define FRAME_POINTER_REGNUM 30
1002
1003 #if 0
1004 /* Register that is used for the return address for the flat model.  */
1005 #define RETURN_ADDR_REGNUM 15
1006 #endif
1007
1008 /* Value should be nonzero if functions must have frame pointers.
1009    Zero means the frame pointer need not be set up (and parms
1010    may be accessed via the stack pointer) in functions that seem suitable.
1011    This is computed in `reload', in reload1.c.
1012    Used in flow.c, global.c, and reload1.c.
1013
1014    Being a non-leaf function does not mean a frame pointer is needed in the
1015    flat window model.  However, the debugger won't be able to backtrace through
1016    us with out it.  */
1017 #define FRAME_POINTER_REQUIRED \
1018   (TARGET_FLAT ? (current_function_calls_alloca || current_function_varargs \
1019                   || !leaf_function_p ()) \
1020    : ! (leaf_function_p () && only_leaf_regs_used ()))
1021
1022 /* C statement to store the difference between the frame pointer
1023    and the stack pointer values immediately after the function prologue.
1024
1025    Note, we always pretend that this is a leaf function because if
1026    it's not, there's no point in trying to eliminate the
1027    frame pointer.  If it is a leaf function, we guessed right!  */
1028 #define INITIAL_FRAME_POINTER_OFFSET(VAR) \
1029   ((VAR) = (TARGET_FLAT ? sparc_flat_compute_frame_size (get_frame_size ()) \
1030             : compute_frame_size (get_frame_size (), 1)))
1031
1032 /* Base register for access to arguments of the function.  */
1033 #define ARG_POINTER_REGNUM FRAME_POINTER_REGNUM
1034
1035 /* Register in which static-chain is passed to a function.  This must
1036    not be a register used by the prologue.  */
1037 #define STATIC_CHAIN_REGNUM (TARGET_ARCH64 ? 5 : 2)
1038
1039 /* Register which holds offset table for position-independent
1040    data references.  */
1041
1042 #define PIC_OFFSET_TABLE_REGNUM 23
1043
1044 #define INITIALIZE_PIC initialize_pic ()
1045 #define FINALIZE_PIC finalize_pic ()
1046
1047 /* Sparc ABI says that quad-precision floats and all structures are returned
1048    in memory.
1049    For v9: unions <= 32 bytes in size are returned in int regs,
1050    structures up to 32 bytes are returned in int and fp regs.
1051    FIXME: wip */
1052
1053 #define RETURN_IN_MEMORY(TYPE)                          \
1054 (TARGET_ARCH32                                          \
1055  ? (TYPE_MODE (TYPE) == BLKmode                         \
1056     || TYPE_MODE (TYPE) == TFmode                       \
1057     || TYPE_MODE (TYPE) == TCmode)                      \
1058  : TYPE_MODE (TYPE) == BLKmode)
1059
1060 /* Functions which return large structures get the address
1061    to place the wanted value at offset 64 from the frame.
1062    Must reserve 64 bytes for the in and local registers.
1063    v9: Functions which return large structures get the address to place the
1064    wanted value from an invisible first argument.  */
1065 /* Used only in other #defines in this file.  */
1066 #define STRUCT_VALUE_OFFSET 64
1067
1068 #define STRUCT_VALUE \
1069   (TARGET_ARCH64                                        \
1070    ? 0                                                  \
1071    : gen_rtx (MEM, Pmode,                               \
1072               gen_rtx (PLUS, Pmode, stack_pointer_rtx,  \
1073                        gen_rtx (CONST_INT, VOIDmode, STRUCT_VALUE_OFFSET))))
1074 #define STRUCT_VALUE_INCOMING \
1075   (TARGET_ARCH64                                        \
1076    ? 0                                                  \
1077    : gen_rtx (MEM, Pmode,                               \
1078               gen_rtx (PLUS, Pmode, frame_pointer_rtx,  \
1079                        gen_rtx (CONST_INT, VOIDmode, STRUCT_VALUE_OFFSET))))
1080 \f
1081 /* Define the classes of registers for register constraints in the
1082    machine description.  Also define ranges of constants.
1083
1084    One of the classes must always be named ALL_REGS and include all hard regs.
1085    If there is more than one class, another class must be named NO_REGS
1086    and contain no registers.
1087
1088    The name GENERAL_REGS must be the name of a class (or an alias for
1089    another name such as ALL_REGS).  This is the class of registers
1090    that is allowed by "g" or "r" in a register constraint.
1091    Also, registers outside this class are allocated only when
1092    instructions express preferences for them.
1093
1094    The classes must be numbered in nondecreasing order; that is,
1095    a larger-numbered class must never be contained completely
1096    in a smaller-numbered class.
1097
1098    For any two classes, it is very desirable that there be another
1099    class that represents their union.  */
1100
1101 /* The SPARC has various kinds of registers: general, floating point,
1102    and condition codes [well, it has others as well, but none that we
1103    care directly about].
1104
1105    For v9 we must distinguish between the upper and lower floating point
1106    registers because the upper ones can't hold SFmode values.
1107    HARD_REGNO_MODE_OK won't help here because reload assumes that register(s)
1108    satisfying a group need for a class will also satisfy a single need for
1109    that class.  EXTRA_FP_REGS is a bit of a misnomer as it covers all 64 fp
1110    regs.
1111
1112    It is important that one class contains all the general and all the standard
1113    fp regs.  Otherwise find_reg() won't properly allocate int regs for moves,
1114    because reg_class_record() will bias the selection in favor of fp regs,
1115    because reg_class_subunion[GENERAL_REGS][FP_REGS] will yield FP_REGS,
1116    because FP_REGS > GENERAL_REGS.
1117
1118    It is also important that one class contain all the general and all the
1119    fp regs.  Otherwise when spilling a DFmode reg, it may be from EXTRA_FP_REGS
1120    but find_reloads() may use class GENERAL_OR_FP_REGS. This will cause
1121    allocate_reload_reg() to bypass it causing an abort because the compiler
1122    thinks it doesn't have a spill reg when in fact it does.
1123
1124    v9 also has 4 floating point condition code registers.  Since we don't
1125    have a class that is the union of FPCC_REGS with either of the others,
1126    it is important that it appear first.  Otherwise the compiler will die
1127    trying to compile _fixunsdfsi because fix_truncdfsi2 won't match its
1128    constraints.
1129
1130    It is important that SPARC_ICC_REG have class NO_REGS.  Otherwise combine
1131    may try to use it to hold an SImode value.  See register_operand.
1132    ??? Should %fcc[0123] be handled similarily?
1133 */
1134
1135 enum reg_class { NO_REGS, FPCC_REGS, GENERAL_REGS, FP_REGS, EXTRA_FP_REGS,
1136                  GENERAL_OR_FP_REGS, GENERAL_OR_EXTRA_FP_REGS,
1137                  ALL_REGS, LIM_REG_CLASSES };
1138
1139 #define N_REG_CLASSES (int) LIM_REG_CLASSES
1140
1141 /* Give names of register classes as strings for dump file.   */
1142
1143 #define REG_CLASS_NAMES \
1144   { "NO_REGS", "FPCC_REGS", "GENERAL_REGS", "FP_REGS", "EXTRA_FP_REGS", \
1145     "GENERAL_OR_FP_REGS", "GENERAL_OR_EXTRA_FP_REGS", "ALL_REGS" }
1146
1147 /* Define which registers fit in which classes.
1148    This is an initializer for a vector of HARD_REG_SET
1149    of length N_REG_CLASSES.  */
1150
1151 #define REG_CLASS_CONTENTS \
1152   {{0, 0, 0, 0}, {0, 0, 0, 0xf}, \
1153    {-1, 0, 0, 0}, {0, -1, 0, 0}, {0, -1, -1, 0}, \
1154    {-1, -1, 0, 0}, {-1, -1, -1, 0}, {-1, -1, -1, 0x1f}}
1155
1156 /* The same information, inverted:
1157    Return the class number of the smallest class containing
1158    reg number REGNO.  This could be a conditional expression
1159    or could index an array.  */
1160
1161 extern enum reg_class sparc_regno_reg_class[];
1162
1163 #define REGNO_REG_CLASS(REGNO) sparc_regno_reg_class[(REGNO)]
1164
1165 /* This is the order in which to allocate registers normally.  
1166    
1167    We put %f0/%f1 last among the float registers, so as to make it more
1168    likely that a pseudo-register which dies in the float return register
1169    will get allocated to the float return register, thus saving a move
1170    instruction at the end of the function.  */
1171
1172 #define REG_ALLOC_ORDER \
1173 { 8, 9, 10, 11, 12, 13, 2, 3,           \
1174   15, 16, 17, 18, 19, 20, 21, 22,       \
1175   23, 24, 25, 26, 27, 28, 29, 31,       \
1176   34, 35, 36, 37, 38, 39,               /* %f2-%f7 */   \
1177   40, 41, 42, 43, 44, 45, 46, 47,       /* %f8-%f15 */  \
1178   48, 49, 50, 51, 52, 53, 54, 55,       /* %f16-%f23 */ \
1179   56, 57, 58, 59, 60, 61, 62, 63,       /* %f24-%f31 */ \
1180   64, 65, 66, 67, 68, 69, 70, 71,       /* %f32-%f39 */ \
1181   72, 73, 74, 75, 76, 77, 78, 79,       /* %f40-%f47 */ \
1182   80, 81, 82, 83, 84, 85, 86, 87,       /* %f48-%f55 */ \
1183   88, 89, 90, 91, 92, 93, 94, 95,       /* %f56-%f63 */ \
1184   32, 33,                               /* %f0,%f1 */   \
1185   96, 97, 98, 99, 100,                  /* %fcc0-3, %icc */ \
1186   1, 4, 5, 6, 7, 0, 14, 30}
1187
1188 /* This is the order in which to allocate registers for
1189    leaf functions.  If all registers can fit in the "i" registers,
1190    then we have the possibility of having a leaf function.  */
1191
1192 #define REG_LEAF_ALLOC_ORDER \
1193 { 2, 3, 24, 25, 26, 27, 28, 29,         \
1194   15, 8, 9, 10, 11, 12, 13,             \
1195   16, 17, 18, 19, 20, 21, 22, 23,       \
1196   34, 35, 36, 37, 38, 39,               \
1197   40, 41, 42, 43, 44, 45, 46, 47,       \
1198   48, 49, 50, 51, 52, 53, 54, 55,       \
1199   56, 57, 58, 59, 60, 61, 62, 63,       \
1200   64, 65, 66, 67, 68, 69, 70, 71,       \
1201   72, 73, 74, 75, 76, 77, 78, 79,       \
1202   80, 81, 82, 83, 84, 85, 86, 87,       \
1203   88, 89, 90, 91, 92, 93, 94, 95,       \
1204   32, 33,                               \
1205   96, 97, 98, 99, 100,                  \
1206   1, 4, 5, 6, 7, 0, 14, 30, 31}
1207
1208 #define ORDER_REGS_FOR_LOCAL_ALLOC order_regs_for_local_alloc ()
1209
1210 /* ??? %g7 is not a leaf register to effectively #undef LEAF_REGISTERS when
1211    -mflat is used.  Function only_leaf_regs_used will return 0 if a global
1212    register is used and is not permitted in a leaf function.  We make %g7
1213    a global reg if -mflat and voila.  Since %g7 is a system register and is
1214    fixed it won't be used by gcc anyway.  */
1215
1216 #define LEAF_REGISTERS \
1217 { 1, 1, 1, 1, 1, 1, 1, 0,       \
1218   0, 0, 0, 0, 0, 0, 1, 0,       \
1219   0, 0, 0, 0, 0, 0, 0, 0,       \
1220   1, 1, 1, 1, 1, 1, 0, 1,       \
1221   1, 1, 1, 1, 1, 1, 1, 1,       \
1222   1, 1, 1, 1, 1, 1, 1, 1,       \
1223   1, 1, 1, 1, 1, 1, 1, 1,       \
1224   1, 1, 1, 1, 1, 1, 1, 1,       \
1225   1, 1, 1, 1, 1, 1, 1, 1,       \
1226   1, 1, 1, 1, 1, 1, 1, 1,       \
1227   1, 1, 1, 1, 1, 1, 1, 1,       \
1228   1, 1, 1, 1, 1, 1, 1, 1,       \
1229   1, 1, 1, 1, 1}
1230
1231 extern char leaf_reg_remap[];
1232 #define LEAF_REG_REMAP(REGNO) (leaf_reg_remap[REGNO])
1233
1234 /* The class value for index registers, and the one for base regs.  */
1235 #define INDEX_REG_CLASS GENERAL_REGS
1236 #define BASE_REG_CLASS GENERAL_REGS
1237
1238 /* Local macro to handle the two v9 classes of FP regs.  */
1239 #define FP_REG_CLASS_P(CLASS) ((CLASS) == FP_REGS || (CLASS) == EXTRA_FP_REGS)
1240
1241 /* Get reg_class from a letter such as appears in the machine description.
1242    In the not-v9 case, coerce v9's 'e' class to 'f', so we can use 'e' in the
1243    .md file for v8 and v9.  */
1244
1245 #define REG_CLASS_FROM_LETTER(C) \
1246 (TARGET_V9                      \
1247  ? ((C) == 'f' ? FP_REGS        \
1248     : (C) == 'e' ? EXTRA_FP_REGS \
1249     : (C) == 'c' ? FPCC_REGS    \
1250     : NO_REGS)                  \
1251  : ((C) == 'f' ? FP_REGS        \
1252     : (C) == 'e' ? FP_REGS      \
1253     : (C) == 'c' ? FPCC_REGS    \
1254     : NO_REGS))
1255
1256 /* The letters I, J, K, L and M in a register constraint string
1257    can be used to stand for particular ranges of immediate operands.
1258    This macro defines what the ranges are.
1259    C is the letter, and VALUE is a constant value.
1260    Return 1 if VALUE is in the range specified by C.
1261
1262    `I' is used for the range of constants an insn can actually contain.
1263    `J' is used for the range which is just zero (since that is R0).
1264    `K' is used for constants which can be loaded with a single sethi insn.
1265    `L' is used for the range of constants supported by the movcc insns.
1266    `M' is used for the range of constants supported by the movrcc insns.  */
1267
1268 #define SPARC_SIMM10_P(X) ((unsigned HOST_WIDE_INT) (X) + 0x200 < 0x400)
1269 #define SPARC_SIMM11_P(X) ((unsigned HOST_WIDE_INT) (X) + 0x400 < 0x800)
1270 #define SPARC_SIMM13_P(X) ((unsigned HOST_WIDE_INT) (X) + 0x1000 < 0x2000)
1271 /* 10 and 11 bit immediates are only used for a few specific insns.
1272    SMALL_INT is used throughout the port so we continue to use it.  */
1273 #define SMALL_INT(X) (SPARC_SIMM13_P (INTVAL (X)))
1274 #define SPARC_SETHI_P(X) \
1275 (((unsigned HOST_WIDE_INT) (X) & ~(unsigned HOST_WIDE_INT) 0xfffffc00) == 0)
1276
1277 #define CONST_OK_FOR_LETTER_P(VALUE, C)  \
1278   ((C) == 'I' ? SPARC_SIMM13_P (VALUE)                  \
1279    : (C) == 'J' ? (VALUE) == 0                          \
1280    : (C) == 'K' ? SPARC_SETHI_P (VALUE)                 \
1281    : (C) == 'L' ? SPARC_SIMM11_P (VALUE)                \
1282    : (C) == 'M' ? SPARC_SIMM10_P (VALUE)                \
1283    : 0)
1284
1285 /* Similar, but for floating constants, and defining letters G and H.
1286    Here VALUE is the CONST_DOUBLE rtx itself.  */
1287
1288 #define CONST_DOUBLE_OK_FOR_LETTER_P(VALUE, C)  \
1289   ((C) == 'G' ? fp_zero_operand (VALUE)                 \
1290    : (C) == 'H' ? arith_double_operand (VALUE, DImode)  \
1291    : 0)
1292
1293 /* Given an rtx X being reloaded into a reg required to be
1294    in class CLASS, return the class of reg to actually use.
1295    In general this is just CLASS; but on some machines
1296    in some cases it is preferable to use a more restrictive class.  */
1297 /* We can't load constants into FP registers.  We can't load any FP constant
1298    if an 'E' constraint fails to match it.  */
1299 #define PREFERRED_RELOAD_CLASS(X,CLASS)                 \
1300   (CONSTANT_P (X)                                       \
1301    && (FP_REG_CLASS_P (CLASS)                           \
1302        || (GET_MODE_CLASS (GET_MODE (X)) == MODE_FLOAT  \
1303            && (HOST_FLOAT_FORMAT != IEEE_FLOAT_FORMAT   \
1304                || HOST_BITS_PER_INT != BITS_PER_WORD))) \
1305    ? NO_REGS : (CLASS))
1306
1307 /* Return the register class of a scratch register needed to load IN into
1308    a register of class CLASS in MODE.
1309
1310    On the SPARC, when PIC, we need a temporary when loading some addresses
1311    into a register.
1312
1313    Also, we need a temporary when loading/storing a HImode/QImode value
1314    between memory and the FPU registers.  This can happen when combine puts
1315    a paradoxical subreg in a float/fix conversion insn.  */
1316
1317 #define SECONDARY_INPUT_RELOAD_CLASS(CLASS, MODE, IN)           \
1318   ((FP_REG_CLASS_P (CLASS) && ((MODE) == HImode || (MODE) == QImode) \
1319     && (GET_CODE (IN) == MEM                                    \
1320         || ((GET_CODE (IN) == REG || GET_CODE (IN) == SUBREG)   \
1321             && true_regnum (IN) == -1))) ? GENERAL_REGS : NO_REGS)
1322
1323 #define SECONDARY_OUTPUT_RELOAD_CLASS(CLASS, MODE, IN)          \
1324   ((FP_REG_CLASS_P (CLASS) && ((MODE) == HImode || (MODE) == QImode) \
1325     && (GET_CODE (IN) == MEM                                    \
1326         || ((GET_CODE (IN) == REG || GET_CODE (IN) == SUBREG)   \
1327             && true_regnum (IN) == -1))) ? GENERAL_REGS : NO_REGS)
1328
1329 /* On SPARC it is not possible to directly move data between 
1330    GENERAL_REGS and FP_REGS.  */
1331 #define SECONDARY_MEMORY_NEEDED(CLASS1, CLASS2, MODE) \
1332   (FP_REG_CLASS_P (CLASS1) != FP_REG_CLASS_P (CLASS2))
1333
1334 /* Return the stack location to use for secondary memory needed reloads.
1335    We want to use the reserved location just below the frame pointer.
1336    However, we must ensure that there is a frame, so use assign_stack_local
1337    if the frame size is zero.  */
1338 #define SECONDARY_MEMORY_NEEDED_RTX(MODE) \
1339   (get_frame_size () == 0                                               \
1340    ? assign_stack_local (MODE, GET_MODE_SIZE (MODE), 0)                 \
1341    : gen_rtx (MEM, MODE, gen_rtx (PLUS, Pmode, frame_pointer_rtx,       \
1342                                   GEN_INT (STARTING_FRAME_OFFSET))))
1343
1344 /* Get_secondary_mem widens it's argument to BITS_PER_WORD which loses on v9
1345    because the movsi and movsf patterns don't handle r/f moves.
1346    For v8 we copy the default definition.  */
1347 #define SECONDARY_MEMORY_NEEDED_MODE(MODE) \
1348   (TARGET_ARCH64                                                \
1349    ? (GET_MODE_BITSIZE (MODE) < 32                              \
1350       ? mode_for_size (32, GET_MODE_CLASS (MODE), 0)            \
1351       : MODE)                                                   \
1352    : (GET_MODE_BITSIZE (MODE) < BITS_PER_WORD                   \
1353       ? mode_for_size (BITS_PER_WORD, GET_MODE_CLASS (MODE), 0) \
1354       : MODE))
1355
1356 /* Return the maximum number of consecutive registers
1357    needed to represent mode MODE in a register of class CLASS.  */
1358 /* On SPARC, this is the size of MODE in words.  */
1359 #define CLASS_MAX_NREGS(CLASS, MODE)    \
1360   (FP_REG_CLASS_P (CLASS) ? (GET_MODE_SIZE (MODE) + 3) / 4 \
1361    : (GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
1362 \f
1363 /* Stack layout; function entry, exit and calling.  */
1364
1365 /* Define the number of register that can hold parameters.
1366    This macro is only used in other macro definitions below and in sparc.c.
1367    MODE is the mode of the argument.
1368    !v9: All args are passed in %o0-%o5.
1369    v9: %o0-%o5 and %f0-%f31 are cumulatively used to pass values.
1370    See the description in sparc.c.  */
1371 #define NPARM_REGS(MODE) \
1372 (TARGET_ARCH64 \
1373  ? (GET_MODE_CLASS (MODE) == MODE_FLOAT ? 32 : 6) \
1374  : 6)
1375
1376 /* Define this if pushing a word on the stack
1377    makes the stack pointer a smaller address.  */
1378 #define STACK_GROWS_DOWNWARD
1379
1380 /* Define this if the nominal address of the stack frame
1381    is at the high-address end of the local variables;
1382    that is, each additional local variable allocated
1383    goes at a more negative offset in the frame.  */
1384 #define FRAME_GROWS_DOWNWARD
1385
1386 /* Offset within stack frame to start allocating local variables at.
1387    If FRAME_GROWS_DOWNWARD, this is the offset to the END of the
1388    first local allocated.  Otherwise, it is the offset to the BEGINNING
1389    of the first local allocated.  */
1390 /* This allows space for one TFmode floating point value.  */
1391 #define STARTING_FRAME_OFFSET \
1392   (TARGET_ARCH64 ? (SPARC_STACK_BIAS - 16) \
1393    : (-SPARC_STACK_ALIGN (LONG_DOUBLE_TYPE_SIZE / BITS_PER_UNIT)))
1394
1395 /* If we generate an insn to push BYTES bytes,
1396    this says how many the stack pointer really advances by.
1397    On SPARC, don't define this because there are no push insns.  */
1398 /*  #define PUSH_ROUNDING(BYTES) */
1399
1400 /* Offset of first parameter from the argument pointer register value.
1401    !v9: This is 64 for the ins and locals, plus 4 for the struct-return reg
1402    even if this function isn't going to use it.
1403    v9: This is 128 for the ins and locals.  */
1404 #define FIRST_PARM_OFFSET(FNDECL) \
1405   (TARGET_ARCH64 ? (SPARC_STACK_BIAS + 16 * UNITS_PER_WORD) \
1406    : (STRUCT_VALUE_OFFSET + UNITS_PER_WORD))
1407
1408 /* When a parameter is passed in a register, stack space is still
1409    allocated for it.  */
1410 /* This only takes into account the int regs.
1411    fp regs are handled elsewhere.  */
1412 #define REG_PARM_STACK_SPACE(DECL) (6 * UNITS_PER_WORD)
1413
1414 /* Keep the stack pointer constant throughout the function.
1415    This is both an optimization and a necessity: longjmp
1416    doesn't behave itself when the stack pointer moves within
1417    the function!  */
1418 #define ACCUMULATE_OUTGOING_ARGS
1419
1420 /* Value is the number of bytes of arguments automatically
1421    popped when returning from a subroutine call.
1422    FUNDECL is the declaration node of the function (as a tree),
1423    FUNTYPE is the data type of the function (as a tree),
1424    or for a library call it is an identifier node for the subroutine name.
1425    SIZE is the number of bytes of arguments passed on the stack.  */
1426
1427 #define RETURN_POPS_ARGS(FUNDECL,FUNTYPE,SIZE) 0
1428
1429 /* Some subroutine macros specific to this machine.
1430    When !TARGET_FPU, put float return values in the general registers,
1431    since we don't have any fp registers.  */
1432 #define BASE_RETURN_VALUE_REG(MODE) \
1433   (TARGET_ARCH64 \
1434    ? (TARGET_FPU && GET_MODE_CLASS (MODE) == MODE_FLOAT ? 32 : 8) \
1435    : (((MODE) == SFmode || (MODE) == DFmode) && TARGET_FPU ? 32 : 8))
1436 #define BASE_OUTGOING_VALUE_REG(MODE) \
1437   (TARGET_ARCH64 \
1438    ? (TARGET_FPU && GET_MODE_CLASS (MODE) == MODE_FLOAT ? 32 \
1439       : TARGET_FLAT ? 8 : 24) \
1440    : (((MODE) == SFmode || (MODE) == DFmode) && TARGET_FPU ? 32 \
1441       : (TARGET_FLAT ? 8 : 24)))
1442 #define BASE_PASSING_ARG_REG(MODE) \
1443   (TARGET_ARCH64 \
1444    ? (TARGET_FPU && GET_MODE_CLASS (MODE) == MODE_FLOAT ? 32 : 8) \
1445    : 8)
1446 #define BASE_INCOMING_ARG_REG(MODE) \
1447   (TARGET_ARCH64 \
1448    ? (TARGET_FPU && GET_MODE_CLASS (MODE) == MODE_FLOAT ? 32 \
1449       : TARGET_FLAT ? 8 : 24) \
1450    : (TARGET_FLAT ? 8 : 24))
1451
1452 /* Define this macro if the target machine has "register windows".  This
1453    C expression returns the register number as seen by the called function
1454    corresponding to register number OUT as seen by the calling function.
1455    Return OUT if register number OUT is not an outbound register.  */
1456
1457 #define INCOMING_REGNO(OUT) \
1458  ((TARGET_FLAT || (OUT) < 8 || (OUT) > 15) ? (OUT) : (OUT) + 16)
1459
1460 /* Define this macro if the target machine has "register windows".  This
1461    C expression returns the register number as seen by the calling function
1462    corresponding to register number IN as seen by the called function.
1463    Return IN if register number IN is not an inbound register.  */
1464
1465 #define OUTGOING_REGNO(IN) \
1466  ((TARGET_FLAT || (IN) < 24 || (IN) > 31) ? (IN) : (IN) - 16)
1467
1468 /* Define how to find the value returned by a function.
1469    VALTYPE is the data type of the value (as a tree).
1470    If the precise function being called is known, FUNC is its FUNCTION_DECL;
1471    otherwise, FUNC is 0.  */
1472
1473 /* On SPARC the value is found in the first "output" register.  */
1474
1475 #define FUNCTION_VALUE(VALTYPE, FUNC)  \
1476   gen_rtx (REG, TYPE_MODE (VALTYPE), BASE_RETURN_VALUE_REG (TYPE_MODE (VALTYPE)))
1477
1478 /* But the called function leaves it in the first "input" register.  */
1479
1480 #define FUNCTION_OUTGOING_VALUE(VALTYPE, FUNC)  \
1481   gen_rtx (REG, TYPE_MODE (VALTYPE), BASE_OUTGOING_VALUE_REG (TYPE_MODE (VALTYPE)))
1482
1483 /* Define how to find the value returned by a library function
1484    assuming the value has mode MODE.  */
1485
1486 #define LIBCALL_VALUE(MODE)     \
1487   gen_rtx (REG, MODE, BASE_RETURN_VALUE_REG (MODE))
1488
1489 /* 1 if N is a possible register number for a function value
1490    as seen by the caller.
1491    On SPARC, the first "output" reg is used for integer values,
1492    and the first floating point register is used for floating point values.  */
1493
1494 #define FUNCTION_VALUE_REGNO_P(N) ((N) == 8 || (N) == 32)
1495
1496 /* Define the size of space to allocate for the return value of an
1497    untyped_call.  */
1498
1499 #define APPLY_RESULT_SIZE 16
1500
1501 /* 1 if N is a possible register number for function argument passing.
1502    On SPARC, these are the "output" registers.  v9 also uses %f0-%f31.  */
1503
1504 #define FUNCTION_ARG_REGNO_P(N) \
1505 (TARGET_ARCH64 \
1506  ? (((N) >= 8 && (N) <= 13) || ((N) >= 32 && (N) <= 63)) \
1507  : ((N) >= 8 && (N) <= 13))
1508 \f
1509 /* Define a data type for recording info about an argument list
1510    during the scan of that argument list.  This data type should
1511    hold all necessary information about the function itself
1512    and about the args processed so far, enough to enable macros
1513    such as FUNCTION_ARG to determine where the next arg should go.
1514
1515    On SPARC (!v9), this is a single integer, which is a number of words
1516    of arguments scanned so far (including the invisible argument,
1517    if any, which holds the structure-value-address).
1518    Thus 7 or more means all following args should go on the stack.
1519
1520    For v9, we also need to know whether a prototype is present.  */
1521
1522 struct sparc_args {
1523   int words;       /* number of words passed so far */
1524   int prototype_p; /* non-zero if a prototype is present */
1525   int libcall_p;   /* non-zero if a library call */
1526 };
1527 #define CUMULATIVE_ARGS struct sparc_args
1528
1529 /* Initialize a variable CUM of type CUMULATIVE_ARGS
1530    for a call to a function whose data type is FNTYPE.
1531    For a library call, FNTYPE is 0.  */
1532
1533 extern void init_cumulative_args ();
1534 #define INIT_CUMULATIVE_ARGS(CUM, FNTYPE, LIBNAME, INDIRECT) \
1535 init_cumulative_args (& (CUM), (FNTYPE), (LIBNAME), (INDIRECT));
1536
1537 /* Update the data in CUM to advance over an argument
1538    of mode MODE and data type TYPE.
1539    TYPE is null for libcalls where that information may not be available.  */
1540
1541 extern void function_arg_advance ();
1542 #define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED) \
1543 function_arg_advance (& (CUM), (MODE), (TYPE), (NAMED))
1544
1545 /* Determine where to put an argument to a function.
1546    Value is zero to push the argument on the stack,
1547    or a hard register in which to store the argument.
1548
1549    MODE is the argument's machine mode.
1550    TYPE is the data type of the argument (as a tree).
1551     This is null for libcalls where that information may
1552     not be available.
1553    CUM is a variable of type CUMULATIVE_ARGS which gives info about
1554     the preceding args and about the function being called.
1555    NAMED is nonzero if this argument is a named parameter
1556     (otherwise it is an extra parameter matching an ellipsis).  */
1557
1558 extern struct rtx_def *function_arg ();
1559 #define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \
1560 function_arg (& (CUM), (MODE), (TYPE), (NAMED), 0)
1561
1562 /* Define where a function finds its arguments.
1563    This is different from FUNCTION_ARG because of register windows.  */
1564
1565 #define FUNCTION_INCOMING_ARG(CUM, MODE, TYPE, NAMED) \
1566 function_arg (& (CUM), (MODE), (TYPE), (NAMED), 1)
1567
1568 /* For an arg passed partly in registers and partly in memory,
1569    this is the number of registers used.
1570    For args passed entirely in registers or entirely in memory, zero.  */
1571
1572 extern int function_arg_partial_nregs ();
1573 #define FUNCTION_ARG_PARTIAL_NREGS(CUM, MODE, TYPE, NAMED) \
1574 function_arg_partial_nregs (& (CUM), (MODE), (TYPE), (NAMED))
1575
1576 /* A C expression that indicates when an argument must be passed by reference.
1577    If nonzero for an argument, a copy of that argument is made in memory and a
1578    pointer to the argument is passed instead of the argument itself.
1579    The pointer is passed in whatever way is appropriate for passing a pointer
1580    to that type.  */
1581
1582 extern int function_arg_pass_by_reference ();
1583 #define FUNCTION_ARG_PASS_BY_REFERENCE(CUM, MODE, TYPE, NAMED) \
1584 function_arg_pass_by_reference (& (CUM), (MODE), (TYPE), (NAMED))
1585
1586 /* If defined, a C expression which determines whether, and in which direction,
1587    to pad out an argument with extra space.  The value should be of type
1588    `enum direction': either `upward' to pad above the argument,
1589    `downward' to pad below, or `none' to inhibit padding.  */
1590 extern enum direction function_arg_padding ();
1591 #define FUNCTION_ARG_PADDING(MODE, TYPE) \
1592 function_arg_padding ((MODE), (TYPE))
1593
1594 /* If defined, a C expression that gives the alignment boundary, in bits,
1595    of an argument with the specified mode and type.  If it is not defined,
1596    PARM_BOUNDARY is used for all arguments.
1597    For sparc64, objects requiring 16 byte alignment are passed that way.  */
1598
1599 #define FUNCTION_ARG_BOUNDARY(MODE, TYPE) \
1600 ((TARGET_ARCH64                                 \
1601   && (GET_MODE_ALIGNMENT (MODE) == 128          \
1602       || ((TYPE) && TYPE_ALIGN (TYPE) == 128))) \
1603  ? 128 : PARM_BOUNDARY)
1604 \f
1605 /* Initialize data used by insn expanders.  This is called from
1606    init_emit, once for each function, before code is generated.
1607    For v9, clear the temp slot used by float/int DImode conversions.
1608    ??? There is the 16 bytes at [%fp-16], however we'd like to delete this
1609    space at some point.
1610    ??? Use assign_stack_temp?  */
1611
1612 extern void sparc_init_expanders ();
1613 extern struct rtx_def *sparc64_fpconv_stack_temp ();
1614 #define INIT_EXPANDERS sparc_init_expanders ()
1615
1616 /* Define the information needed to generate branch and scc insns.  This is
1617    stored from the compare operation.  Note that we can't use "rtx" here
1618    since it hasn't been defined!  */
1619
1620 extern struct rtx_def *sparc_compare_op0, *sparc_compare_op1;
1621
1622 /* Define the function that build the compare insn for scc and bcc.  */
1623
1624 extern struct rtx_def *gen_compare_reg ();
1625
1626 /* This function handles all v9 scc insns */
1627
1628 extern int gen_v9_scc ();
1629 \f
1630 /* Generate the special assembly code needed to tell the assembler whatever
1631    it might need to know about the return value of a function.
1632
1633    For Sparc assemblers, we need to output a .proc pseudo-op which conveys
1634    information to the assembler relating to peephole optimization (done in
1635    the assembler).  */
1636
1637 #define ASM_DECLARE_RESULT(FILE, RESULT) \
1638   fprintf ((FILE), "\t.proc\t0%o\n", sparc_type_code (TREE_TYPE (RESULT)))
1639
1640 /* Output the label for a function definition.  */
1641
1642 #define ASM_DECLARE_FUNCTION_NAME(FILE, NAME, DECL)                     \
1643 do {                                                                    \
1644   ASM_DECLARE_RESULT (FILE, DECL_RESULT (DECL));                        \
1645   ASM_OUTPUT_LABEL (FILE, NAME);                                        \
1646 } while (0)
1647
1648 /* This macro generates the assembly code for function entry.
1649    FILE is a stdio stream to output the code to.
1650    SIZE is an int: how many units of temporary storage to allocate.
1651    Refer to the array `regs_ever_live' to determine which registers
1652    to save; `regs_ever_live[I]' is nonzero if register number I
1653    is ever used in the function.  This macro is responsible for
1654    knowing which registers should not be saved even if used.  */
1655
1656 /* On SPARC, move-double insns between fpu and cpu need an 8-byte block
1657    of memory.  If any fpu reg is used in the function, we allocate
1658    such a block here, at the bottom of the frame, just in case it's needed.
1659
1660    If this function is a leaf procedure, then we may choose not
1661    to do a "save" insn.  The decision about whether or not
1662    to do this is made in regclass.c.  */
1663
1664 extern int leaf_function;
1665 #define FUNCTION_PROLOGUE(FILE, SIZE) \
1666   (TARGET_FLAT ? sparc_flat_output_function_prologue (FILE, SIZE) \
1667    : output_function_prologue (FILE, SIZE, leaf_function))
1668 \f
1669 /* Output assembler code to FILE to increment profiler label # LABELNO
1670    for profiling a function entry.
1671
1672    32 bit sparc uses %g2 as the STATIC_CHAIN_REGNUM which gets clobbered
1673    during profiling so we need to save/restore it around the call to mcount.
1674    We're guaranteed that a save has just been done, and we use the space
1675    allocated for intreg/fpreg value passing.  */
1676
1677 #define FUNCTION_PROFILER(FILE, LABELNO)                        \
1678   do {                                                          \
1679     char buf[20];                                               \
1680     ASM_GENERATE_INTERNAL_LABEL (buf, "LP", (LABELNO));         \
1681     if (! TARGET_ARCH64)                                        \
1682       fputs ("\tst %g2,[%fp-4]\n", FILE);                       \
1683     fputs ("\tsethi %hi(", FILE);                               \
1684     assemble_name (FILE, buf);                                  \
1685     fputs ("),%o0\n", FILE);                                    \
1686     fputs ("\tcall mcount\n\tadd %o0,%lo(", FILE);              \
1687     assemble_name (FILE, buf);                                  \
1688     fputs ("),%o0\n", FILE);                                    \
1689     if (! TARGET_ARCH64)                                        \
1690       fputs ("\tld [%fp-4],%g2\n", FILE);                       \
1691   } while (0)
1692
1693 /* There are three profiling modes for basic blocks available.
1694    The modes are selected at compile time by using the options
1695    -a or -ax of the gnu compiler.
1696    The variable `profile_block_flag' will be set according to the
1697    selected option.
1698
1699    profile_block_flag == 0, no option used:
1700
1701       No profiling done.
1702
1703    profile_block_flag == 1, -a option used.
1704
1705       Count frequency of execution of every basic block.
1706
1707    profile_block_flag == 2, -ax option used.
1708
1709       Generate code to allow several different profiling modes at run time. 
1710       Available modes are:
1711              Produce a trace of all basic blocks.
1712              Count frequency of jump instructions executed.
1713       In every mode it is possible to start profiling upon entering
1714       certain functions and to disable profiling of some other functions.
1715
1716     The result of basic-block profiling will be written to a file `bb.out'.
1717     If the -ax option is used parameters for the profiling will be read
1718     from file `bb.in'.
1719
1720 */
1721
1722 /* The following macro shall output assembler code to FILE
1723    to initialize basic-block profiling.
1724
1725    If profile_block_flag == 2
1726
1727         Output code to call the subroutine `__bb_init_trace_func'
1728         and pass two parameters to it. The first parameter is
1729         the address of a block allocated in the object module.
1730         The second parameter is the number of the first basic block
1731         of the function.
1732
1733         The name of the block is a local symbol made with this statement:
1734         
1735             ASM_GENERATE_INTERNAL_LABEL (BUFFER, "LPBX", 0);
1736
1737         Of course, since you are writing the definition of
1738         `ASM_GENERATE_INTERNAL_LABEL' as well as that of this macro, you
1739         can take a short cut in the definition of this macro and use the
1740         name that you know will result.
1741
1742         The number of the first basic block of the function is
1743         passed to the macro in BLOCK_OR_LABEL.
1744
1745         If described in a virtual assembler language the code to be
1746         output looks like:
1747
1748                 parameter1 <- LPBX0
1749                 parameter2 <- BLOCK_OR_LABEL
1750                 call __bb_init_trace_func
1751
1752     else if profile_block_flag != 0
1753
1754         Output code to call the subroutine `__bb_init_func'
1755         and pass one single parameter to it, which is the same
1756         as the first parameter to `__bb_init_trace_func'.
1757
1758         The first word of this parameter is a flag which will be nonzero if
1759         the object module has already been initialized.  So test this word
1760         first, and do not call `__bb_init_func' if the flag is nonzero.
1761         Note: When profile_block_flag == 2 the test need not be done
1762         but `__bb_init_trace_func' *must* be called.
1763
1764         BLOCK_OR_LABEL may be used to generate a label number as a
1765         branch destination in case `__bb_init_func' will not be called.
1766
1767         If described in a virtual assembler language the code to be
1768         output looks like:
1769
1770                 cmp (LPBX0),0
1771                 jne local_label
1772                 parameter1 <- LPBX0
1773                 call __bb_init_func
1774 local_label:
1775
1776 */
1777
1778 #define FUNCTION_BLOCK_PROFILER(FILE, BLOCK_OR_LABEL)   \
1779 do                                                      \
1780   {                                                     \
1781     int bol = (BLOCK_OR_LABEL);                         \
1782     switch (profile_block_flag)                         \
1783       {                                                 \
1784       case 2:                                           \
1785         fprintf (FILE, "\tsethi %%hi(LPBX0),%%o0\n\tor %%o0,%%lo(LPBX0),%%o0\n\tsethi %%hi(%d),%%o1\n\tcall ___bb_init_trace_func\n\tor %%o1,%%lo(%d),%%o1\n",\
1786                  bol, bol);                             \
1787         break;                                          \
1788       default:                                          \
1789         fprintf (FILE, "\tsethi %%hi(LPBX0),%%o0\n\tld [%%lo(LPBX0)+%%o0],%%o1\n\ttst %%o1\n\tbne LPY%d\n\tadd %%o0,%%lo(LPBX0),%%o0\n\tcall ___bb_init_func\n\tnop\nLPY%d:\n",\
1790                  bol, bol);                             \
1791         break;                                          \
1792       }                                                 \
1793   }                                                     \
1794 while (0)
1795
1796 /* The following macro shall output assembler code to FILE
1797    to increment a counter associated with basic block number BLOCKNO.
1798
1799    If profile_block_flag == 2
1800
1801         Output code to initialize the global structure `__bb' and
1802         call the function `__bb_trace_func' which will increment the
1803         counter.
1804
1805         `__bb' consists of two words. In the first word the number
1806         of the basic block has to be stored. In the second word
1807         the address of a block allocated in the object module 
1808         has to be stored.
1809
1810         The basic block number is given by BLOCKNO.
1811
1812         The address of the block is given by the label created with 
1813
1814             ASM_GENERATE_INTERNAL_LABEL (BUFFER, "LPBX", 0);
1815
1816         by FUNCTION_BLOCK_PROFILER.
1817
1818         Of course, since you are writing the definition of
1819         `ASM_GENERATE_INTERNAL_LABEL' as well as that of this macro, you
1820         can take a short cut in the definition of this macro and use the
1821         name that you know will result.
1822
1823         If described in a virtual assembler language the code to be
1824         output looks like:
1825
1826                 move BLOCKNO -> (__bb)
1827                 move LPBX0 -> (__bb+4)
1828                 call __bb_trace_func
1829
1830         Note that function `__bb_trace_func' must not change the
1831         machine state, especially the flag register. To grant
1832         this, you must output code to save and restore registers
1833         either in this macro or in the macros MACHINE_STATE_SAVE
1834         and MACHINE_STATE_RESTORE. The last two macros will be
1835         used in the function `__bb_trace_func', so you must make
1836         sure that the function prologue does not change any 
1837         register prior to saving it with MACHINE_STATE_SAVE.
1838
1839    else if profile_block_flag != 0
1840
1841         Output code to increment the counter directly.
1842         Basic blocks are numbered separately from zero within each
1843         compiled object module. The count associated with block number
1844         BLOCKNO is at index BLOCKNO in an array of words; the name of 
1845         this array is a local symbol made with this statement:
1846
1847             ASM_GENERATE_INTERNAL_LABEL (BUFFER, "LPBX", 2);
1848
1849         Of course, since you are writing the definition of
1850         `ASM_GENERATE_INTERNAL_LABEL' as well as that of this macro, you
1851         can take a short cut in the definition of this macro and use the
1852         name that you know will result. 
1853
1854         If described in a virtual assembler language, the code to be
1855         output looks like:
1856
1857                 inc (LPBX2+4*BLOCKNO)
1858
1859 */
1860
1861 #define BLOCK_PROFILER(FILE, BLOCKNO)   \
1862 do                                      \
1863   {                                     \
1864     int blockn = (BLOCKNO);             \
1865     switch (profile_block_flag)         \
1866       {                                 \
1867       case 2:                           \
1868         fprintf (FILE, "\tsethi %%hi(___bb),%%g1\n\tsethi %%hi(%d),%%g2\n\tor %%g2,%%lo(%d),%%g2\n\tst %%g2,[%%lo(___bb)+%%g1]\n\tsethi %%hi(LPBX0),%%g2\n\tor %%g2,%%lo(LPBX0),%%g2\n\tadd 4,%%g1,%%g1\n\tst %%g2,[%%lo(___bb)+%%g1]\n\tmov %%o7,%%g2\n\tcall ___bb_trace_func\n\tnop\n\tmov %%g2,%%o7\n",\
1869                  blockn, blockn); \
1870         break;                          \
1871       default:                          \
1872         fprintf (FILE, "\tsethi %%hi(LPBX2+%d),%%g1\n\tld [%%lo(LPBX2+%d)+%%g1],%%g2\n\
1873 \tadd %%g2,1,%%g2\n\tst %%g2,[%%lo(LPBX2+%d)+%%g1]\n", \
1874                  4 * blockn, 4 * blockn, 4 * blockn); \
1875         break;                          \
1876       }                                 \
1877   }                                     \
1878 while(0)
1879
1880 /* The following macro shall output assembler code to FILE
1881    to indicate a return from function during basic-block profiling.
1882
1883    If profiling_block_flag == 2:
1884
1885         Output assembler code to call function `__bb_trace_ret'.
1886
1887         Note that function `__bb_trace_ret' must not change the
1888         machine state, especially the flag register. To grant
1889         this, you must output code to save and restore registers
1890         either in this macro or in the macros MACHINE_STATE_SAVE_RET
1891         and MACHINE_STATE_RESTORE_RET. The last two macros will be
1892         used in the function `__bb_trace_ret', so you must make
1893         sure that the function prologue does not change any 
1894         register prior to saving it with MACHINE_STATE_SAVE_RET.
1895
1896    else if profiling_block_flag != 0:
1897
1898         The macro will not be used, so it need not distinguish
1899         these cases.
1900 */
1901
1902 #define FUNCTION_BLOCK_PROFILER_EXIT(FILE) \
1903   fprintf (FILE, "\tcall ___bb_trace_ret\n\tnop\n" );
1904
1905 /* The function `__bb_trace_func' is called in every basic block
1906    and is not allowed to change the machine state. Saving (restoring)
1907    the state can either be done in the BLOCK_PROFILER macro,
1908    before calling function (rsp. after returning from function)
1909    `__bb_trace_func', or it can be done inside the function by
1910    defining the macros:
1911
1912         MACHINE_STATE_SAVE(ID)
1913         MACHINE_STATE_RESTORE(ID)
1914
1915    In the latter case care must be taken, that the prologue code
1916    of function `__bb_trace_func' does not already change the
1917    state prior to saving it with MACHINE_STATE_SAVE.
1918
1919    The parameter `ID' is a string identifying a unique macro use.
1920
1921    On sparc it is sufficient to save the psw register to memory.
1922    Unfortunately the psw register can be read in supervisor mode only,
1923    so we read only the condition codes by using branch instructions
1924    and hope that this is enough. */
1925
1926 #define MACHINE_STATE_SAVE(ID) \
1927   asm ("        mov %g0,%l0");\
1928   asm ("        be,a LFLGNZ" ID);\
1929   asm ("        or %l0,4,%l0");\
1930   asm ("LFLGNZ" ID ":  bcs,a LFLGNC" ID);\
1931   asm ("        or %l0,1,%l0");\
1932   asm ("LFLGNC" ID ":  bvs,a LFLGNV" ID);\
1933   asm ("        or %l0,2,%l0");\
1934   asm ("LFLGNV" ID ":  bneg,a LFLGNN" ID);\
1935   asm ("        or %l0,8,%l0");\
1936   asm ("LFLGNN" ID ": sethi %hi(LFLAGS" ID "),%l1");\
1937   asm ("        st %l0,[%l1+%lo(LFLAGS" ID ")]"); \
1938   asm ("        st %g2,[%l1+%lo(LSAVRET" ID ")]");
1939
1940 /* On sparc MACHINE_STATE_RESTORE restores the psw register from memory.
1941    The psw register can be written in supervisor mode only,
1942    which is true even for simple condition codes.
1943    We use some combination of instructions to produce the
1944    proper condition codes, but some flag combinations can not
1945    be generated in this way. If this happens an unimplemented
1946    instruction will be executed to abort the program. */
1947
1948 #define MACHINE_STATE_RESTORE(ID) \
1949   asm ("        sethi %hi(LFLGTAB" ID "),%l1");\
1950   asm ("        ld [%l1+%lo(LFLGTAB" ID "-(LFLGTAB" ID "-LFLAGS" ID "))],%l0");\
1951   asm ("        ld [%l1+%lo(LFLGTAB" ID "-(LFLGTAB" ID "-LSAVRET" ID "))],%g2");\
1952   asm ("        sll %l0,2,%l0");\
1953   asm ("        add %l0,%l1,%l0");\
1954   asm ("        ld [%l0+%lo(LFLGTAB" ID ")],%l1");\
1955   asm ("        jmp %l1");\
1956   asm (" nop");\
1957   asm (".data");\
1958   asm ("        .align 4");\
1959   asm ("LFLAGS" ID ":");\
1960   asm ("        .word 0");\
1961   asm ("LSAVRET" ID ":");\
1962   asm (" .word 0");\
1963   asm ("LFLGTAB" ID ": ");\
1964   asm ("        .word LSFLG0" ID);\
1965   asm ("        .word LSFLGC" ID);\
1966   asm ("        .word LSFLGV" ID);\
1967   asm ("        .word LSFLGVC" ID);\
1968   asm ("        .word LSFLGZ" ID);\
1969   asm ("        .word LSFLGZC" ID);\
1970   asm ("        .word LSFLGZV" ID);\
1971   asm ("        .word LSFLGZVC" ID);\
1972   asm ("        .word LSFLGN" ID);\
1973   asm ("        .word LSFLGNC" ID);\
1974   asm ("        .word LSFLGNV" ID);\
1975   asm ("        .word LSFLGNVC" ID);\
1976   asm ("        .word LSFLGNZ" ID);\
1977   asm ("        .word LSFLGNZC" ID);\
1978   asm ("        .word LSFLGNZV" ID);\
1979   asm ("        .word LSFLGNZVC" ID);\
1980   asm (".text");\
1981   asm ("LSFLGVC" ID ": mov -1,%l0");\
1982   asm ("        addcc 2,%l0,%g0");\
1983   asm ("        sethi %hi(0x80000000),%l0");\
1984   asm ("        mov %l0,%l1");\
1985   asm ("        ba LFLGRET" ID);\
1986   asm ("        addxcc %l0,%l1,%l0");\
1987   asm ("LSFLGC" ID ":   mov -1,%l0");\
1988   asm ("        ba LFLGRET" ID);\
1989   asm ("        addcc 2,%l0,%g0");\
1990   asm ("LSFLGZC" ID ": mov -1,%l0");\
1991   asm ("        ba LFLGRET" ID);\
1992   asm ("        addcc 1,%l0,%l0");\
1993   asm ("LSFLGZVC" ID ": sethi %hi(0x80000000),%l0");\
1994   asm ("        mov %l0,%l1");\
1995   asm ("        ba LFLGRET" ID);\
1996   asm ("        addcc %l0,%l1,%l0");\
1997   asm ("LSFLGZ" ID ":   ba LFLGRET" ID);\
1998   asm ("        subcc %g0,%g0,%g0");\
1999   asm ("LSFLGNC" ID ": add %g0,1,%l0");\
2000   asm ("        ba LFLGRET" ID);\
2001   asm ("        subcc %g0,%l0,%g0");\
2002   asm ("LSFLG0" ID ":   ba LFLGRET" ID);\
2003   asm ("        orcc 1,%g0,%g0");\
2004   asm ("LSFLGN" ID ":   ba LFLGRET" ID);\
2005   asm (" orcc -1,%g0,%g0");\
2006   asm ("LSFLGV" ID ":");\
2007   asm ("LSFLGZV" ID ":");\
2008   asm ("LSFLGNV" ID ":");\
2009   asm ("LSFLGNVC" ID ":");\
2010   asm ("LSFLGNZ" ID ":");\
2011   asm ("LSFLGNZC" ID ":");\
2012   asm ("LSFLGNZV" ID ":");\
2013   asm ("LSFLGNZVC" ID ":");\
2014   asm ("        unimp");\
2015   asm ("LFLGRET" ID ":");
2016 \f
2017 /* EXIT_IGNORE_STACK should be nonzero if, when returning from a function,
2018    the stack pointer does not matter.  The value is tested only in
2019    functions that have frame pointers.
2020    No definition is equivalent to always zero.  */
2021
2022 extern int current_function_calls_alloca;
2023 extern int current_function_outgoing_args_size;
2024
2025 #define EXIT_IGNORE_STACK       \
2026  (get_frame_size () != 0        \
2027   || current_function_calls_alloca || current_function_outgoing_args_size)
2028
2029 /* This macro generates the assembly code for function exit,
2030    on machines that need it.  If FUNCTION_EPILOGUE is not defined
2031    then individual return instructions are generated for each
2032    return statement.  Args are same as for FUNCTION_PROLOGUE.
2033
2034    The function epilogue should not depend on the current stack pointer!
2035    It should use the frame pointer only.  This is mandatory because
2036    of alloca; we also take advantage of it to omit stack adjustments
2037    before returning.  */
2038
2039 /* This declaration is needed due to traditional/ANSI
2040    incompatibilities which cannot be #ifdefed away
2041    because they occur inside of macros.  Sigh.  */
2042 extern union tree_node *current_function_decl;
2043
2044 #define FUNCTION_EPILOGUE(FILE, SIZE) \
2045   (TARGET_FLAT ? sparc_flat_output_function_epilogue (FILE, SIZE) \
2046    : output_function_epilogue (FILE, SIZE, leaf_function))
2047
2048 #define DELAY_SLOTS_FOR_EPILOGUE \
2049   (TARGET_FLAT ? sparc_flat_epilogue_delay_slots () : 1)
2050 #define ELIGIBLE_FOR_EPILOGUE_DELAY(trial, slots_filled) \
2051   (TARGET_FLAT ? sparc_flat_eligible_for_epilogue_delay (trial, slots_filled) \
2052    : eligible_for_epilogue_delay (trial, slots_filled))
2053
2054 /* Define registers used by the epilogue and return instruction.  */
2055 #define EPILOGUE_USES(REGNO) \
2056   (!TARGET_FLAT && REGNO == 31)
2057 \f
2058 /* Output assembler code for a block containing the constant parts
2059    of a trampoline, leaving space for the variable parts.  */
2060
2061 /* On 32 bit sparcs, the trampoline contains five instructions:
2062      sethi #TOP_OF_FUNCTION,%g1
2063      or #BOTTOM_OF_FUNCTION,%g1,%g1
2064      sethi #TOP_OF_STATIC,%g2
2065      jmp g1
2066      or #BOTTOM_OF_STATIC,%g2,%g2
2067
2068   On 64 bit sparcs, the trampoline contains 4 insns and two pseudo-immediate
2069   constants (plus some padding):
2070      rd %pc,%g1
2071      ldx[%g1+20],%g5
2072      ldx[%g1+28],%g1
2073      jmp %g1
2074      nop
2075      nop
2076      .xword context
2077      .xword function  */
2078 /* ??? Stack is execute-protected in v9.  */
2079
2080 #define TRAMPOLINE_TEMPLATE(FILE) \
2081 do {                                                                    \
2082   if (TARGET_ARCH64)                                                    \
2083     {                                                                   \
2084       fprintf (FILE, "\trd %%pc,%%g1\n");                               \
2085       fprintf (FILE, "\tldx [%%g1+24],%%g5\n");                         \
2086       fprintf (FILE, "\tldx [%%g1+32],%%g1\n");                         \
2087       fprintf (FILE, "\tjmp %%g1\n");                                   \
2088       fprintf (FILE, "\tnop\n");                                        \
2089       fprintf (FILE, "\tnop\n");                                        \
2090       /* -mmedlow shouldn't generate .xwords, so don't use them at all */ \
2091       fprintf (FILE, "\t.word 0,0,0,0\n");                              \
2092     }                                                                   \
2093   else                                                                  \
2094     {                                                                   \
2095       ASM_OUTPUT_INT (FILE, gen_rtx (CONST_INT, VOIDmode, 0x00000000)); \
2096       ASM_OUTPUT_INT (FILE, gen_rtx (CONST_INT, VOIDmode, 0x00000000)); \
2097       ASM_OUTPUT_INT (FILE, gen_rtx (CONST_INT, VOIDmode, 0x00000000)); \
2098       ASM_OUTPUT_INT (FILE, gen_rtx (CONST_INT, VOIDmode, 0x81C04000)); \
2099       ASM_OUTPUT_INT (FILE, gen_rtx (CONST_INT, VOIDmode, 0x00000000)); \
2100     }                                                                   \
2101 } while (0)
2102
2103 /* Length in units of the trampoline for entering a nested function.  */
2104
2105 #define TRAMPOLINE_SIZE (TARGET_ARCH64 ? 40 : 20)
2106
2107 /* Emit RTL insns to initialize the variable parts of a trampoline.
2108    FNADDR is an RTX for the address of the function's pure code.
2109    CXT is an RTX for the static chain value for the function.  */
2110
2111 void sparc_initialize_trampoline ();
2112 void sparc64_initialize_trampoline ();
2113 #define INITIALIZE_TRAMPOLINE(TRAMP, FNADDR, CXT) \
2114   do {                                                          \
2115     if (TARGET_ARCH64)                                          \
2116       sparc64_initialize_trampoline (TRAMP, FNADDR, CXT);       \
2117     else                                                        \
2118       sparc_initialize_trampoline (TRAMP, FNADDR, CXT);         \
2119   } while (0)
2120 \f
2121 /* Generate necessary RTL for __builtin_saveregs().
2122    ARGLIST is the argument list; see expr.c.  */
2123
2124 extern struct rtx_def *sparc_builtin_saveregs ();
2125 #define EXPAND_BUILTIN_SAVEREGS(ARGLIST) sparc_builtin_saveregs (ARGLIST)
2126
2127 /* Define this macro if the location where a function argument is passed
2128    depends on whether or not it is a named argument.
2129
2130    This macro controls how the NAMED argument to FUNCTION_ARG
2131    is set for varargs and stdarg functions.  With this macro defined,
2132    the NAMED argument is always true for named arguments, and false for
2133    unnamed arguments.  If this is not defined, but SETUP_INCOMING_VARARGS
2134    is defined, then all arguments are treated as named.  Otherwise, all named
2135    arguments except the last are treated as named.
2136    For the v9 we want NAMED to mean what it says it means.  */
2137 /* ??? This needn't be set for v8, but I don't want to make this runtime
2138    selectable if I don't have to.  */
2139 #define STRICT_ARGUMENT_NAMING
2140
2141 /* Generate RTL to flush the register windows so as to make arbitrary frames
2142    available.  */
2143 #define SETUP_FRAME_ADDRESSES()         \
2144   emit_insn (gen_flush_register_windows ())
2145
2146 /* Given an rtx for the address of a frame,
2147    return an rtx for the address of the word in the frame
2148    that holds the dynamic chain--the previous frame's address.
2149    ??? -mflat support? */
2150 #define DYNAMIC_CHAIN_ADDRESS(frame) \
2151   gen_rtx (PLUS, Pmode, frame, gen_rtx (CONST_INT, VOIDmode, 14 * UNITS_PER_WORD))
2152
2153 /* The return address isn't on the stack, it is in a register, so we can't
2154    access it from the current frame pointer.  We can access it from the
2155    previous frame pointer though by reading a value from the register window
2156    save area.  */
2157 #define RETURN_ADDR_IN_PREVIOUS_FRAME
2158
2159 /* This is the offset of the return address to the true next instruction to be
2160    executed for the current function. */
2161 #define RETURN_ADDR_OFFSET \
2162   (8 + 4 * (! TARGET_ARCH64 && current_function_returns_struct))
2163
2164 /* The current return address is in %i7.  The return address of anything
2165    farther back is in the register window save area at [%fp+60].  */
2166 /* ??? This ignores the fact that the actual return address is +8 for normal
2167    returns, and +12 for structure returns.  */
2168 #define RETURN_ADDR_RTX(count, frame)           \
2169   ((count == -1)                                \
2170    ? gen_rtx (REG, Pmode, 31)                   \
2171    : gen_rtx (MEM, Pmode,                       \
2172               memory_address (Pmode, plus_constant (frame, 15 * UNITS_PER_WORD))))
2173
2174 /* Before the prologue, the return address is %o7 + 8.  OK, sometimes it's
2175    +12, but always using +8 is close enough for frame unwind purposes.
2176    Actually, just using %o7 is close enough for unwinding, but %o7+8
2177    is something you can return to.  */
2178 #define INCOMING_RETURN_ADDR_RTX \
2179   gen_rtx (PLUS, word_mode, gen_rtx (REG, word_mode, 15), GEN_INT (8))
2180
2181 /* The offset from the incoming value of %sp to the top of the stack frame
2182    for the current function.  On sparc64, we have to account for the stack
2183    bias if present.  */
2184 #define INCOMING_FRAME_SP_OFFSET SPARC_STACK_BIAS
2185
2186 #define DOESNT_NEED_UNWINDER (! TARGET_FLAT)
2187 \f
2188 /* Addressing modes, and classification of registers for them.  */
2189
2190 /* #define HAVE_POST_INCREMENT */
2191 /* #define HAVE_POST_DECREMENT */
2192
2193 /* #define HAVE_PRE_DECREMENT */
2194 /* #define HAVE_PRE_INCREMENT */
2195
2196 /* Macros to check register numbers against specific register classes.  */
2197
2198 /* These assume that REGNO is a hard or pseudo reg number.
2199    They give nonzero only if REGNO is a hard reg of the suitable class
2200    or a pseudo reg currently allocated to a suitable hard reg.
2201    Since they use reg_renumber, they are safe only once reg_renumber
2202    has been allocated, which happens in local-alloc.c.  */
2203
2204 #define REGNO_OK_FOR_INDEX_P(REGNO) \
2205 ((REGNO) < 32 || (unsigned) reg_renumber[REGNO] < 32)
2206 #define REGNO_OK_FOR_BASE_P(REGNO) \
2207 ((REGNO) < 32 || (unsigned) reg_renumber[REGNO] < 32)
2208 #define REGNO_OK_FOR_FP_P(REGNO) \
2209   (((unsigned) (REGNO) - 32 < (TARGET_V9 ? 64 : 32)) \
2210    || ((unsigned) reg_renumber[REGNO] - 32 < (TARGET_V9 ? 64 : 32)))
2211 #define REGNO_OK_FOR_CCFP_P(REGNO) \
2212  (TARGET_V9 \
2213   && (((unsigned) (REGNO) - 96 < 4) \
2214       || ((unsigned) reg_renumber[REGNO] - 96 < 4)))
2215
2216 /* Now macros that check whether X is a register and also,
2217    strictly, whether it is in a specified class.
2218
2219    These macros are specific to the SPARC, and may be used only
2220    in code for printing assembler insns and in conditions for
2221    define_optimization.  */
2222
2223 /* 1 if X is an fp register.  */
2224
2225 #define FP_REG_P(X) (REG_P (X) && REGNO_OK_FOR_FP_P (REGNO (X)))
2226 \f
2227 /* Maximum number of registers that can appear in a valid memory address.  */
2228
2229 #define MAX_REGS_PER_ADDRESS 2
2230
2231 /* Recognize any constant value that is a valid address.
2232    When PIC, we do not accept an address that would require a scratch reg
2233    to load into a register.  */
2234
2235 #define CONSTANT_ADDRESS_P(X)   \
2236   (GET_CODE (X) == LABEL_REF || GET_CODE (X) == SYMBOL_REF              \
2237    || GET_CODE (X) == CONST_INT || GET_CODE (X) == HIGH                 \
2238    || (GET_CODE (X) == CONST                                            \
2239        && ! (flag_pic && pic_address_needs_scratch (X))))
2240
2241 /* Define this, so that when PIC, reload won't try to reload invalid
2242    addresses which require two reload registers.  */
2243
2244 #define LEGITIMATE_PIC_OPERAND_P(X)  (! pic_address_needs_scratch (X))
2245
2246 /* Nonzero if the constant value X is a legitimate general operand.
2247    Anything can be made to work except floating point constants.  */
2248
2249 #define LEGITIMATE_CONSTANT_P(X) \
2250   (GET_CODE (X) != CONST_DOUBLE || GET_MODE (X) == VOIDmode)
2251
2252 /* The macros REG_OK_FOR..._P assume that the arg is a REG rtx
2253    and check its validity for a certain class.
2254    We have two alternate definitions for each of them.
2255    The usual definition accepts all pseudo regs; the other rejects
2256    them unless they have been allocated suitable hard regs.
2257    The symbol REG_OK_STRICT causes the latter definition to be used.
2258
2259    Most source files want to accept pseudo regs in the hope that
2260    they will get allocated to the class that the insn wants them to be in.
2261    Source files for reload pass need to be strict.
2262    After reload, it makes no difference, since pseudo regs have
2263    been eliminated by then.  */
2264
2265 /* Optional extra constraints for this machine.  Borrowed from romp.h.
2266
2267    For the SPARC, `Q' means that this is a memory operand but not a
2268    symbolic memory operand.  Note that an unassigned pseudo register
2269    is such a memory operand.  Needed because reload will generate
2270    these things in insns and then not re-recognize the insns, causing
2271    constrain_operands to fail.
2272
2273    `S' handles constraints for calls.  ??? So where is it?  */
2274
2275 #ifndef REG_OK_STRICT
2276
2277 /* Nonzero if X is a hard reg that can be used as an index
2278    or if it is a pseudo reg.  */
2279 #define REG_OK_FOR_INDEX_P(X) \
2280   (((unsigned) REGNO (X)) - 32 >= (FIRST_PSEUDO_REGISTER - 32))
2281 /* Nonzero if X is a hard reg that can be used as a base reg
2282    or if it is a pseudo reg.  */
2283 #define REG_OK_FOR_BASE_P(X) \
2284   (((unsigned) REGNO (X)) - 32 >= (FIRST_PSEUDO_REGISTER - 32))
2285
2286 /* 'T', 'U' are for aligned memory loads which aren't needed for v9.  */
2287
2288 #define EXTRA_CONSTRAINT(OP, C)                         \
2289   ((C) == 'Q'                                           \
2290    ? ((GET_CODE (OP) == MEM                             \
2291        && memory_address_p (GET_MODE (OP), XEXP (OP, 0)) \
2292        && ! symbolic_memory_operand (OP, VOIDmode))     \
2293       || (reload_in_progress && GET_CODE (OP) == REG    \
2294           && REGNO (OP) >= FIRST_PSEUDO_REGISTER))      \
2295    : (! TARGET_ARCH64 && (C) == 'T')                    \
2296    ? (mem_aligned_8 (OP))                               \
2297    : (! TARGET_ARCH64 && (C) == 'U')                    \
2298    ? (register_ok_for_ldd (OP))                         \
2299    : 0)
2300  
2301 #else
2302
2303 /* Nonzero if X is a hard reg that can be used as an index.  */
2304 #define REG_OK_FOR_INDEX_P(X) REGNO_OK_FOR_INDEX_P (REGNO (X))
2305 /* Nonzero if X is a hard reg that can be used as a base reg.  */
2306 #define REG_OK_FOR_BASE_P(X) REGNO_OK_FOR_BASE_P (REGNO (X))
2307
2308 #define EXTRA_CONSTRAINT(OP, C)                         \
2309   ((C) == 'Q'                                           \
2310    ? (GET_CODE (OP) == REG                              \
2311       ? (REGNO (OP) >= FIRST_PSEUDO_REGISTER            \
2312          && reg_renumber[REGNO (OP)] < 0)               \
2313       : GET_CODE (OP) == MEM)                           \
2314    : (! TARGET_ARCH64 && (C) == 'T')                    \
2315    ? mem_aligned_8 (OP) && strict_memory_address_p (Pmode, XEXP (OP, 0)) \
2316    : (! TARGET_ARCH64 && (C) == 'U')                    \
2317    ? (GET_CODE (OP) == REG                              \
2318       && (REGNO (OP) < FIRST_PSEUDO_REGISTER            \
2319           || reg_renumber[REGNO (OP)] >= 0)             \
2320       && register_ok_for_ldd (OP))                      \
2321    : 0)
2322 #endif
2323 \f
2324 /* GO_IF_LEGITIMATE_ADDRESS recognizes an RTL expression
2325    that is a valid memory address for an instruction.
2326    The MODE argument is the machine mode for the MEM expression
2327    that wants to use this address.
2328
2329    On SPARC, the actual legitimate addresses must be REG+REG or REG+SMALLINT
2330    ordinarily.  This changes a bit when generating PIC.
2331
2332    If you change this, execute "rm explow.o recog.o reload.o".  */
2333
2334 #define RTX_OK_FOR_BASE_P(X)                                            \
2335   ((GET_CODE (X) == REG && REG_OK_FOR_BASE_P (X))                       \
2336   || (GET_CODE (X) == SUBREG                                            \
2337       && GET_CODE (SUBREG_REG (X)) == REG                               \
2338       && REG_OK_FOR_BASE_P (SUBREG_REG (X))))
2339
2340 #define RTX_OK_FOR_INDEX_P(X)                                           \
2341   ((GET_CODE (X) == REG && REG_OK_FOR_INDEX_P (X))                      \
2342   || (GET_CODE (X) == SUBREG                                            \
2343       && GET_CODE (SUBREG_REG (X)) == REG                               \
2344       && REG_OK_FOR_INDEX_P (SUBREG_REG (X))))
2345
2346 #define RTX_OK_FOR_OFFSET_P(X)                                          \
2347   (GET_CODE (X) == CONST_INT && INTVAL (X) >= -0x1000 && INTVAL (X) < 0x1000)
2348
2349 #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, ADDR)         \
2350 { if (RTX_OK_FOR_BASE_P (X))                            \
2351     goto ADDR;                                          \
2352   else if (GET_CODE (X) == PLUS)                        \
2353     {                                                   \
2354       register rtx op0 = XEXP (X, 0);                   \
2355       register rtx op1 = XEXP (X, 1);                   \
2356       if (flag_pic && op0 == pic_offset_table_rtx)      \
2357         {                                               \
2358           if (RTX_OK_FOR_BASE_P (op1))                  \
2359             goto ADDR;                                  \
2360           else if (flag_pic == 1                        \
2361                    && GET_CODE (op1) != REG             \
2362                    && GET_CODE (op1) != LO_SUM          \
2363                    && GET_CODE (op1) != MEM             \
2364                    && (GET_CODE (op1) != CONST_INT      \
2365                        || SMALL_INT (op1)))             \
2366             goto ADDR;                                  \
2367         }                                               \
2368       else if (RTX_OK_FOR_BASE_P (op0))                 \
2369         {                                               \
2370           if (RTX_OK_FOR_INDEX_P (op1)                  \
2371               || RTX_OK_FOR_OFFSET_P (op1))             \
2372             goto ADDR;                                  \
2373         }                                               \
2374       else if (RTX_OK_FOR_BASE_P (op1))                 \
2375         {                                               \
2376           if (RTX_OK_FOR_INDEX_P (op0)                  \
2377               || RTX_OK_FOR_OFFSET_P (op0))             \
2378             goto ADDR;                                  \
2379         }                                               \
2380     }                                                   \
2381   else if (GET_CODE (X) == LO_SUM)                      \
2382     {                                                   \
2383       register rtx op0 = XEXP (X, 0);                   \
2384       register rtx op1 = XEXP (X, 1);                   \
2385       if (RTX_OK_FOR_BASE_P (op0)                       \
2386           && CONSTANT_P (op1)                           \
2387           /* We can't allow TFmode, because an offset   \
2388              greater than or equal to the alignment (8) \
2389              may cause the LO_SUM to overflow.  */      \
2390           && MODE != TFmode)                            \
2391         goto ADDR;                                      \
2392     }                                                   \
2393   else if (GET_CODE (X) == CONST_INT && SMALL_INT (X))  \
2394     goto ADDR;                                          \
2395 }
2396 \f
2397 /* Try machine-dependent ways of modifying an illegitimate address
2398    to be legitimate.  If we find one, return the new, valid address.
2399    This macro is used in only one place: `memory_address' in explow.c.
2400
2401    OLDX is the address as it was before break_out_memory_refs was called.
2402    In some cases it is useful to look at this to decide what needs to be done.
2403
2404    MODE and WIN are passed so that this macro can use
2405    GO_IF_LEGITIMATE_ADDRESS.
2406
2407    It is always safe for this macro to do nothing.  It exists to recognize
2408    opportunities to optimize the output.  */
2409
2410 /* On SPARC, change REG+N into REG+REG, and REG+(X*Y) into REG+REG.  */
2411 extern struct rtx_def *legitimize_pic_address ();
2412 #define LEGITIMIZE_ADDRESS(X,OLDX,MODE,WIN)     \
2413 { rtx sparc_x = (X);                                            \
2414   if (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 0)) == MULT)   \
2415     (X) = gen_rtx (PLUS, Pmode, XEXP (X, 1),                    \
2416                    force_operand (XEXP (X, 0), NULL_RTX));      \
2417   if (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 1)) == MULT)   \
2418     (X) = gen_rtx (PLUS, Pmode, XEXP (X, 0),                    \
2419                    force_operand (XEXP (X, 1), NULL_RTX));      \
2420   if (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 0)) == PLUS)   \
2421     (X) = gen_rtx (PLUS, Pmode, force_operand (XEXP (X, 0), NULL_RTX),\
2422                    XEXP (X, 1));                                \
2423   if (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 1)) == PLUS)   \
2424     (X) = gen_rtx (PLUS, Pmode, XEXP (X, 0),                    \
2425                    force_operand (XEXP (X, 1), NULL_RTX));      \
2426   if (sparc_x != (X) && memory_address_p (MODE, X))             \
2427     goto WIN;                                                   \
2428   if (flag_pic) (X) = legitimize_pic_address (X, MODE, 0);      \
2429   else if (GET_CODE (X) == PLUS && CONSTANT_ADDRESS_P (XEXP (X, 1)))    \
2430     (X) = gen_rtx (PLUS, Pmode, XEXP (X, 0),                    \
2431                    copy_to_mode_reg (Pmode, XEXP (X, 1)));      \
2432   else if (GET_CODE (X) == PLUS && CONSTANT_ADDRESS_P (XEXP (X, 0)))    \
2433     (X) = gen_rtx (PLUS, Pmode, XEXP (X, 1),                    \
2434                    copy_to_mode_reg (Pmode, XEXP (X, 0)));      \
2435   else if (GET_CODE (X) == SYMBOL_REF || GET_CODE (X) == CONST  \
2436            || GET_CODE (X) == LABEL_REF)                        \
2437     (X) = gen_rtx (LO_SUM, Pmode,                               \
2438                    copy_to_mode_reg (Pmode, gen_rtx (HIGH, Pmode, X)), X); \
2439   if (memory_address_p (MODE, X))                               \
2440     goto WIN; }
2441
2442 /* Go to LABEL if ADDR (a legitimate address expression)
2443    has an effect that depends on the machine mode it is used for.
2444    On the SPARC this is never true.  */
2445
2446 #define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR,LABEL)
2447
2448 /* If we are referencing a function make the SYMBOL_REF special.
2449    In the Embedded Medium/Anywhere code model, %g4 points to the data segment
2450    so we must not add it to function addresses.  */
2451
2452 #define ENCODE_SECTION_INFO(DECL) \
2453   do {                                                  \
2454     if (TARGET_CM_EMBMEDANY && TREE_CODE (DECL) == FUNCTION_DECL) \
2455       SYMBOL_REF_FLAG (XEXP (DECL_RTL (DECL), 0)) = 1;  \
2456   } while (0)
2457 \f
2458 /* Specify the machine mode that this machine uses
2459    for the index in the tablejump instruction.  */
2460 #define CASE_VECTOR_MODE Pmode
2461
2462 /* Define this if the tablejump instruction expects the table
2463    to contain offsets from the address of the table.
2464    Do not define this if the table should contain absolute addresses.  */
2465 /* #define CASE_VECTOR_PC_RELATIVE */
2466
2467 /* Specify the tree operation to be used to convert reals to integers.  */
2468 #define IMPLICIT_FIX_EXPR FIX_ROUND_EXPR
2469
2470 /* This is the kind of divide that is easiest to do in the general case.  */
2471 #define EASY_DIV_EXPR TRUNC_DIV_EXPR
2472
2473 /* Define this as 1 if `char' should by default be signed; else as 0.  */
2474 #define DEFAULT_SIGNED_CHAR 1
2475
2476 /* Max number of bytes we can move from memory to memory
2477    in one reasonably fast instruction.  */
2478 #define MOVE_MAX 8
2479
2480 #if 0 /* Sun 4 has matherr, so this is no good.  */
2481 /* This is the value of the error code EDOM for this machine,
2482    used by the sqrt instruction.  */
2483 #define TARGET_EDOM 33
2484
2485 /* This is how to refer to the variable errno.  */
2486 #define GEN_ERRNO_RTX \
2487   gen_rtx (MEM, SImode, gen_rtx (SYMBOL_REF, Pmode, "errno"))
2488 #endif /* 0 */
2489
2490 /* Define if operations between registers always perform the operation
2491    on the full register even if a narrower mode is specified.  */
2492 #define WORD_REGISTER_OPERATIONS
2493
2494 /* Define if loading in MODE, an integral mode narrower than BITS_PER_WORD
2495    will either zero-extend or sign-extend.  The value of this macro should
2496    be the code that says which one of the two operations is implicitly
2497    done, NIL if none.  */
2498 #define LOAD_EXTEND_OP(MODE) ZERO_EXTEND
2499
2500 /* Nonzero if access to memory by bytes is slow and undesirable.
2501    For RISC chips, it means that access to memory by bytes is no
2502    better than access by words when possible, so grab a whole word
2503    and maybe make use of that.  */
2504 #define SLOW_BYTE_ACCESS 1
2505
2506 /* We assume that the store-condition-codes instructions store 0 for false
2507    and some other value for true.  This is the value stored for true.  */
2508
2509 #define STORE_FLAG_VALUE 1
2510
2511 /* When a prototype says `char' or `short', really pass an `int'.  */
2512 #define PROMOTE_PROTOTYPES
2513
2514 /* Define this to be nonzero if shift instructions ignore all but the low-order
2515    few bits. */
2516 #define SHIFT_COUNT_TRUNCATED 1
2517
2518 /* Value is 1 if truncating an integer of INPREC bits to OUTPREC bits
2519    is done just by pretending it is already truncated.  */
2520 #define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1
2521
2522 /* Specify the machine mode that pointers have.
2523    After generation of rtl, the compiler makes no further distinction
2524    between pointers and any other objects of this machine mode.  */
2525 #define Pmode (TARGET_PTR64 ? DImode : SImode)
2526
2527 /* Generate calls to memcpy, memcmp and memset.  */
2528 #define TARGET_MEM_FUNCTIONS
2529
2530 /* Add any extra modes needed to represent the condition code.
2531
2532    On the Sparc, we have a "no-overflow" mode which is used when an add or
2533    subtract insn is used to set the condition code.  Different branches are
2534    used in this case for some operations.
2535
2536    We also have two modes to indicate that the relevant condition code is
2537    in the floating-point condition code register.  One for comparisons which
2538    will generate an exception if the result is unordered (CCFPEmode) and
2539    one for comparisons which will never trap (CCFPmode).
2540
2541    CCXmode and CCX_NOOVmode are only used by v9.  */
2542
2543 #define EXTRA_CC_MODES CCXmode, CC_NOOVmode, CCX_NOOVmode, CCFPmode, CCFPEmode
2544
2545 /* Define the names for the modes specified above.  */
2546
2547 #define EXTRA_CC_NAMES "CCX", "CC_NOOV", "CCX_NOOV", "CCFP", "CCFPE"
2548
2549 /* Given a comparison code (EQ, NE, etc.) and the first operand of a COMPARE,
2550    return the mode to be used for the comparison.  For floating-point,
2551    CCFP[E]mode is used.  CC_NOOVmode should be used when the first operand is a
2552    PLUS, MINUS, NEG, or ASHIFT.  CCmode should be used when no special
2553    processing is needed.  */
2554 #define SELECT_CC_MODE(OP,X,Y) \
2555   (GET_MODE_CLASS (GET_MODE (X)) == MODE_FLOAT                          \
2556    ? ((OP == EQ || OP == NE) ? CCFPmode : CCFPEmode)                    \
2557    : ((GET_CODE (X) == PLUS || GET_CODE (X) == MINUS                    \
2558        || GET_CODE (X) == NEG || GET_CODE (X) == ASHIFT)                \
2559       ? (TARGET_ARCH64 && GET_MODE (X) == DImode ? CCX_NOOVmode : CC_NOOVmode) \
2560       : (TARGET_ARCH64 && GET_MODE (X) == DImode ? CCXmode : CCmode)))
2561
2562 /* Return non-zero if SELECT_CC_MODE will never return MODE for a
2563    floating point inequality comparison.  */
2564
2565 #define REVERSIBLE_CC_MODE(MODE) ((MODE) != CCFPEmode)
2566
2567 /* A function address in a call instruction
2568    is a byte address (for indexing purposes)
2569    so give the MEM rtx a byte's mode.  */
2570 #define FUNCTION_MODE SImode
2571
2572 /* Define this if addresses of constant functions
2573    shouldn't be put through pseudo regs where they can be cse'd.
2574    Desirable on machines where ordinary constants are expensive
2575    but a CALL with constant address is cheap.  */
2576 #define NO_FUNCTION_CSE
2577
2578 /* alloca should avoid clobbering the old register save area.  */
2579 #define SETJMP_VIA_SAVE_AREA
2580
2581 /* Define subroutines to call to handle multiply and divide.
2582    Use the subroutines that Sun's library provides.
2583    The `*' prevents an underscore from being prepended by the compiler.  */
2584
2585 #define DIVSI3_LIBCALL "*.div"
2586 #define UDIVSI3_LIBCALL "*.udiv"
2587 #define MODSI3_LIBCALL "*.rem"
2588 #define UMODSI3_LIBCALL "*.urem"
2589 /* .umul is a little faster than .mul.  */
2590 #define MULSI3_LIBCALL "*.umul"
2591
2592 /* Define library calls for quad FP operations.  These are all part of the
2593    SPARC ABI.  */
2594 #define ADDTF3_LIBCALL "_Q_add"
2595 #define SUBTF3_LIBCALL "_Q_sub"
2596 #define NEGTF2_LIBCALL "_Q_neg"
2597 #define MULTF3_LIBCALL "_Q_mul"
2598 #define DIVTF3_LIBCALL "_Q_div"
2599 #define FLOATSITF2_LIBCALL "_Q_itoq"
2600 #define FIX_TRUNCTFSI2_LIBCALL "_Q_qtoi"
2601 #define FIXUNS_TRUNCTFSI2_LIBCALL "_Q_qtou"
2602 #define EXTENDSFTF2_LIBCALL "_Q_stoq"
2603 #define TRUNCTFSF2_LIBCALL "_Q_qtos"
2604 #define EXTENDDFTF2_LIBCALL "_Q_dtoq"
2605 #define TRUNCTFDF2_LIBCALL "_Q_qtod"
2606 #define EQTF2_LIBCALL "_Q_feq"
2607 #define NETF2_LIBCALL "_Q_fne"
2608 #define GTTF2_LIBCALL "_Q_fgt"
2609 #define GETF2_LIBCALL "_Q_fge"
2610 #define LTTF2_LIBCALL "_Q_flt"
2611 #define LETF2_LIBCALL "_Q_fle"
2612
2613 /* We can define the TFmode sqrt optab only if TARGET_FPU.  This is because
2614    with soft-float, the SFmode and DFmode sqrt instructions will be absent,
2615    and the compiler will notice and try to use the TFmode sqrt instruction
2616    for calls to the builtin function sqrt, but this fails.  */
2617 #define INIT_TARGET_OPTABS                                              \
2618   do {                                                                  \
2619     add_optab->handlers[(int) TFmode].libfunc                           \
2620       = gen_rtx (SYMBOL_REF, Pmode, ADDTF3_LIBCALL);                    \
2621     sub_optab->handlers[(int) TFmode].libfunc                           \
2622       = gen_rtx (SYMBOL_REF, Pmode, SUBTF3_LIBCALL);                    \
2623     neg_optab->handlers[(int) TFmode].libfunc                           \
2624       = gen_rtx (SYMBOL_REF, Pmode, NEGTF2_LIBCALL);                    \
2625     smul_optab->handlers[(int) TFmode].libfunc                          \
2626       = gen_rtx (SYMBOL_REF, Pmode, MULTF3_LIBCALL);                    \
2627     flodiv_optab->handlers[(int) TFmode].libfunc                        \
2628       = gen_rtx (SYMBOL_REF, Pmode, DIVTF3_LIBCALL);                    \
2629     eqtf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, EQTF2_LIBCALL);         \
2630     netf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, NETF2_LIBCALL);         \
2631     gttf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, GTTF2_LIBCALL);         \
2632     getf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, GETF2_LIBCALL);         \
2633     lttf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, LTTF2_LIBCALL);         \
2634     letf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, LETF2_LIBCALL);         \
2635     trunctfsf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, TRUNCTFSF2_LIBCALL);   \
2636     trunctfdf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, TRUNCTFDF2_LIBCALL);   \
2637     extendsftf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, EXTENDSFTF2_LIBCALL); \
2638     extenddftf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, EXTENDDFTF2_LIBCALL); \
2639     floatsitf_libfunc = gen_rtx (SYMBOL_REF, Pmode, FLOATSITF2_LIBCALL);    \
2640     fixtfsi_libfunc = gen_rtx (SYMBOL_REF, Pmode, FIX_TRUNCTFSI2_LIBCALL);  \
2641     fixunstfsi_libfunc                                                  \
2642       = gen_rtx (SYMBOL_REF, Pmode, FIXUNS_TRUNCTFSI2_LIBCALL);         \
2643     if (TARGET_FPU)                                                     \
2644       sqrt_optab->handlers[(int) TFmode].libfunc                        \
2645         = gen_rtx (SYMBOL_REF, Pmode, "_Q_sqrt");                       \
2646     INIT_SUBTARGET_OPTABS;                                              \
2647   } while (0)
2648
2649 /* This is meant to be redefined in the host dependent files */
2650 #define INIT_SUBTARGET_OPTABS
2651
2652 /* Compute the cost of computing a constant rtl expression RTX
2653    whose rtx-code is CODE.  The body of this macro is a portion
2654    of a switch statement.  If the code is computed here,
2655    return it with a return statement.  Otherwise, break from the switch.  */
2656
2657 #define CONST_COSTS(RTX,CODE,OUTER_CODE) \
2658   case CONST_INT:                                               \
2659     if (INTVAL (RTX) < 0x1000 && INTVAL (RTX) >= -0x1000)       \
2660       return 0;                                                 \
2661   case HIGH:                                                    \
2662     return 2;                                                   \
2663   case CONST:                                                   \
2664   case LABEL_REF:                                               \
2665   case SYMBOL_REF:                                              \
2666     return 4;                                                   \
2667   case CONST_DOUBLE:                                            \
2668     if (GET_MODE (RTX) == DImode)                               \
2669       if ((XINT (RTX, 3) == 0                                   \
2670            && (unsigned) XINT (RTX, 2) < 0x1000)                \
2671           || (XINT (RTX, 3) == -1                               \
2672               && XINT (RTX, 2) < 0                              \
2673               && XINT (RTX, 2) >= -0x1000))                     \
2674         return 0;                                               \
2675     return 8;
2676
2677 /* Compute the cost of an address.  For the sparc, all valid addresses are
2678    the same cost.  */
2679
2680 #define ADDRESS_COST(RTX)  1
2681
2682 /* Compute extra cost of moving data between one register class
2683    and another.
2684    ??? v9: We ignore FPCC_REGS on the assumption they'll never be seen.  */
2685 #define REGISTER_MOVE_COST(CLASS1, CLASS2) \
2686   (((FP_REG_CLASS_P (CLASS1) && (CLASS2) == GENERAL_REGS) \
2687     || ((CLASS1) == GENERAL_REGS && FP_REG_CLASS_P (CLASS2))) ? 6 : 2)
2688
2689 /* Provide the costs of a rtl expression.  This is in the body of a
2690    switch on CODE.  The purpose for the cost of MULT is to encourage
2691    `synth_mult' to find a synthetic multiply when reasonable.
2692
2693    If we need more than 12 insns to do a multiply, then go out-of-line,
2694    since the call overhead will be < 10% of the cost of the multiply.  */
2695
2696 #define RTX_COSTS(X,CODE,OUTER_CODE)                    \
2697   case MULT:                                            \
2698     return (TARGET_V8 || TARGET_SPARCLITE)              \
2699         ? COSTS_N_INSNS (5) : COSTS_N_INSNS (25);       \
2700   case DIV:                                             \
2701   case UDIV:                                            \
2702   case MOD:                                             \
2703   case UMOD:                                            \
2704     return COSTS_N_INSNS (25);                          \
2705   /* Make FLOAT and FIX more expensive than CONST_DOUBLE,\
2706      so that cse will favor the latter.  */             \
2707   case FLOAT:                                           \
2708   case FIX:                                             \
2709     return 19;
2710
2711 /* Adjust the cost of dependencies.  */
2712 #define ADJUST_COST(INSN,LINK,DEP,COST) \
2713   if (sparc_cpu == PROCESSOR_SUPERSPARC) \
2714     (COST) = supersparc_adjust_cost (INSN, LINK, DEP, COST)
2715
2716 /* Conditional branches with empty delay slots have a length of two.  */
2717 #define ADJUST_INSN_LENGTH(INSN, LENGTH)        \
2718   if (GET_CODE (INSN) == CALL_INSN                                      \
2719       || (GET_CODE (INSN) == JUMP_INSN && ! simplejump_p (insn)))       \
2720     LENGTH += 1;
2721 \f
2722 /* Control the assembler format that we output.  */
2723
2724 /* Output at beginning of assembler file.  */
2725
2726 #define ASM_FILE_START(file)
2727
2728 /* A C string constant describing how to begin a comment in the target
2729    assembler language.  The compiler assumes that the comment will end at
2730    the end of the line.  */
2731
2732 #define ASM_COMMENT_START "!"
2733
2734 /* Output to assembler file text saying following lines
2735    may contain character constants, extra white space, comments, etc.  */
2736
2737 #define ASM_APP_ON ""
2738
2739 /* Output to assembler file text saying following lines
2740    no longer contain unusual constructs.  */
2741
2742 #define ASM_APP_OFF ""
2743
2744 /* ??? Try to make the style consistent here (_OP?).  */
2745
2746 #define ASM_LONGLONG    ".xword"
2747 #define ASM_LONG        ".word"
2748 #define ASM_SHORT       ".half"
2749 #define ASM_BYTE_OP     ".byte"
2750 #define ASM_FLOAT       ".single"
2751 #define ASM_DOUBLE      ".double"
2752 #define ASM_LONGDOUBLE  ".xxx"          /* ??? Not known (or used yet). */
2753
2754 /* Output before read-only data.  */
2755
2756 #define TEXT_SECTION_ASM_OP ".text"
2757
2758 /* Output before writable data.  */
2759
2760 #define DATA_SECTION_ASM_OP ".data"
2761
2762 /* How to refer to registers in assembler output.
2763    This sequence is indexed by compiler's hard-register-number (see above).  */
2764
2765 #define REGISTER_NAMES \
2766 {"%g0", "%g1", "%g2", "%g3", "%g4", "%g5", "%g6", "%g7",                \
2767  "%o0", "%o1", "%o2", "%o3", "%o4", "%o5", "%sp", "%o7",                \
2768  "%l0", "%l1", "%l2", "%l3", "%l4", "%l5", "%l6", "%l7",                \
2769  "%i0", "%i1", "%i2", "%i3", "%i4", "%i5", "%fp", "%i7",                \
2770  "%f0", "%f1", "%f2", "%f3", "%f4", "%f5", "%f6", "%f7",                \
2771  "%f8", "%f9", "%f10", "%f11", "%f12", "%f13", "%f14", "%f15",          \
2772  "%f16", "%f17", "%f18", "%f19", "%f20", "%f21", "%f22", "%f23",        \
2773  "%f24", "%f25", "%f26", "%f27", "%f28", "%f29", "%f30", "%f31",        \
2774  "%f32", "%f33", "%f34", "%f35", "%f36", "%f37", "%f38", "%f39",        \
2775  "%f40", "%f41", "%f42", "%f43", "%f44", "%f45", "%f46", "%f47",        \
2776  "%f48", "%f49", "%f50", "%f51", "%f52", "%f53", "%f54", "%f55",        \
2777  "%f56", "%f57", "%f58", "%f59", "%f60", "%f61", "%f62", "%f63",        \
2778  "%fcc0", "%fcc1", "%fcc2", "%fcc3", "%icc"}
2779
2780 /* Define additional names for use in asm clobbers and asm declarations.  */
2781
2782 #define ADDITIONAL_REGISTER_NAMES \
2783 {{"ccr", SPARC_ICC_REG}, {"cc", SPARC_ICC_REG}}
2784
2785 /* How to renumber registers for dbx and gdb.  In the flat model, the frame
2786    pointer is really %i7.  */
2787
2788 #define DBX_REGISTER_NUMBER(REGNO) \
2789   (TARGET_FLAT && REGNO == FRAME_POINTER_REGNUM ? 31 : REGNO)
2790
2791 /* On Sun 4, this limit is 2048.  We use 1000 to be safe, since the length
2792    can run past this up to a continuation point.  Once we used 1500, but
2793    a single entry in C++ can run more than 500 bytes, due to the length of
2794    mangled symbol names.  dbxout.c should really be fixed to do
2795    continuations when they are actually needed instead of trying to
2796    guess...  */
2797 #define DBX_CONTIN_LENGTH 1000
2798
2799 /* This is how to output a note to DBX telling it the line number
2800    to which the following sequence of instructions corresponds.
2801
2802    This is needed for SunOS 4.0, and should not hurt for 3.2
2803    versions either.  */
2804 #define ASM_OUTPUT_SOURCE_LINE(file, line)              \
2805   { static int sym_lineno = 1;                          \
2806     fprintf (file, ".stabn 68,0,%d,LM%d\nLM%d:\n",      \
2807              line, sym_lineno, sym_lineno);             \
2808     sym_lineno += 1; }
2809
2810 /* This is how to output the definition of a user-level label named NAME,
2811    such as the label on a static function or variable NAME.  */
2812
2813 #define ASM_OUTPUT_LABEL(FILE,NAME)     \
2814   do { assemble_name (FILE, NAME); fputs (":\n", FILE); } while (0)
2815
2816 /* This is how to output a command to make the user-level label named NAME
2817    defined for reference from other files.  */
2818
2819 #define ASM_GLOBALIZE_LABEL(FILE,NAME)  \
2820   do { fputs ("\t.global ", FILE); assemble_name (FILE, NAME); fputs ("\n", FILE);} while (0)
2821
2822 /* The prefix to add to user-visible assembler symbols. */
2823
2824 #define USER_LABEL_PREFIX "_"
2825
2826 /* This is how to output a definition of an internal numbered label where
2827    PREFIX is the class of label and NUM is the number within the class.  */
2828
2829 #define ASM_OUTPUT_INTERNAL_LABEL(FILE,PREFIX,NUM)      \
2830   fprintf (FILE, "%s%d:\n", PREFIX, NUM)
2831
2832 /* This is how to store into the string LABEL
2833    the symbol_ref name of an internal numbered label where
2834    PREFIX is the class of label and NUM is the number within the class.
2835    This is suitable for output with `assemble_name'.  */
2836
2837 #define ASM_GENERATE_INTERNAL_LABEL(LABEL,PREFIX,NUM)   \
2838   sprintf (LABEL, "*%s%d", PREFIX, NUM)
2839
2840 /* This is how to output an assembler line defining a `float' constant.
2841    We always have to use a .long pseudo-op to do this because the native
2842    SVR4 ELF assembler is buggy and it generates incorrect values when we
2843    try to use the .float pseudo-op instead.  */
2844
2845 #define ASM_OUTPUT_FLOAT(FILE,VALUE) \
2846   {                                                             \
2847     long t;                                                     \
2848     char str[30];                                               \
2849     REAL_VALUE_TO_TARGET_SINGLE ((VALUE), t);                   \
2850     REAL_VALUE_TO_DECIMAL ((VALUE), "%.20e", str);              \
2851     fprintf (FILE, "\t%s\t0x%lx %s ~%s\n", ASM_LONG, t,         \
2852              ASM_COMMENT_START, str);                           \
2853   }                                                             \
2854
2855 /* This is how to output an assembler line defining a `double' constant.
2856    We always have to use a .long pseudo-op to do this because the native
2857    SVR4 ELF assembler is buggy and it generates incorrect values when we
2858    try to use the .float pseudo-op instead.  */
2859
2860 #define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
2861   {                                                             \
2862     long t[2];                                                  \
2863     char str[30];                                               \
2864     REAL_VALUE_TO_TARGET_DOUBLE ((VALUE), t);                   \
2865     REAL_VALUE_TO_DECIMAL ((VALUE), "%.20e", str);              \
2866     fprintf (FILE, "\t%s\t0x%lx %s ~%s\n", ASM_LONG, t[0],      \
2867              ASM_COMMENT_START, str);                           \
2868     fprintf (FILE, "\t%s\t0x%lx\n", ASM_LONG, t[1]);            \
2869   }
2870
2871 /* This is how to output an assembler line defining a `long double'
2872    constant.  */
2873
2874 #define ASM_OUTPUT_LONG_DOUBLE(FILE,VALUE) \
2875   {                                                             \
2876     long t[4];                                                  \
2877     char str[30];                                               \
2878     REAL_VALUE_TO_TARGET_LONG_DOUBLE ((VALUE), t);              \
2879     REAL_VALUE_TO_DECIMAL ((VALUE), "%.20e", str);              \
2880     fprintf (FILE, "\t%s\t0x%lx %s ~%s\n", ASM_LONG, t[0],      \
2881              ASM_COMMENT_START, str);                           \
2882     fprintf (FILE, "\t%s\t0x%lx\n", ASM_LONG, t[1]);            \
2883     fprintf (FILE, "\t%s\t0x%lx\n", ASM_LONG, t[2]);            \
2884     fprintf (FILE, "\t%s\t0x%lx\n", ASM_LONG, t[3]);            \
2885   }
2886
2887 /* This is how to output an assembler line defining an `int' constant.  */
2888
2889 #define ASM_OUTPUT_INT(FILE,VALUE)  \
2890 ( fprintf (FILE, "\t%s\t", ASM_LONG),           \
2891   output_addr_const (FILE, (VALUE)),            \
2892   fprintf (FILE, "\n"))
2893
2894 /* This is how to output an assembler line defining a DImode constant.  */
2895 #define ASM_OUTPUT_DOUBLE_INT(FILE,VALUE)  \
2896   output_double_int (FILE, VALUE)
2897
2898 /* Likewise for `char' and `short' constants.  */
2899
2900 #define ASM_OUTPUT_SHORT(FILE,VALUE)  \
2901 ( fprintf (FILE, "\t%s\t", ASM_SHORT),          \
2902   output_addr_const (FILE, (VALUE)),            \
2903   fprintf (FILE, "\n"))
2904
2905 #define ASM_OUTPUT_CHAR(FILE,VALUE)  \
2906 ( fprintf (FILE, "\t%s\t", ASM_BYTE_OP),        \
2907   output_addr_const (FILE, (VALUE)),            \
2908   fprintf (FILE, "\n"))
2909
2910 /* This is how to output an assembler line for a numeric constant byte.  */
2911
2912 #define ASM_OUTPUT_BYTE(FILE,VALUE)  \
2913   fprintf (FILE, "\t%s\t0x%x\n", ASM_BYTE_OP, (VALUE))
2914
2915 /* This is how to output an element of a case-vector that is absolute.  */
2916
2917 #define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE)  \
2918 do {                                                                    \
2919   char label[30];                                                       \
2920   ASM_GENERATE_INTERNAL_LABEL (label, "L", VALUE);                      \
2921   if (Pmode == SImode)                                                  \
2922     fprintf (FILE, "\t.word\t");                                        \
2923   else if (TARGET_CM_MEDLOW)                                            \
2924     fprintf (FILE, "\t.word\t0\n\t.word\t");                            \
2925   else                                                                  \
2926     fprintf (FILE, "\t.xword\t");                                       \
2927   assemble_name (FILE, label);                                          \
2928   fprintf (FILE, "\n");                                                 \
2929 } while (0)
2930
2931 /* This is how to output an element of a case-vector that is relative.
2932    (SPARC uses such vectors only when generating PIC.)  */
2933
2934 #define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, VALUE, REL)                      \
2935 do {                                                                    \
2936   char label[30];                                                       \
2937   ASM_GENERATE_INTERNAL_LABEL (label, "L", VALUE);                      \
2938   if (Pmode == SImode)                                                  \
2939     fprintf (FILE, "\t.word\t");                                        \
2940   else if (TARGET_CM_MEDLOW)                                            \
2941     fprintf (FILE, "\t.word\t0\n\t.word\t");                            \
2942   else                                                                  \
2943     fprintf (FILE, "\t.xword\t");                                       \
2944   assemble_name (FILE, label);                                          \
2945   fprintf (FILE, "-1b\n");                                              \
2946 } while (0)
2947
2948 /* This is how to output an assembler line
2949    that says to advance the location counter
2950    to a multiple of 2**LOG bytes.  */
2951
2952 #define ASM_OUTPUT_ALIGN(FILE,LOG)      \
2953   if ((LOG) != 0)                       \
2954     fprintf (FILE, "\t.align %d\n", (1<<(LOG)))
2955
2956 #define ASM_OUTPUT_ALIGN_CODE(FILE) \
2957   ASM_OUTPUT_ALIGN (FILE, sparc_align_jumps)
2958
2959 #define ASM_OUTPUT_LOOP_ALIGN(FILE) \
2960   ASM_OUTPUT_ALIGN (FILE, sparc_align_loops)
2961
2962 #define ASM_OUTPUT_SKIP(FILE,SIZE)  \
2963   fprintf (FILE, "\t.skip %u\n", (SIZE))
2964
2965 /* This says how to output an assembler line
2966    to define a global common symbol.  */
2967
2968 #define ASM_OUTPUT_COMMON(FILE, NAME, SIZE, ROUNDED)  \
2969 ( fputs ("\t.common ", (FILE)),         \
2970   assemble_name ((FILE), (NAME)),               \
2971   fprintf ((FILE), ",%u,\"bss\"\n", (SIZE)))
2972
2973 /* This says how to output an assembler line to define a local common
2974    symbol.  */
2975
2976 #define ASM_OUTPUT_ALIGNED_LOCAL(FILE, NAME, SIZE, ALIGNED)             \
2977 ( fputs ("\t.reserve ", (FILE)),                                        \
2978   assemble_name ((FILE), (NAME)),                                       \
2979   fprintf ((FILE), ",%u,\"bss\",%u\n",                                  \
2980            (SIZE), ((ALIGNED) / BITS_PER_UNIT)))
2981
2982 /* A C statement (sans semicolon) to output to the stdio stream
2983    FILE the assembler definition of uninitialized global DECL named
2984    NAME whose size is SIZE bytes and alignment is ALIGN bytes.
2985    Try to use asm_output_aligned_bss to implement this macro.  */
2986
2987 #define ASM_OUTPUT_ALIGNED_BSS(FILE, DECL, NAME, SIZE, ALIGN)   \
2988   do {                                                          \
2989     fputs (".globl ", (FILE));                                  \
2990     assemble_name ((FILE), (NAME));                             \
2991     fputs ("\n", (FILE));                                       \
2992     ASM_OUTPUT_ALIGNED_LOCAL (FILE, NAME, SIZE, ALIGN);         \
2993   } while (0)
2994
2995 /* Store in OUTPUT a string (made with alloca) containing
2996    an assembler-name for a local static variable named NAME.
2997    LABELNO is an integer which is different for each call.  */
2998
2999 #define ASM_FORMAT_PRIVATE_NAME(OUTPUT, NAME, LABELNO)  \
3000 ( (OUTPUT) = (char *) alloca (strlen ((NAME)) + 10),    \
3001   sprintf ((OUTPUT), "%s.%d", (NAME), (LABELNO)))
3002
3003 #define IDENT_ASM_OP ".ident"
3004
3005 /* Output #ident as a .ident.  */
3006
3007 #define ASM_OUTPUT_IDENT(FILE, NAME) \
3008   fprintf (FILE, "\t%s\t\"%s\"\n", IDENT_ASM_OP, NAME);
3009
3010 /* Output code to add DELTA to the first argument, and then jump to FUNCTION.
3011    Used for C++ multiple inheritance.  */
3012 #define ASM_OUTPUT_MI_THUNK(FILE, THUNK_FNDECL, DELTA, FUNCTION)        \
3013 do {                                                                    \
3014   int big_delta = (DELTA) >= 4096 || (DELTA) < -4096;                   \
3015   if (big_delta)                                                        \
3016     fprintf (FILE, "\tset %d,%%g1\n\tadd %%o0,%%g1,%%o0\n", (DELTA));   \
3017   if (flag_pic)                                                         \
3018     {                                                                   \
3019       if (! big_delta)                                                  \
3020         fprintf (FILE, "\tadd %%o0,%d,%%o0\n", DELTA);                  \
3021       fprintf (FILE, "\tsave %%sp,-112,%%sp\n");                        \
3022       fprintf (FILE, "\tcall ");                                        \
3023       assemble_name                                                     \
3024         (FILE, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (FUNCTION)));    \
3025       fprintf (FILE, ",0\n");                                           \
3026     }                                                                   \
3027   else if (TARGET_CM_EMBMEDANY)                                         \
3028     {                                                                   \
3029       fprintf (FILE, "\tsetx ");                                        \
3030       assemble_name                                                     \
3031         (FILE, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (FUNCTION)));    \
3032       fprintf (FILE, ",%%g5,%%g1\n\tjmp %%g1\n");                       \
3033     }                                                                   \
3034   else                                                                  \
3035     {                                                                   \
3036       fprintf (FILE, "\tsethi %%hi(");                                  \
3037       assemble_name                                                     \
3038         (FILE, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (FUNCTION)));    \
3039       fprintf (FILE, "),%%g1\n\tjmp %%g1+%%lo(");                       \
3040       assemble_name                                                     \
3041         (FILE, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (FUNCTION)));    \
3042       fprintf (FILE, ")\n");                                            \
3043     }                                                                   \
3044   if (big_delta)                                                        \
3045     fprintf (FILE, "\tnop\n");                                          \
3046   else if (flag_pic)                                                    \
3047     fprintf (FILE, "\trestore\n");                                      \
3048   else                                                                  \
3049     fprintf (FILE, "\tadd %%o0,%d,%%o0\n", DELTA);                      \
3050 } while (0)
3051
3052 /* Define the parentheses used to group arithmetic operations
3053    in assembler code.  */
3054
3055 #define ASM_OPEN_PAREN "("
3056 #define ASM_CLOSE_PAREN ")"
3057
3058 /* Define results of standard character escape sequences.  */
3059 #define TARGET_BELL 007
3060 #define TARGET_BS 010
3061 #define TARGET_TAB 011
3062 #define TARGET_NEWLINE 012
3063 #define TARGET_VT 013
3064 #define TARGET_FF 014
3065 #define TARGET_CR 015
3066
3067 #define PRINT_OPERAND_PUNCT_VALID_P(CHAR) \
3068   ((CHAR) == '#' || (CHAR) == '*' || (CHAR) == '^' || (CHAR) == '(' || (CHAR) == '_')
3069
3070 /* Print operand X (an rtx) in assembler syntax to file FILE.
3071    CODE is a letter or dot (`z' in `%z0') or 0 if no letter was specified.
3072    For `%' followed by punctuation, CODE is the punctuation and X is null.  */
3073
3074 #define PRINT_OPERAND(FILE, X, CODE) print_operand (FILE, X, CODE)
3075
3076 /* Print a memory address as an operand to reference that memory location.  */
3077
3078 #define PRINT_OPERAND_ADDRESS(FILE, ADDR)  \
3079 { register rtx base, index = 0;                                 \
3080   int offset = 0;                                               \
3081   register rtx addr = ADDR;                                     \
3082   if (GET_CODE (addr) == REG)                                   \
3083     fputs (reg_names[REGNO (addr)], FILE);                      \
3084   else if (GET_CODE (addr) == PLUS)                             \
3085     {                                                         &nbs