OSDN Git Service

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