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