?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* expr.c (do_tablejump): Let CASE_VECTOR_PC_RELATIVE be an
[official-gcc.git] / gcc / config / i370 / i370.h
blob28279b24dfaf3105b5febd58a337d2a0c3b681f1
1 /* Definitions of target machine for GNU compiler. System/370 version.
2 Copyright (C) 1989, 1993, 1995, 1996, 1997 Free Software Foundation, Inc.
3 Contributed by Jan Stein (jan@cd.chalmers.se).
4 Modified for C/370 MVS by Dave Pitts (dpitts@nyx.cs.du.edu)
5
6 This file is part of GNU CC.
7
8 GNU CC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
11 any later version.
12
13 GNU CC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GNU CC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
22
23 #define TARGET_VERSION printf (" (370/MVS)");
24
25 /* Options for the preprocessor for this target machine. */
26
27 #define CPP_SPEC "-trigraphs"
28
29 /* Names to predefine in the preprocessor for this target machine. */
30
31 #define CPP_PREDEFINES "-DGCC -Dgcc -DMVS -Dmvs -Asystem(mvs) -Acpu(i370) -Amachine(i370)"
32
33 /* Run-time compilation parameters selecting different hardware subsets. */
34
35 extern int target_flags;
36
37 /* The sizes of the code and literals on the current page. */
38
39 extern int mvs_page_code, mvs_page_lit;
40
41 /* The current page number and the base page number for the function. */
42
43 extern int mvs_page_num, function_base_page;
44
45 /* True if a label has been emitted. */
46
47 extern int mvs_label_emitted;
48
49 /* The name of the current function. */
50
51 extern char *mvs_function_name;
52
53 /* The length of the function name malloc'd area. */
54
55 extern int mvs_function_name_length;
56
57 /* The amount of space used for outgoing arguments. */
58
59 extern int current_function_outgoing_args_size;
60
61 /* Compile using char instructions (mvc, nc, oc, xc). On 4341 use this since
62 these are more than twice as fast as load-op-store.
63 On 3090 don't use this since load-op-store is much faster. */
64
65 #define TARGET_CHAR_INSTRUCTIONS (target_flags & 1)
66
67 /* Default target switches */
68
69 #define TARGET_DEFAULT 1
70
71 /* Macro to define tables used to set the flags. This is a list in braces
72 of pairs in braces, each pair being { "NAME", VALUE }
73 where VALUE is the bits to set or minus the bits to clear.
74 An empty string NAME is used to identify the default VALUE. */
75
76 #define TARGET_SWITCHES \
77 { { "char-instructions", 1}, \
78 { "no-char-instructions", -1}, \
79 { "", TARGET_DEFAULT} }
80
81 /* To use IBM supplied macro function prologue and epilogue, define the
82 following to 1. Should only be needed if IBM changes the definition
83 of their prologue and epilogue. */
84
85 #define MACROPROLOGUE 0
86 #define MACROEPILOGUE 0
87
88 /* Target machine storage layout */
89
90 /* Define this if most significant bit is lowest numbered in instructions
91 that operate on numbered bit-fields. */
92
93 #define BITS_BIG_ENDIAN 1
94
95 /* Define this if most significant byte of a word is the lowest numbered. */
96
97 #define BYTES_BIG_ENDIAN 1
98
99 /* Define this if MS word of a multiword is the lowest numbered. */
100
101 #define WORDS_BIG_ENDIAN 1
102
103 /* Number of bits in an addressable storage unit. */
104
105 #define BITS_PER_UNIT 8
106
107 /* Width in bits of a "word", which is the contents of a machine register. */
108
109 #define BITS_PER_WORD 32
110
111 /* Width of a word, in units (bytes). */
112
113 #define UNITS_PER_WORD 4
114
115 /* Width in bits of a pointer. See also the macro `Pmode' defined below. */
116
117 #define POINTER_SIZE 32
118
119 /* Allocation boundary (in *bits*) for storing pointers in memory. */
120
121 #define POINTER_BOUNDARY 32
122
123 /* Allocation boundary (in *bits*) for storing arguments in argument list. */
124
125 #define PARM_BOUNDARY 32
126
127 /* Boundary (in *bits*) on which stack pointer should be aligned. */
128
129 #define STACK_BOUNDARY 32
130
131 /* Allocation boundary (in *bits*) for the code of a function. */
132
133 #define FUNCTION_BOUNDARY 32
134
135 /* There is no point aligning anything to a rounder boundary than this. */
136
137 #define BIGGEST_ALIGNMENT 64
138
139 /* Alignment of field after `int : 0' in a structure. */
140
141 #define EMPTY_FIELD_BOUNDARY 32
142
143 /* Define this if move instructions will actually fail to work when given
144 unaligned data. */
145
146 #define STRICT_ALIGNMENT 0
147
148 /* Define target floating point format. */
149
150 #define TARGET_FLOAT_FORMAT IBM_FLOAT_FORMAT
151
152 /* Define character mapping for cross-compiling. */
153
154 #define TARGET_EBCDIC 1
155
156 #ifdef HOST_EBCDIC
157 #define MAP_CHARACTER(c) ((char)(c))
158 #else
159 #define MAP_CHARACTER(c) ((char)mvs_map_char (c))
160 #endif
161
162 /* Define maximum length of page minus page escape overhead. */
163
164 #define MAX_MVS_PAGE_LENGTH 4080
165
166 /* Define if special allocation order desired. */
167
168 #define REG_ALLOC_ORDER \
169 { 0, 1, 2, 3, 14, 15, 12, 10, 9, 8, 7, 6, 5, 4, 16, 17, 18, 19, 11, 13 }
170
171 /* Standard register usage. */
172
173 /* Number of actual hardware registers. The hardware registers are
174 assigned numbers for the compiler from 0 to just below
175 FIRST_PSEUDO_REGISTER.
176 All registers that the compiler knows about must be given numbers,
177 even those that are not normally considered general registers.
178 For the 370, we give the data registers numbers 0-15,
179 and the floating point registers numbers 16-19. */
180
181 #define FIRST_PSEUDO_REGISTER 20
182
183 /* Define base and page registers. */
184
185 #define BASE_REGISTER 3
186 #define PAGE_REGISTER 4
187
188 /* 1 for registers that have pervasive standard uses and are not available
189 for the register allocator. On the 370 under C/370, R13 is stack (DSA)
190 pointer, R12 is the TCA pointer, R3 is the base register, R4 is the page
191 origin table pointer and R11 is the arg pointer. */
192
193 #define FIXED_REGISTERS \
194 { 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0 }
195 /*0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19*/
196
197 /* 1 for registers not available across function calls. These must include
198 the FIXED_REGISTERS and also any registers that can be used without being
199 saved.
200 The latter must include the registers where values are returned
201 and the register where structure-value addresses are passed.
202 NOTE: all floating registers are undefined across calls. */
203
204 #define CALL_USED_REGISTERS \
205 { 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1 }
206 /*0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19*/
207
208 /* Return number of consecutive hard regs needed starting at reg REGNO
209 to hold something of mode MODE.
210 This is ordinarily the length in words of a value of mode MODE
211 but can be less for certain modes in special long registers. */
212
213 #define HARD_REGNO_NREGS(REGNO, MODE) \
214 ((REGNO) > 15 ? 1 : (GET_MODE_SIZE(MODE)+UNITS_PER_WORD-1) / UNITS_PER_WORD)
215
216 /* Value is 1 if hard register REGNO can hold a value of machine-mode MODE.
217 On the 370, the cpu registers can hold QI, HI, SI, SF and DF. The
218 even registers can hold DI. The floating point registers can hold
219 either SF or DF. */
220
221 #define HARD_REGNO_MODE_OK(REGNO, MODE) \
222 ((REGNO) < 16 ? ((REGNO) & 1) == 0 || (MODE) != DImode \
223 : (MODE) == SFmode || (MODE) == DFmode)
224
225 /* Value is 1 if it is a good idea to tie two pseudo registers when one has
226 mode MODE1 and one has mode MODE2.
227 If HARD_REGNO_MODE_OK could produce different values for MODE1 and MODE2,
228 for any hard reg, then this must be 0 for correct output. */
229
230 #define MODES_TIEABLE_P(MODE1, MODE2) \
231 (((MODE1) == SFmode || (MODE1) == DFmode) \
232 == ((MODE2) == SFmode || (MODE2) == DFmode))
233
234 /* Mark external references. */
235
236 #define ENCODE_SECTION_INFO(decl) \
237 if (DECL_EXTERNAL (decl) && TREE_PUBLIC (decl)) \
238 SYMBOL_REF_FLAG (XEXP (DECL_RTL (decl), 0)) = 1;
239
240 /* Specify the registers used for certain standard purposes.
241 The values of these macros are register numbers. */
242
243 /* 370 PC isn't overloaded on a register. */
244
245 /* #define PC_REGNUM */
246
247 /* Register to use for pushing function arguments. */
248
249 #define STACK_POINTER_REGNUM 13
250
251 /* Base register for access to local variables of the function. */
252
253 #define FRAME_POINTER_REGNUM 13
254
255 /* Value should be nonzero if functions must have frame pointers.
256 Zero means the frame pointer need not be set up (and parms may be
257 accessed via the stack pointer) in functions that seem suitable.
258 This is computed in `reload', in reload1.c. */
259
260 #define FRAME_POINTER_REQUIRED 1
261
262 /* Base register for access to arguments of the function. */
263
264 #define ARG_POINTER_REGNUM 11
265
266 /* Register in which static-chain is passed to a function. */
267
268 #define STATIC_CHAIN_REGNUM 10
269
270 /* Register in which address to store a structure value is passed to
271 a function. */
272
273 #define STRUCT_VALUE_REGNUM 1
274
275 /* Define the classes of registers for register constraints in the
276 machine description. Also define ranges of constants.
277
278 One of the classes must always be named ALL_REGS and include all hard regs.
279 If there is more than one class, another class must be named NO_REGS
280 and contain no registers.
281
282 The name GENERAL_REGS must be the name of a class (or an alias for
283 another name such as ALL_REGS). This is the class of registers
284 that is allowed by "g" or "r" in a register constraint.
285 Also, registers outside this class are allocated only when
286 instructions express preferences for them.
287
288 The classes must be numbered in nondecreasing order; that is,
289 a larger-numbered class must never be contained completely
290 in a smaller-numbered class.
291
292 For any two classes, it is very desirable that there be another
293 class that represents their union. */
294
295 enum reg_class
296 {
297 NO_REGS, ADDR_REGS, DATA_REGS,
298 FP_REGS, ALL_REGS, LIM_REG_CLASSES
299 };
300
301 #define GENERAL_REGS DATA_REGS
302 #define N_REG_CLASSES (int) LIM_REG_CLASSES
303
304 /* Give names of register classes as strings for dump file. */
305
306 #define REG_CLASS_NAMES \
307 { "NO_REGS", "ADDR_REGS", "DATA_REGS", "FP_REGS", "ALL_REGS" }
308
309 /* Define which registers fit in which classes. This is an initializer for
310 a vector of HARD_REG_SET of length N_REG_CLASSES. */
311
312 #define REG_CLASS_CONTENTS {0, 0x0fffe, 0x0ffff, 0xf0000, 0xfffff}
313
314 /* The same information, inverted:
315 Return the class number of the smallest class containing
316 reg number REGNO. This could be a conditional expression
317 or could index an array. */
318
319 #define REGNO_REG_CLASS(REGNO) \
320 ((REGNO) >= 16 ? FP_REGS : (REGNO) != 0 ? ADDR_REGS : DATA_REGS)
321
322 /* The class value for index registers, and the one for base regs. */
323
324 #define INDEX_REG_CLASS ADDR_REGS
325 #define BASE_REG_CLASS ADDR_REGS
326
327 /* Get reg_class from a letter such as appears in the machine description. */
328
329 #define REG_CLASS_FROM_LETTER(C) \
330 ((C) == 'a' ? ADDR_REGS : \
331 ((C) == 'd' ? DATA_REGS : \
332 ((C) == 'f' ? FP_REGS : NO_REGS)))
333
334 /* The letters I, J, K, L and M in a register constraint string can be used
335 to stand for particular ranges of immediate operands.
336 This macro defines what the ranges are.
337 C is the letter, and VALUE is a constant value.
338 Return 1 if VALUE is in the range specified by C. */
339
340 #define CONST_OK_FOR_LETTER_P(VALUE, C) \
341 ((C) == 'I' ? (unsigned) (VALUE) < 256 : \
342 (C) == 'J' ? (unsigned) (VALUE) < 4096 : \
343 (C) == 'K' ? (VALUE) >= -32768 && (VALUE) < 32768 : 0)
344
345 /* Similar, but for floating constants, and defining letters G and H.
346 Here VALUE is the CONST_DOUBLE rtx itself. */
347
348 #define CONST_DOUBLE_OK_FOR_LETTER_P(VALUE, C) 1
349
350 /* Given an rtx X being reloaded into a reg required to be in class CLASS,
351 return the class of reg to actually use. In general this is just CLASS;
352 but on some machines in some cases it is preferable to use a more
353 restrictive class. */
354
355 #define PREFERRED_RELOAD_CLASS(X, CLASS) \
356 (GET_CODE(X) == CONST_DOUBLE ? FP_REGS : \
357 GET_CODE(X) == CONST_INT ? DATA_REGS : \
358 GET_CODE(X) == LABEL_REF || \
359 GET_CODE(X) == SYMBOL_REF || \
360 GET_CODE(X) == CONST ? ADDR_REGS : (CLASS))
361
362 /* Return the maximum number of consecutive registers needed to represent
363 mode MODE in a register of class CLASS. */
364
365 #define CLASS_MAX_NREGS(CLASS, MODE) \
366 ((CLASS) == FP_REGS ? 1 : \
367 (GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
368
369 /* Stack layout; function entry, exit and calling. */
370
371 /* Define this if pushing a word on the stack makes the stack pointer a
372 smaller address. */
373
374 /* #define STACK_GROWS_DOWNWARD */
375
376 /* Define this if the nominal address of the stack frame is at the
377 high-address end of the local variables; that is, each additional local
378 variable allocated goes at a more negative offset in the frame. */
379
380 /* #define FRAME_GROWS_DOWNWARD */
381
382 /* Offset within stack frame to start allocating local variables at.
383 If FRAME_GROWS_DOWNWARD, this is the offset to the END of the
384 first local allocated. Otherwise, it is the offset to the BEGINNING
385 of the first local allocated. */
386
387 #define STARTING_FRAME_OFFSET \
388 (STACK_POINTER_OFFSET + current_function_outgoing_args_size)
389
390 #define INITIAL_FRAME_POINTER_OFFSET(DEPTH) (DEPTH) = STARTING_FRAME_OFFSET
391
392 /* If we generate an insn to push BYTES bytes, this says how many the stack
393 pointer really advances by. On the 370, we have no push instruction. */
394
395 /* #define PUSH_ROUNDING(BYTES) */
396
397 /* Accumulate the outgoing argument count so we can request the right
398 DSA size and determine stack offset. */
399
400 #define ACCUMULATE_OUTGOING_ARGS
401
402 /* Define offset from stack pointer, to location where a parm can be
403 pushed. */
404
405 #define STACK_POINTER_OFFSET 148
406
407 /* Offset of first parameter from the argument pointer register value. */
408
409 #define FIRST_PARM_OFFSET(FNDECL) 0
410
411 /* 1 if N is a possible register number for function argument passing.
412 On the 370, no registers are used in this way. */
413
414 #define FUNCTION_ARG_REGNO_P(N) 0
415
416 /* Define a data type for recording info about an argument list during
417 the scan of that argument list. This data type should hold all
418 necessary information about the function itself and about the args
419 processed so far, enough to enable macros such as FUNCTION_ARG to
420 determine where the next arg should go. */
421
422 #define CUMULATIVE_ARGS int
423
424 /* Initialize a variable CUM of type CUMULATIVE_ARGS for a call to
425 a function whose data type is FNTYPE.
426 For a library call, FNTYPE is 0. */
427
428 #define INIT_CUMULATIVE_ARGS(CUM, FNTYPE, LIBNAME, INDIRECT) ((CUM) = 0)
429
430 /* Update the data in CUM to advance over an argument of mode MODE and
431 data type TYPE. (TYPE is null for libcalls where that information
432 may not be available.) */
433
434 #define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED) \
435 ((CUM) += ((MODE) == DFmode || (MODE) == SFmode \
436 ? 256 \
437 : (MODE) != BLKmode \
438 ? (GET_MODE_SIZE (MODE) + 3) / 4 \
439 : (int_size_in_bytes (TYPE) + 3) / 4))
440
441 /* Define where to put the arguments to a function. Value is zero to push
442 the argument on the stack, or a hard register in which to store the
443 argument. */
444
445 #define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) 0
446
447 /* For an arg passed partly in registers and partly in memory, this is the
448 number of registers used. For args passed entirely in registers or
449 entirely in memory, zero. */
450
451 #define FUNCTION_ARG_PARTIAL_NREGS(CUM, MODE, TYPE, NAMED) 0
452
453 /* Define if returning from a function call automatically pops the
454 arguments described by the number-of-args field in the call. */
455
456 #define RETURN_POPS_ARGS(FUNDECL,FUNTYPE,SIZE) 0
457
458 /* Define how to find the value returned by a function. VALTYPE is the
459 data type of the value (as a tree).
460 If the precise function being called is known, FUNC is its FUNCTION_DECL;
461 otherwise, FUNC is 15. */
462
463 #define RET_REG(MODE) ((MODE) == DFmode || (MODE) == SFmode ? 16 : 15)
464
465 /* On the 370 the return value is in R15 or R16. */
466
467 #define FUNCTION_VALUE(VALTYPE, FUNC) \
468 gen_rtx(REG, TYPE_MODE (VALTYPE), RET_REG(TYPE_MODE(VALTYPE)))
469
470 /* Define how to find the value returned by a library function assuming
471 the value has mode MODE. */
472
473 #define LIBCALL_VALUE(MODE) gen_rtx(REG, MODE, RET_REG(MODE))
474
475 /* 1 if N is a possible register number for a function value.
476 On the 370 under C/370, R15 and R16 are thus used. */
477
478 #define FUNCTION_VALUE_REGNO_P(N) ((N) == 15 || (N) == 16)
479
480 /* This macro definition sets up a default value for `main' to return. */
481
482 #define DEFAULT_MAIN_RETURN c_expand_return (integer_zero_node)
483
484 /* This macro generates the assembly code for function entry.
485 All of the C/370 environment is preserved. */
486 #define FUNCTION_PROLOGUE(FILE, LSIZE) i370_function_prolog ((FILE), (LSIZE));
487
488 #define ASM_DECLARE_FUNCTION_NAME(FILE, NAME, DECL) \
489 { \
490 if (strlen (NAME) * 2 > mvs_function_name_length) \
491 { \
492 if (mvs_function_name) \
493 free (mvs_function_name); \
494 mvs_function_name = 0; \
495 } \
496 if (!mvs_function_name) \
497 { \
498 mvs_function_name_length = strlen (NAME) * 2; \
499 mvs_function_name = (char *) malloc (mvs_function_name_length); \
500 if (mvs_function_name == 0) \
501 { \
502 fatal ("virtual memory exceeded"); \
503 abort (); \
504 } \
505 } \
506 if (!strcmp (NAME, "main")) \
507 strcpy (mvs_function_name, "gccmain"); \
508 else \
509 strcpy (mvs_function_name, NAME); \
510 }
511
512 /* This macro generates the assembly code for function exit, on machines
513 that need it. If FUNCTION_EPILOGUE is not defined then individual
514 return instructions are generated for each return statement. Args are
515 same as for FUNCTION_PROLOGUE.
516
517 The function epilogue should not depend on the current stack pointer!
518 It should use the frame pointer only. This is mandatory because
519 of alloca; we also take advantage of it to omit stack adjustments
520 before returning. */
521
522 #if MACROEPILOGUE == 1
523 #define FUNCTION_EPILOGUE(FILE, LSIZE) \
524 { \
525 int i; \
526 check_label_emit(); \
527 mvs_check_page (FILE,14,0); \
528 fprintf (FILE, "\tEDCEPIL\n"); \
529 mvs_page_num++; \
530 fprintf (FILE, "\tDS\t0F\n" ); \
531 fprintf (FILE, "\tLTORG\n"); \
532 fprintf (FILE, "\tDS\t0F\n"); \
533 fprintf (FILE, "PGT%d\tEQU\t*\n", function_base_page); \
534 mvs_free_label(); \
535 for ( i = function_base_page; i < mvs_page_num; i++ ) \
536 fprintf (FILE, "\tDC\tA(PG%d)\n", i); \
537 }
538 #else /* MACROEPILOGUE != 1 */
539 #define FUNCTION_EPILOGUE(FILE, LSIZE) \
540 { \
541 int i; \
542 check_label_emit(); \
543 mvs_check_page (FILE,14,0); \
544 fprintf (FILE, "\tL\t13,4(,13)\n"); \
545 fprintf (FILE, "\tL\t14,12(,13)\n"); \
546 fprintf (FILE, "\tLM\t2,12,28(13)\n"); \
547 fprintf (FILE, "\tBALR\t1,14\n"); \
548 fprintf (FILE, "\tDC\tA("); \
549 mvs_page_num++; \
550 assemble_name (FILE, mvs_function_name); \
551 fprintf (FILE, ")\n" ); \
552 fprintf (FILE, "\tDS\t0F\n" ); \
553 fprintf (FILE, "\tLTORG\n"); \
554 fprintf (FILE, "\tDS\t0F\n"); \
555 fprintf (FILE, "PGT%d\tEQU\t*\n", function_base_page); \
556 mvs_free_label(); \
557 for ( i = function_base_page; i < mvs_page_num; i++ ) \
558 fprintf (FILE, "\tDC\tA(PG%d)\n", i); \
559 }
560 #endif /* MACROEPILOGUE */
561
562
563 /* Output assembler code for a block containing the constant parts of a
564 trampoline, leaving space for the variable parts.
565
566 On the 370, the trampoline contains these instructions:
567
568 BALR 14,0
569 USING *,14
570 L STATIC_CHAIN_REGISTER,X
571 L 15,Y
572 BR 15
573 X DS 0F
574 Y DS 0F */
575
576 #define TRAMPOLINE_TEMPLATE(FILE) \
577 { \
578 ASM_OUTPUT_SHORT (FILE, gen_rtx (CONST_INT, VOIDmode, 0x05E0)); \
579 ASM_OUTPUT_SHORT (FILE, gen_rtx (CONST_INT, VOIDmode, 0x5800 | \
580 STATIC_CHAIN_REGNUM << 4)); \
581 ASM_OUTPUT_SHORT (FILE, gen_rtx (CONST_INT, VOIDmode, 0xE00A)); \
582 ASM_OUTPUT_SHORT (FILE, gen_rtx (CONST_INT, VOIDmode, 0x58F0)); \
583 ASM_OUTPUT_SHORT (FILE, gen_rtx (CONST_INT, VOIDmode, 0xE00E)); \
584 ASM_OUTPUT_SHORT (FILE, gen_rtx (CONST_INT, VOIDmode, 0x07FF)); \
585 ASM_OUTPUT_SHORT (FILE, const0_rtx); \
586 ASM_OUTPUT_SHORT (FILE, const0_rtx); \
587 ASM_OUTPUT_SHORT (FILE, const0_rtx); \
588 ASM_OUTPUT_SHORT (FILE, const0_rtx); \
589 }
590
591 /* Length in units of the trampoline for entering a nested function. */
592
593 #define TRAMPOLINE_SIZE 20
594
595 /* Emit RTL insns to initialize the variable parts of a trampoline. */
596
597 #define INITIALIZE_TRAMPOLINE(TRAMP, FNADDR, CXT) \
598 { \
599 emit_move_insn (gen_rtx (MEM, SImode, plus_constant (TRAMP, 12)), CXT); \
600 emit_move_insn (gen_rtx (MEM, SImode, plus_constant (TRAMP, 16)), FNADDR); \
601 }
602
603 /* Output assembler code to FILE to increment profiler label # LABELNO
604 for profiling a function entry. */
605
606 #define FUNCTION_PROFILER(FILE, LABELNO) \
607 fprintf (FILE, "Error: No profiling available.\n")
608
609 /* Define EXIT_IGNORE_STACK if, when returning from a function, the stack
610 pointer does not matter (provided there is a frame pointer). */
611
612 #define EXIT_IGNORE_STACK 1
613
614 /* Addressing modes, and classification of registers for them. */
615
616 /* #define HAVE_POST_INCREMENT */
617 /* #define HAVE_POST_DECREMENT */
618
619 /* #define HAVE_PRE_DECREMENT */
620 /* #define HAVE_PRE_INCREMENT */
621
622 /* These assume that REGNO is a hard or pseudo reg number. They give
623 nonzero only if REGNO is a hard reg of the suitable class or a pseudo
624 reg currently allocated to a suitable hard reg.
625 These definitions are NOT overridden anywhere. */
626
627 #define REGNO_OK_FOR_INDEX_P(REGNO) \
628 (((REGNO) > 0 && (REGNO) < 16) \
629 || (reg_renumber[REGNO] > 0 && reg_renumber[REGNO] < 16))
630
631 #define REGNO_OK_FOR_BASE_P(REGNO) REGNO_OK_FOR_INDEX_P(REGNO)
632
633 #define REGNO_OK_FOR_DATA_P(REGNO) \
634 ((REGNO) < 16 || (unsigned) reg_renumber[REGNO] < 16)
635
636 #define REGNO_OK_FOR_FP_P(REGNO) \
637 ((unsigned) ((REGNO) - 16) < 4 || (unsigned) (reg_renumber[REGNO] - 16) < 4)
638
639 /* Now macros that check whether X is a register and also,
640 strictly, whether it is in a specified class. */
641
642 /* 1 if X is a data register. */
643
644 #define DATA_REG_P(X) (REG_P (X) && REGNO_OK_FOR_DATA_P (REGNO (X)))
645
646 /* 1 if X is an fp register. */
647
648 #define FP_REG_P(X) (REG_P (X) && REGNO_OK_FOR_FP_P (REGNO (X)))
649
650 /* 1 if X is an address register. */
651
652 #define ADDRESS_REG_P(X) (REG_P (X) && REGNO_OK_FOR_BASE_P (REGNO (X)))
653
654 /* Maximum number of registers that can appear in a valid memory address. */
655
656 #define MAX_REGS_PER_ADDRESS 2
657
658 /* Recognize any constant value that is a valid address. */
659
660 #define CONSTANT_ADDRESS_P(X) \
661 (GET_CODE (X) == LABEL_REF || GET_CODE (X) == SYMBOL_REF \
662 || GET_CODE (X) == CONST_INT || GET_CODE (X) == CONST_DOUBLE \
663 || (GET_CODE (X) == CONST \
664 && GET_CODE (XEXP (XEXP (X, 0), 0)) == LABEL_REF) \
665 || (GET_CODE (X) == CONST \
666 && GET_CODE (XEXP (XEXP (X, 0), 0)) == SYMBOL_REF \
667 && !SYMBOL_REF_FLAG (XEXP (XEXP (X, 0), 0))))
668
669 /* Nonzero if the constant value X is a legitimate general operand.
670 It is given that X satisfies CONSTANT_P or is a CONST_DOUBLE. */
671
672 #define LEGITIMATE_CONSTANT_P(X) 1
673
674 /* The macros REG_OK_FOR..._P assume that the arg is a REG rtx and check
675 its validity for a certain class. We have two alternate definitions
676 for each of them. The usual definition accepts all pseudo regs; the
677 other rejects them all. The symbol REG_OK_STRICT causes the latter
678 definition to be used.
679
680 Most source files want to accept pseudo regs in the hope that they will
681 get allocated to the class that the insn wants them to be in.
682 Some source files that are used after register allocation
683 need to be strict. */
684
685 #ifndef REG_OK_STRICT
686
687 /* Nonzero if X is a hard reg that can be used as an index or if it is
688 a pseudo reg. */
689
690 #define REG_OK_FOR_INDEX_P(X) \
691 ((REGNO(X) > 0 && REGNO(X) < 16) || REGNO(X) >= 20)
692
693 /* Nonzero if X is a hard reg that can be used as a base reg or if it is
694 a pseudo reg. */
695
696 #define REG_OK_FOR_BASE_P(X) REG_OK_FOR_INDEX_P(X)
697
698 #else /* REG_OK_STRICT */
699
700 /* Nonzero if X is a hard reg that can be used as an index. */
701
702 #define REG_OK_FOR_INDEX_P(X) REGNO_OK_FOR_INDEX_P(REGNO(X))
703
704 /* Nonzero if X is a hard reg that can be used as a base reg. */
705
706 #define REG_OK_FOR_BASE_P(X) REGNO_OK_FOR_BASE_P(REGNO(X))
707
708 #endif /* REG_OK_STRICT */
709
710 /* GO_IF_LEGITIMATE_ADDRESS recognizes an RTL expression that is a
711 valid memory address for an instruction.
712 The MODE argument is the machine mode for the MEM expression
713 that wants to use this address.
714
715 The other macros defined here are used only in GO_IF_LEGITIMATE_ADDRESS,
716 except for CONSTANT_ADDRESS_P which is actually machine-independent. */
717
718 #define COUNT_REGS(X, REGS, FAIL) \
719 if (REG_P (X) && REG_OK_FOR_BASE_P (X)) \
720 REGS += 1; \
721 else if (GET_CODE (X) != CONST_INT || (unsigned) INTVAL (X) >= 4096) \
722 goto FAIL;
723
724 #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, ADDR) \
725 { \
726 if (REG_P (X) && REG_OK_FOR_BASE_P (X)) \
727 goto ADDR; \
728 if (GET_CODE (X) == PLUS) \
729 { \
730 int regs = 0; \
731 rtx x0 = XEXP (X, 0); \
732 rtx x1 = XEXP (X, 1); \
733 if (GET_CODE (x0) == PLUS) \
734 { \
735 COUNT_REGS (XEXP (x0, 0), regs, FAIL); \
736 COUNT_REGS (XEXP (x0, 1), regs, FAIL); \
737 COUNT_REGS (x1, regs, FAIL); \
738 if (regs == 2) \
739 goto ADDR; \
740 } \
741 else if (GET_CODE (x1) == PLUS) \
742 { \
743 COUNT_REGS (x0, regs, FAIL); \
744 COUNT_REGS (XEXP (x1, 0), regs, FAIL); \
745 COUNT_REGS (XEXP (x1, 1), regs, FAIL); \
746 if (regs == 2) \
747 goto ADDR; \
748 } \
749 else \
750 { \
751 COUNT_REGS (x0, regs, FAIL); \
752 COUNT_REGS (x1, regs, FAIL); \
753 if (regs != 0) \
754 goto ADDR; \
755 } \
756 } \
757 FAIL: ; \
758 }
759
760 /* The 370 has no mode dependent addresses. */
761
762 #define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR, LABEL)
763
764 /* Try machine-dependent ways of modifying an illegitimate address
765 to be legitimate. If we find one, return the new, valid address.
766 This macro is used in only one place: `memory_address' in explow.c. */
767
768 #define LEGITIMIZE_ADDRESS(X, OLDX, MODE, WIN) \
769 { \
770 if (GET_CODE (X) == PLUS && CONSTANT_ADDRESS_P (XEXP (X, 1))) \
771 (X) = gen_rtx (PLUS, SImode, XEXP (X, 0), \
772 copy_to_mode_reg (SImode, XEXP (X, 1))); \
773 if (GET_CODE (X) == PLUS && CONSTANT_ADDRESS_P (XEXP (X, 0))) \
774 (X) = gen_rtx (PLUS, SImode, XEXP (X, 1), \
775 copy_to_mode_reg (SImode, XEXP (X, 0))); \
776 if (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 0)) == MULT) \
777 (X) = gen_rtx (PLUS, SImode, XEXP (X, 1), \
778 force_operand (XEXP (X, 0), 0)); \
779 if (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 1)) == MULT) \
780 (X) = gen_rtx (PLUS, SImode, XEXP (X, 0), \
781 force_operand (XEXP (X, 1), 0)); \
782 if (memory_address_p (MODE, X)) \
783 goto WIN; \
784 }
785
786 /* Specify the machine mode that this machine uses for the index in the
787 tablejump instruction. */
788
789 #define CASE_VECTOR_MODE SImode
790
791 /* Define as C expression which evaluates to nonzero if the tablejump
792 instruction expects the table to contain offsets from the address of the
793 table.
794 Do not define this if the table should contain absolute addresses. */
795 /* #define CASE_VECTOR_PC_RELATIVE 1 */
796
797 /* Specify the tree operation to be used to convert reals to integers. */
798
799 #define IMPLICIT_FIX_EXPR FIX_ROUND_EXPR
800
801 /* Define this if fixuns_trunc is the same as fix_trunc. */
802
803 #define FIXUNS_TRUNC_LIKE_FIX_TRUNC
804
805 /* We use "unsigned char" as default. */
806
807 #define DEFAULT_SIGNED_CHAR 0
808
809 /* This is the kind of divide that is easiest to do in the general case. */
810
811 #define EASY_DIV_EXPR TRUNC_DIV_EXPR
812
813 /* Max number of bytes we can move from memory to memory in one reasonably
814 fast instruction. */
815
816 #define MOVE_MAX 256
817
818 /* Define this if zero-extension is slow (more than one real instruction). */
819
820 #define SLOW_ZERO_EXTEND
821
822 /* Nonzero if access to memory by bytes is slow and undesirable. */
823
824 #define SLOW_BYTE_ACCESS 1
825
826 /* Define if shifts truncate the shift count which implies one can omit
827 a sign-extension or zero-extension of a shift count. */
828
829 /* #define SHIFT_COUNT_TRUNCATED */
830
831 /* Value is 1 if truncating an integer of INPREC bits to OUTPREC bits
832 is done just by pretending it is already truncated. */
833
834 #define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) (OUTPREC != 16)
835
836 /* We assume that the store-condition-codes instructions store 0 for false
837 and some other value for true. This is the value stored for true. */
838
839 /* #define STORE_FLAG_VALUE -1 */
840
841 /* When a prototype says `char' or `short', really pass an `int'. */
842
843 #define PROMOTE_PROTOTYPES
844
845 /* Don't perform CSE on function addresses. */
846
847 #define NO_FUNCTION_CSE
848
849 /* Specify the machine mode that pointers have.
850 After generation of rtl, the compiler makes no further distinction
851 between pointers and any other objects of this machine mode. */
852
853 #define Pmode SImode
854
855 /* A function address in a call instruction is a byte address (for
856 indexing purposes) so give the MEM rtx a byte's mode. */
857
858 #define FUNCTION_MODE QImode
859
860 /* Compute the cost of computing a constant rtl expression RTX whose
861 rtx-code is CODE. The body of this macro is a portion of a switch
862 statement. If the code is computed here, return it with a return
863 statement. Otherwise, break from the switch. */
864
865 #define CONST_COSTS(RTX, CODE, OUTERCODE) \
866 case CONST_INT: \
867 if ((unsigned) INTVAL (RTX) < 0xfff) return 1; \
868 case CONST: \
869 case LABEL_REF: \
870 case SYMBOL_REF: \
871 return 2; \
872 case CONST_DOUBLE: \
873 return 4;
874
875 /* Tell final.c how to eliminate redundant test instructions. */
876
877 /* Here we define machine-dependent flags and fields in cc_status
878 (see `conditions.h'). */
879
880 /* Store in cc_status the expressions that the condition codes will
881 describe after execution of an instruction whose pattern is EXP.
882 Do not alter them if the instruction would not alter the cc's.
883
884 On the 370, load insns do not alter the cc's. However, in some
885 cases these instructions can make it possibly invalid to use the
886 saved cc's. In those cases we clear out some or all of the saved
887 cc's so they won't be used. */
888
889 #define NOTICE_UPDATE_CC(EXP, INSN) \
890 { \
891 rtx exp = (EXP); \
892 if (GET_CODE (exp) == PARALLEL) /* Check this */ \
893 exp = XVECEXP (exp, 0, 0); \
894 if (GET_CODE (exp) != SET) \
895 CC_STATUS_INIT; \
896 else \
897 { \
898 if (XEXP (exp, 0) == cc0_rtx) \
899 { \
900 cc_status.value1 = XEXP (exp, 0); \
901 cc_status.value2 = XEXP (exp, 1); \
902 cc_status.flags = 0; \
903 } \
904 else \
905 { \
906 if (cc_status.value1 \
907 && reg_mentioned_p (XEXP (exp, 0), cc_status.value1)) \
908 cc_status.value1 = 0; \
909 if (cc_status.value2 \
910 && reg_mentioned_p (XEXP (exp, 0), cc_status.value2)) \
911 cc_status.value2 = 0; \
912 switch (GET_CODE (XEXP (exp, 1))) \
913 { \
914 case PLUS: case MINUS: case MULT: /* case UMULT: */ \
915 case DIV: case UDIV: case NEG: case ASHIFT: \
916 case ASHIFTRT: case AND: case IOR: case XOR: \
917 case ABS: case NOT: \
918 CC_STATUS_SET (XEXP (exp, 0), XEXP (exp, 1)); \
919 } \
920 } \
921 } \
922 }
923
924
925 #define CC_STATUS_SET(V1, V2) \
926 { \
927 cc_status.flags = 0; \
928 cc_status.value1 = (V1); \
929 cc_status.value2 = (V2); \
930 if (cc_status.value1 \
931 && reg_mentioned_p (cc_status.value1, cc_status.value2)) \
932 cc_status.value2 = 0; \
933 }
934
935 #define OUTPUT_JUMP(NORMAL, FLOAT, NO_OV) \
936 { if (cc_status.flags & CC_NO_OVERFLOW) return NO_OV; return NORMAL; }
937
938 /* Control the assembler format that we output. */
939
940 #define TEXT_SECTION_ASM_OP "* Program text area"
941 #define DATA_SECTION_ASM_OP "* Program data area"
942 #define INIT_SECTION_ASM_OP "* Program initialization area"
943 #define CTOR_LIST_BEGIN /* NO OP */
944 #define CTOR_LIST_END /* NO OP */
945
946 /* How to refer to registers in assembler output. This sequence is
947 indexed by compiler's hard-register-number (see above). */
948
949 #define REGISTER_NAMES \
950 { "0", "1", "2", "3", "4", "5", "6", "7", \
951 "8", "9", "10", "11", "12", "13", "14", "15", \
952 "0", "2", "4", "6" \
953 }
954
955 /* How to renumber registers for dbx and gdb. */
956
957 #define DBX_REGISTER_NUMBER(REGNO) (REGNO)
958
959 #define ASM_FILE_START(FILE) fputs ("\tCSECT\n", FILE);
960 #define ASM_FILE_END(FILE) fputs ("\tEND\n", FILE);
961 #define ASM_IDENTIFY_GCC(FILE)
962 #define ASM_COMMENT_START "*"
963 #define ASM_APP_OFF ""
964 #define ASM_APP_ON ""
965
966 #define ASM_OUTPUT_LABEL(FILE, NAME) \
967 { assemble_name (FILE, NAME); fputs ("\tEQU\t*\n", FILE); }
968
969 #define ASM_OUTPUT_EXTERNAL(FILE, DECL, NAME) /* NO OP */
970
971 #define ASM_GLOBALIZE_LABEL(FILE, NAME) \
972 { fputs ("\tENTRY\t", FILE); assemble_name (FILE, NAME); fputs ("\n", FILE); }
973
974 /* MVS externals are limited to 8 characters, upper case only.
975 The '_' is mapped to '@', except for MVS functions, then '#'. */
976
977 #define MAX_MVS_LABEL_SIZE 8
978
979 #define ASM_OUTPUT_LABELREF(FILE, NAME) \
980 { \
981 char *bp, ch, temp[MAX_MVS_LABEL_SIZE + 1]; \
982 if (strlen (NAME) > MAX_MVS_LABEL_SIZE) \
983 { \
984 strncpy (temp, NAME, MAX_MVS_LABEL_SIZE); \
985 temp[MAX_MVS_LABEL_SIZE] = '\0'; \
986 } \
987 else \
988 strcpy (temp,NAME); \
989 if (!strcmp (temp,"main")) \
990 strcpy (temp,"gccmain"); \
991 if (mvs_function_check (temp)) \
992 ch = '#'; \
993 else \
994 ch = '@'; \
995 for (bp = temp; *bp; bp++) \
996 { \
997 if (islower (*bp)) *bp = toupper (*bp); \
998 if (*bp == '_') *bp = ch; \
999 } \
1000 fprintf (FILE, "%s", temp); \
1001 }
1002
1003 #define ASM_GENERATE_INTERNAL_LABEL(LABEL, PREFIX, NUM) \
1004 sprintf (LABEL, "*%s%d", PREFIX, NUM)
1005
1006 /* Generate internal label. Since we can branch here from off page, we
1007 must reload the base register. */
1008
1009 #define ASM_OUTPUT_INTERNAL_LABEL(FILE, PREFIX, NUM) \
1010 { \
1011 if (!strcmp (PREFIX,"L")) \
1012 { \
1013 mvs_add_label(NUM); \
1014 mvs_label_emitted = 1; \
1015 } \
1016 fprintf (FILE, "%s%d\tEQU\t*\n", PREFIX, NUM); \
1017 }
1018
1019 /* Generate case label. */
1020
1021 #define ASM_OUTPUT_CASE_LABEL(FILE, PREFIX, NUM, TABLE) \
1022 fprintf (FILE, "%s%d\tEQU\t*\n", PREFIX, NUM)
1023
1024 /* This is how to output an element of a case-vector that is absolute. */
1025
1026 #define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE) \
1027 mvs_check_page (FILE, 4, 0); \
1028 fprintf (FILE, "\tDC\tA(L%d)\n", VALUE)
1029
1030 /* This is how to output an element of a case-vector that is relative. */
1031
1032 #define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, VALUE, REL) \
1033 mvs_check_page (FILE, 4, 0); \
1034 fprintf (FILE, "\tDC\tA(L%d-L%d)\n", VALUE, REL)
1035
1036 /* This is how to output an insn to push a register on the stack.
1037 It need not be very fast code. */
1038
1039 #define ASM_OUTPUT_REG_PUSH(FILE, REGNO) \
1040 mvs_check_page (FILE, 8, 4); \
1041 fprintf (FILE, "\tS\t13,=F'4'\n\tST\t%s,%d(13)\n", \
1042 reg_names[REGNO], STACK_POINTER_OFFSET)
1043
1044 /* This is how to output an insn to pop a register from the stack.
1045 It need not be very fast code. */
1046
1047 #define ASM_OUTPUT_REG_POP(FILE, REGNO) \
1048 mvs_check_page (FILE, 8, 0); \
1049 fprintf (FILE, "\tL\t%s,%d(13)\n\tLA\t13,4(13)\n", \
1050 reg_names[REGNO], STACK_POINTER_OFFSET)
1051
1052 /* This is how to output an assembler line defining a `double' constant. */
1053
1054 #define ASM_OUTPUT_DOUBLE(FILE, VALUE) \
1055 fprintf (FILE, "\tDC\tD'%.18G'\n", (VALUE))
1056
1057 /* This is how to output an assembler line defining a `float' constant. */
1058
1059 #define ASM_OUTPUT_FLOAT(FILE, VALUE) \
1060 fprintf (FILE, "\tDC\tE'%.9G'\n", (VALUE))
1061
1062 /* This outputs an integer, if not a CONST_INT must be address constant. */
1063
1064 #define ASM_OUTPUT_INT(FILE, EXP) \
1065 { \
1066 if (GET_CODE (EXP) == CONST_INT) \
1067 { \
1068 fprintf (FILE, "\tDC\tF'"); \
1069 output_addr_const (FILE, EXP); \
1070 fprintf (FILE, "'\n"); \
1071 } \
1072 else \
1073 { \
1074 fprintf (FILE, "\tDC\tA("); \
1075 output_addr_const (FILE, EXP); \
1076 fprintf (FILE, ")\n"); \
1077 } \
1078 }
1079
1080 /* This outputs a short integer. */
1081
1082 #define ASM_OUTPUT_SHORT(FILE, EXP) \
1083 { \
1084 fprintf (FILE, "\tDC\tX'%04X'\n", INTVAL(EXP) & 0xFFFF); \
1085 }
1086
1087 /* This outputs a byte sized integer. */
1088
1089 #define ASM_OUTPUT_CHAR(FILE, EXP) \
1090 fprintf (FILE, "\tDC\tX'%02X'\n", INTVAL (EXP) )
1091
1092 #define ASM_OUTPUT_BYTE(FILE, VALUE) \
1093 fprintf (FILE, "\tDC\tX'%02X'\n", VALUE)
1094
1095 /* This outputs a text string. The string are chopped up to fit into
1096 an 80 byte record. Also, control and special characters, interpreted
1097 by the IBM assembler, are output numerically. */
1098
1099 #define MVS_ASCII_TEXT_LENGTH 48
1100
1101 #define ASM_OUTPUT_ASCII(FILE, PTR, LEN) \
1102 { \
1103 int i, j; \
1104 int c; \
1105 for (j = 0, i = 0; i < LEN; j++, i++) \
1106 { \
1107 c = PTR[i]; \
1108 if (iscntrl (c) || c == '&') \
1109 { \
1110 if (j % MVS_ASCII_TEXT_LENGTH != 0 ) \
1111 fprintf (FILE, "'\n"); \
1112 j = -1; \
1113 if (c == '&') c = MAP_CHARACTER (c); \
1114 fprintf (FILE, "\tDC\tX'%X'\n", c ); \
1115 } \
1116 else \
1117 { \
1118 if (j % MVS_ASCII_TEXT_LENGTH == 0) \
1119 fprintf (FILE, "\tDC\tC'"); \
1120 if ( c == '\'' ) \
1121 fprintf (FILE, "%c%c", c, c); \
1122 else \
1123 fprintf (FILE, "%c", c); \
1124 if (j % MVS_ASCII_TEXT_LENGTH == MVS_ASCII_TEXT_LENGTH - 1) \
1125 fprintf (FILE, "'\n" ); \
1126 } \
1127 } \
1128 if (j % MVS_ASCII_TEXT_LENGTH != 0) \
1129 fprintf (FILE, "'\n"); \
1130 }
1131
1132 /* This is how to output an assembler line that says to advance the
1133 location counter to a multiple of 2**LOG bytes. */
1134
1135 #define ASM_OUTPUT_ALIGN(FILE, LOG) \
1136 if (LOG) \
1137 { \
1138 if ((LOG) == 1) \
1139 fprintf (FILE, "\tDS\t0H\n" ); \
1140 else \
1141 fprintf (FILE, "\tDS\t0F\n" ); \
1142 } \
1143
1144 /* The maximum length of memory that the IBM assembler will allow in one
1145 DS operation. */
1146
1147 #define MAX_CHUNK 32767
1148
1149 /* A C statement to output to the stdio stream FILE an assembler
1150 instruction to advance the location counter by SIZE bytes. Those
1151 bytes should be zero when loaded. */
1152
1153 #define ASM_OUTPUT_SKIP(FILE, SIZE) \
1154 { \
1155 int s, k; \
1156 for (s = (SIZE); s > 0; s -= MAX_CHUNK) \
1157 { \
1158 if (s > MAX_CHUNK) \
1159 k = MAX_CHUNK; \
1160 else \
1161 k = s; \
1162 fprintf (FILE, "\tDS\tXL%d\n", k); \
1163 } \
1164 }
1165
1166 /* A C statement (sans semicolon) to output to the stdio stream
1167 FILE the assembler definition of a common-label named NAME whose
1168 size is SIZE bytes. The variable ROUNDED is the size rounded up
1169 to whatever alignment the caller wants. */
1170
1171 #define ASM_OUTPUT_COMMON(FILE, NAME, SIZE, ROUNDED) \
1172 { \
1173 fputs ("\tENTRY\t", FILE); \
1174 assemble_name (FILE, NAME); \
1175 fputs ("\n", FILE); \
1176 fprintf (FILE, "\tDS\t0F\n"); \
1177 ASM_OUTPUT_LABEL (FILE,NAME); \
1178 ASM_OUTPUT_SKIP (FILE,SIZE); \
1179 }
1180
1181 /* A C statement (sans semicolon) to output to the stdio stream
1182 FILE the assembler definition of a local-common-label named NAME
1183 whose size is SIZE bytes. The variable ROUNDED is the size
1184 rounded up to whatever alignment the caller wants. */
1185
1186 #define ASM_OUTPUT_LOCAL(FILE, NAME, SIZE, ROUNDED) \
1187 { \
1188 fprintf (FILE, "\tDS\t0F\n"); \
1189 ASM_OUTPUT_LABEL (FILE,NAME); \
1190 ASM_OUTPUT_SKIP (FILE,SIZE); \
1191 }
1192
1193 /* Store in OUTPUT a string (made with alloca) containing an
1194 assembler-name for a local static variable named NAME.
1195 LABELNO is an integer which is different for each call. */
1196
1197 #define ASM_FORMAT_PRIVATE_NAME(OUTPUT, NAME, LABELNO) \
1198 { \
1199 (OUTPUT) = (char *) alloca (strlen ((NAME)) + 10); \
1200 sprintf ((OUTPUT), "%s%d", (NAME), (LABELNO)); \
1201 }
1202
1203 /* Define the parentheses used to group arithmetic operations
1204 in assembler code. */
1205
1206 #define ASM_OPEN_PAREN "("
1207 #define ASM_CLOSE_PAREN ")"
1208
1209 /* Define results of standard character escape sequences. */
1210
1211 #define TARGET_BELL 47
1212 #define TARGET_BS 22
1213 #define TARGET_TAB 5
1214 #define TARGET_NEWLINE 21
1215 #define TARGET_VT 11
1216 #define TARGET_FF 12
1217 #define TARGET_CR 13
1218
1219 /* Print operand X (an rtx) in assembler syntax to file FILE.
1220 CODE is a letter or dot (`z' in `%z0') or 0 if no letter was specified.
1221 For `%' followed by punctuation, CODE is the punctuation and X is null. */
1222
1223 #define PRINT_OPERAND(FILE, X, CODE) \
1224 { \
1225 switch (GET_CODE (X)) \
1226 { \
1227 static char curreg[4]; \
1228 case REG: \
1229 if (CODE == 'N') \
1230 strcpy (curreg, reg_names[REGNO (X) + 1]); \
1231 else \
1232 strcpy (curreg, reg_names[REGNO (X)]); \
1233 fprintf (FILE, "%s", curreg); \
1234 break; \
1235 case MEM: \
1236 { \
1237 rtx addr = XEXP (X, 0); \
1238 if (CODE == 'O') \
1239 { \
1240 if (GET_CODE (addr) == PLUS) \
1241 fprintf (FILE, "%d", INTVAL (XEXP (addr, 1))); \
1242 else \
1243 fprintf (FILE, "0"); \
1244 } \
1245 else if (CODE == 'R') \
1246 { \
1247 if (GET_CODE (addr) == PLUS) \
1248 fprintf (FILE, "%s", reg_names[REGNO (XEXP (addr, 0))]);\
1249 else \
1250 fprintf (FILE, "%s", reg_names[REGNO (addr)]); \
1251 } \
1252 else \
1253 output_address (XEXP (X, 0)); \
1254 } \
1255 break; \
1256 case SYMBOL_REF: \
1257 case LABEL_REF: \
1258 mvs_page_lit += 4; \
1259 if (SYMBOL_REF_FLAG (X)) fprintf (FILE, "=V("); \
1260 else fprintf (FILE, "=A("); \
1261 output_addr_const (FILE, X); \
1262 fprintf (FILE, ")"); \
1263 break; \
1264 case CONST_INT: \
1265 if (CODE == 'B') \
1266 fprintf (FILE, "%d", INTVAL (X) & 0xff); \
1267 else if (CODE == 'X') \
1268 fprintf (FILE, "%02X", INTVAL (X) & 0xff); \
1269 else if (CODE == 'h') \
1270 fprintf (FILE, "%d", (INTVAL (X) << 16) >> 16); \
1271 else if (CODE == 'H') \
1272 { \
1273 mvs_page_lit += 2; \
1274 fprintf (FILE, "=H'%d'", (INTVAL (X) << 16) >> 16); \
1275 } \
1276 else \
1277 { \
1278 mvs_page_lit += 4; \
1279 fprintf (FILE, "=F'%d'", INTVAL (X)); \
1280 } \
1281 break; \
1282 case CONST_DOUBLE: \
1283 if (GET_MODE (X) == DImode) \
1284 { \
1285 if (CODE == 'M') \
1286 { \
1287 mvs_page_lit += 4; \
1288 fprintf (FILE, "=XL4'%08X'", CONST_DOUBLE_LOW (X)); \
1289 } \
1290 else if (CODE == 'L') \
1291 { \
1292 mvs_page_lit += 4; \
1293 fprintf (FILE, "=XL4'%08X'", CONST_DOUBLE_HIGH (X)); \
1294 } \
1295 else \
1296 { \
1297 mvs_page_lit += 8; \
1298 fprintf (FILE, "=XL8'%08X%08X'", CONST_DOUBLE_LOW (X), \
1299 CONST_DOUBLE_HIGH (X)); \
1300 } \
1301 } \
1302 else \
1303 { \
1304 union { double d; int i[2]; } u; \
1305 u.i[0] = CONST_DOUBLE_LOW (X); \
1306 u.i[1] = CONST_DOUBLE_HIGH (X); \
1307 if (GET_MODE (X) == SFmode) \
1308 { \
1309 mvs_page_lit += 4; \
1310 fprintf (FILE, "=E'%.9G'", u.d); \
1311 } \
1312 else \
1313 { \
1314 mvs_page_lit += 8; \
1315 fprintf (FILE, "=D'%.18G'", u.d); \
1316 } \
1317 } \
1318 break; \
1319 case CONST: \
1320 if (GET_CODE (XEXP (X, 0)) == PLUS \
1321 && GET_CODE (XEXP (XEXP (X, 0), 0)) == SYMBOL_REF) \
1322 { \
1323 mvs_page_lit += 4; \
1324 if (SYMBOL_REF_FLAG (XEXP (XEXP (X, 0), 0))) \
1325 { \
1326 fprintf (FILE, "=V("); \
1327 ASM_OUTPUT_LABELREF (FILE, \
1328 XSTR (XEXP (XEXP (X, 0), 0), 0)); \
1329 fprintf (FILE, ")\n\tA\t%s,=F'%d'", curreg, \
1330 INTVAL (XEXP (XEXP (X, 0), 1))); \
1331 } \
1332 else \
1333 { \
1334 fprintf (FILE, "=A("); \
1335 output_addr_const (FILE, X); \
1336 fprintf (FILE, ")"); \
1337 } \
1338 } \
1339 else \
1340 { \
1341 mvs_page_lit += 4; \
1342 fprintf (FILE, "=F'"); \
1343 output_addr_const (FILE, X); \
1344 fprintf (FILE, "'"); \
1345 } \
1346 break; \
1347 default: \
1348 abort(); \
1349 } \
1350 }
1351
1352 #define PRINT_OPERAND_ADDRESS(FILE, ADDR) \
1353 { \
1354 rtx breg, xreg, offset, plus; \
1355 \
1356 switch (GET_CODE (ADDR)) \
1357 { \
1358 case REG: \
1359 fprintf (FILE, "0(%s)", reg_names[REGNO (ADDR)]); \
1360 break; \
1361 case PLUS: \
1362 breg = 0; \
1363 xreg = 0; \
1364 offset = 0; \
1365 if (GET_CODE (XEXP (ADDR, 0)) == PLUS) \
1366 { \
1367 if (GET_CODE (XEXP (ADDR, 1)) == REG) \
1368 breg = XEXP (ADDR, 1); \
1369 else \
1370 offset = XEXP (ADDR, 1); \
1371 plus = XEXP (ADDR, 0); \
1372 } \
1373 else \
1374 { \
1375 if (GET_CODE (XEXP (ADDR, 0)) == REG) \
1376 breg = XEXP (ADDR, 0); \
1377 else \
1378 offset = XEXP (ADDR, 0); \
1379 plus = XEXP (ADDR, 1); \
1380 } \
1381 if (GET_CODE (plus) == PLUS) \
1382 { \
1383 if (GET_CODE (XEXP (plus, 0)) == REG) \
1384 { \
1385 if (breg) \
1386 xreg = XEXP (plus, 0); \
1387 else \
1388 breg = XEXP (plus, 0); \
1389 } \
1390 else \
1391 { \
1392 offset = XEXP (plus, 0); \
1393 } \
1394 if (GET_CODE (XEXP (plus, 1)) == REG) \
1395 { \
1396 if (breg) \
1397 xreg = XEXP (plus, 1); \
1398 else \
1399 breg = XEXP (plus, 1); \
1400 } \
1401 else \
1402 { \
1403 offset = XEXP (plus, 1); \
1404 } \
1405 } \
1406 else if (GET_CODE (plus) == REG) \
1407 { \
1408 if (breg) \
1409 xreg = plus; \
1410 else \
1411 breg = plus; \
1412 } \
1413 else \
1414 { \
1415 offset = plus; \
1416 } \
1417 if (offset) \
1418 { \
1419 if (GET_CODE (offset) == LABEL_REF) \
1420 fprintf (FILE, "L%d", \
1421 CODE_LABEL_NUMBER (XEXP (offset, 0))); \
1422 else \
1423 output_addr_const (FILE, offset); \
1424 } \
1425 else \
1426 fprintf (FILE, "0"); \
1427 if (xreg) \
1428 fprintf (FILE, "(%s,%s)", \
1429 reg_names[REGNO (xreg)], reg_names[REGNO (breg)]); \
1430 else \
1431 fprintf (FILE, "(%s)", reg_names[REGNO (breg)]); \
1432 break; \
1433 default: \
1434 mvs_page_lit += 4; \
1435 if (SYMBOL_REF_FLAG (ADDR)) fprintf (FILE, "=V("); \
1436 else fprintf (FILE, "=A("); \
1437 output_addr_const (FILE, ADDR); \
1438 fprintf (FILE, ")"); \
1439 break; \
1440 } \
1441 }
Mirror of the offical gcc git repository hosted at gcc.gnu.org