![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vax.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc / config / vax|
Return to vax.h CVS log | Up to [GCC 2.x] / gcc / config / vax |
1.1 root 1: /* Definitions of target machine for GNU compiler. Vax version.
1.1.1.4 root 2: Copyright (C) 1987, 88, 91, 93, 94, 95 Free Software Foundation, Inc.
1.1 root 3:
4: This file is part of GNU CC.
5:
6: GNU CC is free software; you can redistribute it and/or modify
7: it under the terms of the GNU General Public License as published by
8: the Free Software Foundation; either version 2, or (at your option)
9: any later version.
10:
11: GNU CC is distributed in the hope that it will be useful,
12: but WITHOUT ANY WARRANTY; without even the implied warranty of
13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14: GNU General Public License for more details.
15:
16: You should have received a copy of the GNU General Public License
17: along with GNU CC; see the file COPYING. If not, write to
1.1.1.4 root 18: the Free Software Foundation, 59 Temple Place - Suite 330,
19: Boston, MA 02111-1307, USA. */
1.1 root 20:
21:
22: /* Names to predefine in the preprocessor for this target machine. */
23:
1.1.1.3 root 24: #define CPP_PREDEFINES "-Dvax -D__vax__ -Dunix -Asystem(unix) -Asystem(bsd) -Acpu(vax) -Amachine(vax)"
1.1 root 25:
26: /* If using g-format floating point, alter math.h. */
27:
28: #define CPP_SPEC "%{mg:-DGFLOAT}"
29:
30: /* Choose proper libraries depending on float format.
31: Note that there are no profiling libraries for g-format.
32: Also use -lg for the sake of dbx. */
33:
34: #define LIB_SPEC "%{g:-lg}\
35: %{mg:%{lm:-lmg} -lcg \
36: %{p:%eprofiling not supported with -mg\n}\
37: %{pg:%eprofiling not supported with -mg\n}}\
38: %{!mg:%{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
39:
40: /* Print subsidiary information on the compiler version in use. */
41:
42: #define TARGET_VERSION fprintf (stderr, " (vax)");
43:
44: /* Run-time compilation parameters selecting different hardware subsets. */
45:
46: extern int target_flags;
47:
48: /* Macros used in the machine description to test the flags. */
49:
50: /* Nonzero if compiling code that Unix assembler can assemble. */
51: #define TARGET_UNIX_ASM (target_flags & 1)
52:
53: /* Nonzero if compiling with VAX-11 "C" style structure alignment */
54: #define TARGET_VAXC_ALIGNMENT (target_flags & 2)
55:
56: /* Nonzero if compiling with `G'-format floating point */
57: #define TARGET_G_FLOAT (target_flags & 4)
58:
59: /* Macro to define tables used to set the flags.
60: This is a list in braces of pairs in braces,
61: each pair being { "NAME", VALUE }
62: where VALUE is the bits to set or minus the bits to clear.
63: An empty string NAME is used to identify the default VALUE. */
64:
65: #define TARGET_SWITCHES \
66: { {"unix", 1}, \
67: {"gnu", -1}, \
68: {"vaxc-alignment", 2}, \
69: {"g", 4}, \
70: {"g-float", 4}, \
71: {"d", -4}, \
72: {"d-float", -4}, \
73: { "", TARGET_DEFAULT}}
74:
75: /* Default target_flags if no switches specified. */
76:
77: #ifndef TARGET_DEFAULT
78: #define TARGET_DEFAULT 1
79: #endif
80:
81: /* Target machine storage layout */
82:
83: /* Define for software floating point emulation of VAX format
84: when cross compiling from a non-VAX host. */
85: /* #define REAL_ARITHMETIC */
86:
87: /* Define this if most significant bit is lowest numbered
88: in instructions that operate on numbered bit-fields.
89: This is not true on the vax. */
90: #define BITS_BIG_ENDIAN 0
91:
92: /* Define this if most significant byte of a word is the lowest numbered. */
93: /* That is not true on the vax. */
94: #define BYTES_BIG_ENDIAN 0
95:
96: /* Define this if most significant word of a multiword number is the lowest
97: numbered. */
98: /* This is not true on the vax. */
99: #define WORDS_BIG_ENDIAN 0
100:
101: /* Number of bits in an addressable storage unit */
102: #define BITS_PER_UNIT 8
103:
104: /* Width in bits of a "word", which is the contents of a machine register.
105: Note that this is not necessarily the width of data type `int';
106: if using 16-bit ints on a 68000, this would still be 32.
107: But on a machine with 16-bit registers, this would be 16. */
108: #define BITS_PER_WORD 32
109:
110: /* Width of a word, in units (bytes). */
111: #define UNITS_PER_WORD 4
112:
113: /* Width in bits of a pointer.
114: See also the macro `Pmode' defined below. */
115: #define POINTER_SIZE 32
116:
117: /* Allocation boundary (in *bits*) for storing arguments in argument list. */
118: #define PARM_BOUNDARY 32
119:
120: /* Allocation boundary (in *bits*) for the code of a function. */
121: #define FUNCTION_BOUNDARY 16
122:
123: /* Alignment of field after `int : 0' in a structure. */
124: #define EMPTY_FIELD_BOUNDARY (TARGET_VAXC_ALIGNMENT ? 8 : 32)
125:
126: /* Every structure's size must be a multiple of this. */
127: #define STRUCTURE_SIZE_BOUNDARY 8
128:
129: /* A bitfield declared as `int' forces `int' alignment for the struct. */
130: #define PCC_BITFIELD_TYPE_MATTERS (! TARGET_VAXC_ALIGNMENT)
131:
132: /* No data type wants to be aligned rounder than this. */
133: #define BIGGEST_ALIGNMENT 32
134:
135: /* No structure field wants to be aligned rounder than this. */
136: #define BIGGEST_FIELD_ALIGNMENT (TARGET_VAXC_ALIGNMENT ? 8 : 32)
137:
138: /* Set this nonzero if move instructions will actually fail to work
139: when given unaligned data. */
140: #define STRICT_ALIGNMENT 0
141:
142: /* Let's keep the stack somewhat aligned. */
143: #define STACK_BOUNDARY 32
144:
145: /* Standard register usage. */
146:
147: /* Number of actual hardware registers.
148: The hardware registers are assigned numbers for the compiler
149: from 0 to just below FIRST_PSEUDO_REGISTER.
150: All registers that the compiler knows about must be given numbers,
151: even those that are not normally considered general registers. */
152: #define FIRST_PSEUDO_REGISTER 16
153:
154: /* 1 for registers that have pervasive standard uses
155: and are not available for the register allocator.
156: On the vax, these are the AP, FP, SP and PC. */
157: #define FIXED_REGISTERS {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1}
158:
159: /* 1 for registers not available across function calls.
160: These must include the FIXED_REGISTERS and also any
161: registers that can be used without being saved.
162: The latter must include the registers where values are returned
163: and the register where structure-value addresses are passed.
164: Aside from that, you can include as many other registers as you like. */
165: #define CALL_USED_REGISTERS {1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1}
166:
167: /* Return number of consecutive hard regs needed starting at reg REGNO
168: to hold something of mode MODE.
169: This is ordinarily the length in words of a value of mode MODE
170: but can be less for certain modes in special long registers.
171: On the vax, all registers are one word long. */
172: #define HARD_REGNO_NREGS(REGNO, MODE) \
173: ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
174:
175: /* Value is 1 if hard register REGNO can hold a value of machine-mode MODE.
176: On the vax, all registers can hold all modes. */
177: #define HARD_REGNO_MODE_OK(REGNO, MODE) 1
178:
179: /* Value is 1 if it is a good idea to tie two pseudo registers
180: when one has mode MODE1 and one has mode MODE2.
181: If HARD_REGNO_MODE_OK could produce different values for MODE1 and MODE2,
182: for any hard reg, then this must be 0 for correct output. */
183: #define MODES_TIEABLE_P(MODE1, MODE2) 1
184:
185: /* Specify the registers used for certain standard purposes.
186: The values of these macros are register numbers. */
187:
188: /* Vax pc is overloaded on a register. */
189: #define PC_REGNUM 15
190:
191: /* Register to use for pushing function arguments. */
192: #define STACK_POINTER_REGNUM 14
193:
194: /* Base register for access to local variables of the function. */
195: #define FRAME_POINTER_REGNUM 13
196:
197: /* Value should be nonzero if functions must have frame pointers.
198: Zero means the frame pointer need not be set up (and parms
199: may be accessed via the stack pointer) in functions that seem suitable.
200: This is computed in `reload', in reload1.c. */
201: #define FRAME_POINTER_REQUIRED 1
202:
203: /* Base register for access to arguments of the function. */
204: #define ARG_POINTER_REGNUM 12
205:
206: /* Register in which static-chain is passed to a function. */
207: #define STATIC_CHAIN_REGNUM 0
208:
209: /* Register in which address to store a structure value
210: is passed to a function. */
211: #define STRUCT_VALUE_REGNUM 1
212:
213: /* Define the classes of registers for register constraints in the
214: machine description. Also define ranges of constants.
215:
216: One of the classes must always be named ALL_REGS and include all hard regs.
217: If there is more than one class, another class must be named NO_REGS
218: and contain no registers.
219:
220: The name GENERAL_REGS must be the name of a class (or an alias for
221: another name such as ALL_REGS). This is the class of registers
222: that is allowed by "g" or "r" in a register constraint.
223: Also, registers outside this class are allocated only when
224: instructions express preferences for them.
225:
226: The classes must be numbered in nondecreasing order; that is,
227: a larger-numbered class must never be contained completely
228: in a smaller-numbered class.
229:
230: For any two classes, it is very desirable that there be another
231: class that represents their union. */
232:
233: /* The vax has only one kind of registers, so NO_REGS and ALL_REGS
234: are the only classes. */
235:
236: enum reg_class { NO_REGS, ALL_REGS, LIM_REG_CLASSES };
237:
238: #define N_REG_CLASSES (int) LIM_REG_CLASSES
239:
240: /* Since GENERAL_REGS is the same class as ALL_REGS,
241: don't give it a different class number; just make it an alias. */
242:
243: #define GENERAL_REGS ALL_REGS
244:
245: /* Give names of register classes as strings for dump file. */
246:
247: #define REG_CLASS_NAMES \
248: {"NO_REGS", "ALL_REGS" }
249:
250: /* Define which registers fit in which classes.
251: This is an initializer for a vector of HARD_REG_SET
252: of length N_REG_CLASSES. */
253:
254: #define REG_CLASS_CONTENTS {0, 0xffff}
255:
256: /* The same information, inverted:
257: Return the class number of the smallest class containing
258: reg number REGNO. This could be a conditional expression
259: or could index an array. */
260:
261: #define REGNO_REG_CLASS(REGNO) ALL_REGS
262:
263: /* The class value for index registers, and the one for base regs. */
264:
265: #define INDEX_REG_CLASS ALL_REGS
266: #define BASE_REG_CLASS ALL_REGS
267:
268: /* Get reg_class from a letter such as appears in the machine description. */
269:
270: #define REG_CLASS_FROM_LETTER(C) NO_REGS
271:
272: /* The letters I, J, K, L and M in a register constraint string
273: can be used to stand for particular ranges of immediate operands.
274: This macro defines what the ranges are.
275: C is the letter, and VALUE is a constant value.
276: Return 1 if VALUE is in the range specified by C.
277:
278: `I' is the constant zero. */
279:
280: #define CONST_OK_FOR_LETTER_P(VALUE, C) \
281: ((C) == 'I' ? (VALUE) == 0 \
282: : 0)
283:
284: /* Similar, but for floating constants, and defining letters G and H.
285: Here VALUE is the CONST_DOUBLE rtx itself.
286:
287: `G' is a floating-point zero. */
288:
289: #define CONST_DOUBLE_OK_FOR_LETTER_P(VALUE, C) \
290: ((C) == 'G' ? ((VALUE) == CONST0_RTX (DFmode) \
291: || (VALUE) == CONST0_RTX (SFmode)) \
292: : 0)
293:
294: /* Optional extra constraints for this machine.
295:
296: For the VAX, `Q' means that OP is a MEM that does not have a mode-dependent
297: address. */
298:
299: #define EXTRA_CONSTRAINT(OP, C) \
300: ((C) == 'Q' \
301: ? GET_CODE (OP) == MEM && ! mode_dependent_address_p (XEXP (OP, 0)) \
302: : 0)
303:
304: /* Given an rtx X being reloaded into a reg required to be
305: in class CLASS, return the class of reg to actually use.
306: In general this is just CLASS; but on some machines
307: in some cases it is preferable to use a more restrictive class. */
308:
309: #define PREFERRED_RELOAD_CLASS(X,CLASS) (CLASS)
310:
311: /* Return the maximum number of consecutive registers
312: needed to represent mode MODE in a register of class CLASS. */
313: /* On the vax, this is always the size of MODE in words,
314: since all registers are the same size. */
315: #define CLASS_MAX_NREGS(CLASS, MODE) \
316: ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
317:
318: /* Stack layout; function entry, exit and calling. */
319:
320: /* Define this if pushing a word on the stack
321: makes the stack pointer a smaller address. */
322: #define STACK_GROWS_DOWNWARD
323:
324: /* Define this if longjmp restores from saved registers
325: rather than from what setjmp saved. */
326: #define LONGJMP_RESTORE_FROM_STACK
327:
328: /* Define this if the nominal address of the stack frame
329: is at the high-address end of the local variables;
330: that is, each additional local variable allocated
331: goes at a more negative offset in the frame. */
332: #define FRAME_GROWS_DOWNWARD
333:
334: /* Offset within stack frame to start allocating local variables at.
335: If FRAME_GROWS_DOWNWARD, this is the offset to the END of the
336: first local allocated. Otherwise, it is the offset to the BEGINNING
337: of the first local allocated. */
338: #define STARTING_FRAME_OFFSET 0
339:
340: /* Given an rtx for the address of a frame,
341: return an rtx for the address of the word in the frame
342: that holds the dynamic chain--the previous frame's address. */
343: #define DYNAMIC_CHAIN_ADDRESS(frame) \
344: gen_rtx (PLUS, Pmode, frame, gen_rtx (CONST_INT, VOIDmode, 12))
345:
346: /* If we generate an insn to push BYTES bytes,
347: this says how many the stack pointer really advances by.
348: On the vax, -(sp) pushes only the bytes of the operands. */
349: #define PUSH_ROUNDING(BYTES) (BYTES)
350:
351: /* Offset of first parameter from the argument pointer register value. */
352: #define FIRST_PARM_OFFSET(FNDECL) 4
353:
354: /* Value is the number of bytes of arguments automatically
355: popped when returning from a subroutine call.
1.1.1.4 root 356: FUNDECL is the declaration node of the function (as a tree),
1.1 root 357: FUNTYPE is the data type of the function (as a tree),
358: or for a library call it is an identifier node for the subroutine name.
359: SIZE is the number of bytes of arguments passed on the stack.
360:
361: On the Vax, the RET insn always pops all the args for any function. */
362:
1.1.1.4 root 363: #define RETURN_POPS_ARGS(FUNDECL,FUNTYPE,SIZE) (SIZE)
1.1 root 364:
365: /* Define how to find the value returned by a function.
366: VALTYPE is the data type of the value (as a tree).
367: If the precise function being called is known, FUNC is its FUNCTION_DECL;
368: otherwise, FUNC is 0. */
369:
370: /* On the Vax the return value is in R0 regardless. */
371:
372: #define FUNCTION_VALUE(VALTYPE, FUNC) \
373: gen_rtx (REG, TYPE_MODE (VALTYPE), 0)
374:
375: /* Define how to find the value returned by a library function
376: assuming the value has mode MODE. */
377:
378: /* On the Vax the return value is in R0 regardless. */
379:
380: #define LIBCALL_VALUE(MODE) gen_rtx (REG, MODE, 0)
381:
382: /* Define this if PCC uses the nonreentrant convention for returning
383: structure and union values. */
384:
385: #define PCC_STATIC_STRUCT_RETURN
386:
387: /* 1 if N is a possible register number for a function value.
388: On the Vax, R0 is the only register thus used. */
389:
390: #define FUNCTION_VALUE_REGNO_P(N) ((N) == 0)
391:
392: /* 1 if N is a possible register number for function argument passing.
393: On the Vax, no registers are used in this way. */
394:
395: #define FUNCTION_ARG_REGNO_P(N) 0
396:
397: /* Define a data type for recording info about an argument list
398: during the scan of that argument list. This data type should
399: hold all necessary information about the function itself
400: and about the args processed so far, enough to enable macros
401: such as FUNCTION_ARG to determine where the next arg should go.
402:
403: On the vax, this is a single integer, which is a number of bytes
404: of arguments scanned so far. */
405:
406: #define CUMULATIVE_ARGS int
407:
408: /* Initialize a variable CUM of type CUMULATIVE_ARGS
409: for a call to a function whose data type is FNTYPE.
410: For a library call, FNTYPE is 0.
411:
412: On the vax, the offset starts at 0. */
413:
414: #define INIT_CUMULATIVE_ARGS(CUM,FNTYPE,LIBNAME) \
415: ((CUM) = 0)
416:
417: /* Update the data in CUM to advance over an argument
418: of mode MODE and data type TYPE.
419: (TYPE is null for libcalls where that information may not be available.) */
420:
421: #define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED) \
422: ((CUM) += ((MODE) != BLKmode \
423: ? (GET_MODE_SIZE (MODE) + 3) & ~3 \
424: : (int_size_in_bytes (TYPE) + 3) & ~3))
425:
426: /* Define where to put the arguments to a function.
427: Value is zero to push the argument on the stack,
428: or a hard register in which to store the argument.
429:
430: MODE is the argument's machine mode.
431: TYPE is the data type of the argument (as a tree).
432: This is null for libcalls where that information may
433: not be available.
434: CUM is a variable of type CUMULATIVE_ARGS which gives info about
435: the preceding args and about the function being called.
436: NAMED is nonzero if this argument is a named parameter
437: (otherwise it is an extra parameter matching an ellipsis). */
438:
439: /* On the vax all args are pushed. */
440:
441: #define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) 0
442:
443: /* This macro generates the assembly code for function entry.
444: FILE is a stdio stream to output the code to.
445: SIZE is an int: how many units of temporary storage to allocate.
446: Refer to the array `regs_ever_live' to determine which registers
447: to save; `regs_ever_live[I]' is nonzero if register number I
448: is ever used in the function. This macro is responsible for
449: knowing which registers should not be saved even if used. */
450:
451: #define FUNCTION_PROLOGUE(FILE, SIZE) \
452: { register int regno; \
453: register int mask = 0; \
454: extern char call_used_regs[]; \
455: for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++) \
456: if (regs_ever_live[regno] && !call_used_regs[regno]) \
457: mask |= 1 << regno; \
458: fprintf (FILE, "\t.word 0x%x\n", mask); \
459: MAYBE_VMS_FUNCTION_PROLOGUE(FILE) \
460: if ((SIZE) >= 64) fprintf (FILE, "\tmovab %d(sp),sp\n", -SIZE);\
461: else if (SIZE) fprintf (FILE, "\tsubl2 $%d,sp\n", (SIZE)); }
462:
463: /* vms.h redefines this. */
464: #define MAYBE_VMS_FUNCTION_PROLOGUE(FILE)
465:
466: /* Output assembler code to FILE to increment profiler label # LABELNO
467: for profiling a function entry. */
468:
469: #define FUNCTION_PROFILER(FILE, LABELNO) \
470: fprintf (FILE, "\tmovab LP%d,r0\n\tjsb mcount\n", (LABELNO));
471:
472: /* Output assembler code to FILE to initialize this source file's
473: basic block profiling info, if that has not already been done. */
474:
475: #define FUNCTION_BLOCK_PROFILER(FILE, LABELNO) \
476: fprintf (FILE, "\ttstl LPBX0\n\tjneq LPI%d\n\tpushal LPBX0\n\tcalls $1,__bb_init_func\nLPI%d:\n", \
477: LABELNO, LABELNO);
478:
479: /* Output assembler code to FILE to increment the entry-count for
480: the BLOCKNO'th basic block in this source file. This is a real pain in the
481: sphincter on a VAX, since we do not want to change any of the bits in the
482: processor status word. The way it is done here, it is pushed onto the stack
483: before any flags have changed, and then the stack is fixed up to account for
484: the fact that the instruction to restore the flags only reads a word.
485: It may seem a bit clumsy, but at least it works.
486: */
487:
488: #define BLOCK_PROFILER(FILE, BLOCKNO) \
489: fprintf (FILE, "\tmovpsl -(sp)\n\tmovw (sp),2(sp)\n\taddl2 $2,sp\n\taddl2 $1,LPBX2+%d\n\tbicpsw $255\n\tbispsw (sp)+\n", \
490: 4 * BLOCKNO)
491:
492: /* EXIT_IGNORE_STACK should be nonzero if, when returning from a function,
493: the stack pointer does not matter. The value is tested only in
494: functions that have frame pointers.
495: No definition is equivalent to always zero. */
496:
497: #define EXIT_IGNORE_STACK 1
498:
499: /* This macro generates the assembly code for function exit,
500: on machines that need it. If FUNCTION_EPILOGUE is not defined
501: then individual return instructions are generated for each
502: return statement. Args are same as for FUNCTION_PROLOGUE. */
503:
504: /* #define FUNCTION_EPILOGUE(FILE, SIZE) */
505:
506: /* Store in the variable DEPTH the initial difference between the
507: frame pointer reg contents and the stack pointer reg contents,
508: as of the start of the function body. This depends on the layout
509: of the fixed parts of the stack frame and on how registers are saved.
510:
511: On the Vax, FRAME_POINTER_REQUIRED is always 1, so the definition of this
512: macro doesn't matter. But it must be defined. */
513:
514: #define INITIAL_FRAME_POINTER_OFFSET(DEPTH) (DEPTH) = 0;
515:
516: /* Output assembler code for a block containing the constant parts
517: of a trampoline, leaving space for the variable parts. */
518:
519: /* On the vax, the trampoline contains an entry mask and two instructions:
520: .word NN
521: movl $STATIC,r0 (store the functions static chain)
522: jmp *$FUNCTION (jump to function code at address FUNCTION) */
523:
524: #define TRAMPOLINE_TEMPLATE(FILE) \
525: { \
526: ASM_OUTPUT_SHORT (FILE, const0_rtx); \
527: ASM_OUTPUT_SHORT (FILE, gen_rtx (CONST_INT, VOIDmode, 0x8fd0)); \
528: ASM_OUTPUT_INT (FILE, const0_rtx); \
529: ASM_OUTPUT_BYTE (FILE, 0x50+STATIC_CHAIN_REGNUM); \
530: ASM_OUTPUT_SHORT (FILE, gen_rtx (CONST_INT, VOIDmode, 0x9f17)); \
531: ASM_OUTPUT_INT (FILE, const0_rtx); \
532: }
533:
534: /* Length in units of the trampoline for entering a nested function. */
535:
536: #define TRAMPOLINE_SIZE 15
537:
538: /* Emit RTL insns to initialize the variable parts of a trampoline.
539: FNADDR is an RTX for the address of the function's pure code.
540: CXT is an RTX for the static chain value for the function. */
541:
542: /* We copy the register-mask from the function's pure code
543: to the start of the trampoline. */
544: #define INITIALIZE_TRAMPOLINE(TRAMP, FNADDR, CXT) \
545: { \
1.1.1.2 root 546: emit_insn (gen_rtx (ASM_INPUT, VOIDmode, \
547: "movpsl -(sp)\n\tpushal 1(pc)\n\trei")); \
1.1 root 548: emit_move_insn (gen_rtx (MEM, HImode, TRAMP), \
549: gen_rtx (MEM, HImode, FNADDR)); \
550: emit_move_insn (gen_rtx (MEM, SImode, plus_constant (TRAMP, 4)), CXT);\
551: emit_move_insn (gen_rtx (MEM, SImode, plus_constant (TRAMP, 11)), \
552: plus_constant (FNADDR, 2)); \
553: }
1.1.1.4 root 554:
555: /* Byte offset of return address in a stack frame. The "saved PC" field
556: is in element [4] when treating the frame as an array of longwords. */
557:
558: #define RETURN_ADDRESS_OFFSET (4 * UNITS_PER_WORD) /* 16 */
559:
560: /* A C expression whose value is RTL representing the value of the return
561: address for the frame COUNT steps up from the current frame.
562: FRAMEADDR is already the frame pointer of the COUNT frame, so we
563: can ignore COUNT. */
564:
565: #define RETURN_ADDR_RTX(COUNT, FRAME) \
566: gen_rtx (MEM, Pmode, plus_constant (FRAME, RETURN_ADDRESS_OFFSET))
567:
1.1 root 568:
569: /* Addressing modes, and classification of registers for them. */
570:
571: #define HAVE_POST_INCREMENT
572: /* #define HAVE_POST_DECREMENT */
573:
574: #define HAVE_PRE_DECREMENT
575: /* #define HAVE_PRE_INCREMENT */
576:
577: /* Macros to check register numbers against specific register classes. */
578:
579: /* These assume that REGNO is a hard or pseudo reg number.
580: They give nonzero only if REGNO is a hard reg of the suitable class
581: or a pseudo reg currently allocated to a suitable hard reg.
582: Since they use reg_renumber, they are safe only once reg_renumber
583: has been allocated, which happens in local-alloc.c. */
584:
585: #define REGNO_OK_FOR_INDEX_P(regno) \
586: ((regno) < FIRST_PSEUDO_REGISTER || reg_renumber[regno] >= 0)
587: #define REGNO_OK_FOR_BASE_P(regno) \
588: ((regno) < FIRST_PSEUDO_REGISTER || reg_renumber[regno] >= 0)
589:
590: /* Maximum number of registers that can appear in a valid memory address. */
591:
592: #define MAX_REGS_PER_ADDRESS 2
593:
594: /* 1 if X is an rtx for a constant that is a valid address. */
595:
596: #define CONSTANT_ADDRESS_P(X) \
597: (GET_CODE (X) == LABEL_REF || GET_CODE (X) == SYMBOL_REF \
598: || GET_CODE (X) == CONST_INT || GET_CODE (X) == CONST \
599: || GET_CODE (X) == HIGH)
600:
601: /* Nonzero if the constant value X is a legitimate general operand.
602: It is given that X satisfies CONSTANT_P or is a CONST_DOUBLE. */
603:
604: #define LEGITIMATE_CONSTANT_P(X) 1
605:
606: /* The macros REG_OK_FOR..._P assume that the arg is a REG rtx
607: and check its validity for a certain class.
608: We have two alternate definitions for each of them.
609: The usual definition accepts all pseudo regs; the other rejects
610: them unless they have been allocated suitable hard regs.
611: The symbol REG_OK_STRICT causes the latter definition to be used.
612:
613: Most source files want to accept pseudo regs in the hope that
614: they will get allocated to the class that the insn wants them to be in.
615: Source files for reload pass need to be strict.
616: After reload, it makes no difference, since pseudo regs have
617: been eliminated by then. */
618:
619: #ifndef REG_OK_STRICT
620:
621: /* Nonzero if X is a hard reg that can be used as an index
622: or if it is a pseudo reg. */
623: #define REG_OK_FOR_INDEX_P(X) 1
624: /* Nonzero if X is a hard reg that can be used as a base reg
625: or if it is a pseudo reg. */
626: #define REG_OK_FOR_BASE_P(X) 1
627:
628: #else
629:
630: /* Nonzero if X is a hard reg that can be used as an index. */
631: #define REG_OK_FOR_INDEX_P(X) REGNO_OK_FOR_INDEX_P (REGNO (X))
632: /* Nonzero if X is a hard reg that can be used as a base reg. */
633: #define REG_OK_FOR_BASE_P(X) REGNO_OK_FOR_BASE_P (REGNO (X))
634:
635: #endif
636:
637: /* GO_IF_LEGITIMATE_ADDRESS recognizes an RTL expression
638: that is a valid memory address for an instruction.
639: The MODE argument is the machine mode for the MEM expression
640: that wants to use this address.
641:
642: The other macros defined here are used only in GO_IF_LEGITIMATE_ADDRESS,
643: except for CONSTANT_ADDRESS_P which is actually machine-independent. */
644:
645: #ifdef NO_EXTERNAL_INDIRECT_ADDRESS
646:
647: /* Zero if this contains a (CONST (PLUS (SYMBOL_REF) (...))) and the
648: symbol in the SYMBOL_REF is an external symbol. */
649:
650: #define INDIRECTABLE_CONSTANT_P(X) \
651: (! (GET_CODE ((X)) == CONST \
652: && GET_CODE (XEXP ((X), 0)) == PLUS \
653: && GET_CODE (XEXP (XEXP ((X), 0), 0)) == SYMBOL_REF \
654: && SYMBOL_REF_FLAG (XEXP (XEXP ((X), 0), 0))))
655:
656: /* Re-definition of CONSTANT_ADDRESS_P, which is true only when there
657: are no SYMBOL_REFs for external symbols present. */
658:
659: #define INDIRECTABLE_CONSTANT_ADDRESS_P(X) \
660: (GET_CODE (X) == LABEL_REF \
661: || (GET_CODE (X) == SYMBOL_REF && !SYMBOL_REF_FLAG (X)) \
662: || (GET_CODE (X) == CONST && INDIRECTABLE_CONSTANT_P(X)) \
663: || GET_CODE (X) == CONST_INT)
664:
665:
666: /* Non-zero if X is an address which can be indirected. External symbols
667: could be in a sharable image library, so we disallow those. */
668:
669: #define INDIRECTABLE_ADDRESS_P(X) \
670: (INDIRECTABLE_CONSTANT_ADDRESS_P (X) \
671: || (GET_CODE (X) == REG && REG_OK_FOR_BASE_P (X)) \
672: || (GET_CODE (X) == PLUS \
673: && GET_CODE (XEXP (X, 0)) == REG \
674: && REG_OK_FOR_BASE_P (XEXP (X, 0)) \
675: && INDIRECTABLE_CONSTANT_ADDRESS_P (XEXP (X, 1))))
676:
677: #else /* not NO_EXTERNAL_INDIRECT_ADDRESS */
678:
679: #define INDIRECTABLE_CONSTANT_ADDRESS_P(X) CONSTANT_ADDRESS_P(X)
680:
681: /* Non-zero if X is an address which can be indirected. */
682: #define INDIRECTABLE_ADDRESS_P(X) \
683: (CONSTANT_ADDRESS_P (X) \
684: || (GET_CODE (X) == REG && REG_OK_FOR_BASE_P (X)) \
685: || (GET_CODE (X) == PLUS \
686: && GET_CODE (XEXP (X, 0)) == REG \
687: && REG_OK_FOR_BASE_P (XEXP (X, 0)) \
688: && CONSTANT_ADDRESS_P (XEXP (X, 1))))
689:
690: #endif /* not NO_EXTERNAL_INDIRECT_ADDRESS */
691:
692: /* Go to ADDR if X is a valid address not using indexing.
693: (This much is the easy part.) */
694: #define GO_IF_NONINDEXED_ADDRESS(X, ADDR) \
695: { register rtx xfoob = (X); \
1.1.1.2 root 696: if (GET_CODE (xfoob) == REG) \
697: { \
698: extern rtx *reg_equiv_mem; \
699: if (! reload_in_progress \
700: || reg_equiv_mem[REGNO (xfoob)] == 0 \
701: || INDIRECTABLE_ADDRESS_P (reg_equiv_mem[REGNO (xfoob)])) \
702: goto ADDR; \
703: } \
1.1 root 704: if (CONSTANT_ADDRESS_P (xfoob)) goto ADDR; \
705: if (INDIRECTABLE_ADDRESS_P (xfoob)) goto ADDR; \
706: xfoob = XEXP (X, 0); \
707: if (GET_CODE (X) == MEM && INDIRECTABLE_ADDRESS_P (xfoob)) \
708: goto ADDR; \
709: if ((GET_CODE (X) == PRE_DEC || GET_CODE (X) == POST_INC) \
710: && GET_CODE (xfoob) == REG && REG_OK_FOR_BASE_P (xfoob)) \
711: goto ADDR; }
712:
713: /* 1 if PROD is either a reg times size of mode MODE
714: or just a reg, if MODE is just one byte.
715: This macro's expansion uses the temporary variables xfoo0 and xfoo1
716: that must be declared in the surrounding context. */
717: #define INDEX_TERM_P(PROD, MODE) \
718: (GET_MODE_SIZE (MODE) == 1 \
719: ? (GET_CODE (PROD) == REG && REG_OK_FOR_BASE_P (PROD)) \
720: : (GET_CODE (PROD) == MULT \
721: && \
722: (xfoo0 = XEXP (PROD, 0), xfoo1 = XEXP (PROD, 1), \
723: ((GET_CODE (xfoo0) == CONST_INT \
724: && INTVAL (xfoo0) == GET_MODE_SIZE (MODE) \
725: && GET_CODE (xfoo1) == REG \
726: && REG_OK_FOR_INDEX_P (xfoo1)) \
727: || \
728: (GET_CODE (xfoo1) == CONST_INT \
729: && INTVAL (xfoo1) == GET_MODE_SIZE (MODE) \
730: && GET_CODE (xfoo0) == REG \
731: && REG_OK_FOR_INDEX_P (xfoo0))))))
732:
733: /* Go to ADDR if X is the sum of a register
734: and a valid index term for mode MODE. */
735: #define GO_IF_REG_PLUS_INDEX(X, MODE, ADDR) \
736: { register rtx xfooa; \
737: if (GET_CODE (X) == PLUS) \
738: { if (GET_CODE (XEXP (X, 0)) == REG \
739: && REG_OK_FOR_BASE_P (XEXP (X, 0)) \
740: && (xfooa = XEXP (X, 1), \
741: INDEX_TERM_P (xfooa, MODE))) \
742: goto ADDR; \
743: if (GET_CODE (XEXP (X, 1)) == REG \
744: && REG_OK_FOR_BASE_P (XEXP (X, 1)) \
745: && (xfooa = XEXP (X, 0), \
746: INDEX_TERM_P (xfooa, MODE))) \
747: goto ADDR; } }
748:
749: #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, ADDR) \
750: { register rtx xfoo, xfoo0, xfoo1; \
751: GO_IF_NONINDEXED_ADDRESS (X, ADDR); \
752: if (GET_CODE (X) == PLUS) \
753: { /* Handle <address>[index] represented with index-sum outermost */\
754: xfoo = XEXP (X, 0); \
755: if (INDEX_TERM_P (xfoo, MODE)) \
756: { GO_IF_NONINDEXED_ADDRESS (XEXP (X, 1), ADDR); } \
757: xfoo = XEXP (X, 1); \
758: if (INDEX_TERM_P (xfoo, MODE)) \
759: { GO_IF_NONINDEXED_ADDRESS (XEXP (X, 0), ADDR); } \
760: /* Handle offset(reg)[index] with offset added outermost */ \
761: if (INDIRECTABLE_CONSTANT_ADDRESS_P (XEXP (X, 0))) \
762: { if (GET_CODE (XEXP (X, 1)) == REG \
763: && REG_OK_FOR_BASE_P (XEXP (X, 1))) \
764: goto ADDR; \
765: GO_IF_REG_PLUS_INDEX (XEXP (X, 1), MODE, ADDR); } \
766: if (INDIRECTABLE_CONSTANT_ADDRESS_P (XEXP (X, 1))) \
767: { if (GET_CODE (XEXP (X, 0)) == REG \
768: && REG_OK_FOR_BASE_P (XEXP (X, 0))) \
769: goto ADDR; \
770: GO_IF_REG_PLUS_INDEX (XEXP (X, 0), MODE, ADDR); } } }
771:
772: /* Try machine-dependent ways of modifying an illegitimate address
773: to be legitimate. If we find one, return the new, valid address.
774: This macro is used in only one place: `memory_address' in explow.c.
775:
776: OLDX is the address as it was before break_out_memory_refs was called.
777: In some cases it is useful to look at this to decide what needs to be done.
778:
779: MODE and WIN are passed so that this macro can use
780: GO_IF_LEGITIMATE_ADDRESS.
781:
782: It is always safe for this macro to do nothing. It exists to recognize
783: opportunities to optimize the output.
784:
785: For the vax, nothing needs to be done. */
786:
787: #define LEGITIMIZE_ADDRESS(X,OLDX,MODE,WIN) {}
788:
789: /* Go to LABEL if ADDR (a legitimate address expression)
790: has an effect that depends on the machine mode it is used for.
791: On the VAX, the predecrement and postincrement address depend thus
792: (the amount of decrement or increment being the length of the operand)
793: and all indexed address depend thus (because the index scale factor
794: is the length of the operand). */
795: #define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR,LABEL) \
796: { if (GET_CODE (ADDR) == POST_INC || GET_CODE (ADDR) == PRE_DEC) \
797: goto LABEL; \
798: if (GET_CODE (ADDR) == PLUS) \
799: { if (CONSTANT_ADDRESS_P (XEXP (ADDR, 0)) \
800: && GET_CODE (XEXP (ADDR, 1)) == REG); \
801: else if (CONSTANT_ADDRESS_P (XEXP (ADDR, 1)) \
802: && GET_CODE (XEXP (ADDR, 0)) == REG); \
803: else goto LABEL; }}
804:
805: /* Specify the machine mode that this machine uses
806: for the index in the tablejump instruction. */
807: #define CASE_VECTOR_MODE HImode
808:
809: /* Define this if the case instruction expects the table
810: to contain offsets from the address of the table.
811: Do not define this if the table should contain absolute addresses. */
812: #define CASE_VECTOR_PC_RELATIVE
813:
814: /* Define this if the case instruction drops through after the table
815: when the index is out of range. Don't define it if the case insn
816: jumps to the default label instead. */
817: #define CASE_DROPS_THROUGH
818:
819: /* Specify the tree operation to be used to convert reals to integers. */
820: #define IMPLICIT_FIX_EXPR FIX_ROUND_EXPR
821:
822: /* This is the kind of divide that is easiest to do in the general case. */
823: #define EASY_DIV_EXPR TRUNC_DIV_EXPR
824:
825: /* Define this as 1 if `char' should by default be signed; else as 0. */
826: #define DEFAULT_SIGNED_CHAR 1
827:
828: /* This flag, if defined, says the same insns that convert to a signed fixnum
829: also convert validly to an unsigned one. */
830: #define FIXUNS_TRUNC_LIKE_FIX_TRUNC
831:
832: /* Max number of bytes we can move from memory to memory
833: in one reasonably fast instruction. */
834: #define MOVE_MAX 8
835:
836: /* Define this if zero-extension is slow (more than one real instruction). */
837: /* #define SLOW_ZERO_EXTEND */
838:
839: /* Nonzero if access to memory by bytes is slow and undesirable. */
840: #define SLOW_BYTE_ACCESS 0
841:
842: /* Define if shifts truncate the shift count
843: which implies one can omit a sign-extension or zero-extension
844: of a shift count. */
845: /* #define SHIFT_COUNT_TRUNCATED */
846:
847: /* Value is 1 if truncating an integer of INPREC bits to OUTPREC bits
848: is done just by pretending it is already truncated. */
849: #define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1
850:
851: /* Specify the machine mode that pointers have.
852: After generation of rtl, the compiler makes no further distinction
853: between pointers and any other objects of this machine mode. */
854: #define Pmode SImode
855:
856: /* A function address in a call instruction
857: is a byte address (for indexing purposes)
858: so give the MEM rtx a byte's mode. */
859: #define FUNCTION_MODE QImode
860:
861: /* This machine doesn't use IEEE floats. */
862:
863: #define TARGET_FLOAT_FORMAT VAX_FLOAT_FORMAT
864:
865: /* Compute the cost of computing a constant rtl expression RTX
866: whose rtx-code is CODE. The body of this macro is a portion
867: of a switch statement. If the code is computed here,
868: return it with a return statement. Otherwise, break from the switch. */
869:
870: /* On a VAX, constants from 0..63 are cheap because they can use the
871: 1 byte literal constant format. compare to -1 should be made cheap
872: so that decrement-and-branch insns can be formed more easily (if
873: the value -1 is copied to a register some decrement-and-branch patterns
874: will not match). */
875:
876: #define CONST_COSTS(RTX,CODE,OUTER_CODE) \
877: case CONST_INT: \
878: if (INTVAL (RTX) == 0) return 0; \
879: if ((OUTER_CODE) == AND) \
880: return ((unsigned) ~INTVAL (RTX) <= 077) ? 1 : 2; \
881: if ((unsigned) INTVAL (RTX) <= 077) return 1; \
882: if ((OUTER_CODE) == COMPARE && INTVAL (RTX) == -1) \
883: return 1; \
884: if ((OUTER_CODE) == PLUS && (unsigned) -INTVAL (RTX) <= 077)\
885: return 1; \
886: case CONST: \
887: case LABEL_REF: \
888: case SYMBOL_REF: \
889: return 3; \
890: case CONST_DOUBLE: \
891: if (GET_MODE_CLASS (GET_MODE (RTX)) == MODE_FLOAT) \
892: return vax_float_literal (RTX) ? 5 : 8; \
893: else \
894: return (((CONST_DOUBLE_HIGH (RTX) == 0 \
895: && (unsigned) CONST_DOUBLE_LOW (RTX) < 64) \
896: || ((OUTER_CODE) == PLUS \
897: && CONST_DOUBLE_HIGH (RTX) == -1 \
898: && (unsigned)-CONST_DOUBLE_LOW (RTX) < 64)) \
899: ? 2 : 5);
900:
901: #define RTX_COSTS(RTX,CODE,OUTER_CODE) case FIX: case FLOAT: \
902: case MULT: case DIV: case UDIV: case MOD: case UMOD: \
1.1.1.3 root 903: case ASHIFT: case LSHIFTRT: case ASHIFTRT: \
1.1 root 904: case ROTATE: case ROTATERT: case PLUS: case MINUS: case IOR: \
905: case XOR: case AND: case NEG: case NOT: case ZERO_EXTRACT: \
906: case SIGN_EXTRACT: case MEM: return vax_rtx_cost(RTX)
907:
908: #define ADDRESS_COST(RTX) (1 + (GET_CODE (RTX) == REG ? 0 : vax_address_cost(RTX)))
909:
910: /* Specify the cost of a branch insn; roughly the number of extra insns that
911: should be added to avoid a branch.
912:
913: Branches are extremely cheap on the VAX while the shift insns often
914: used to replace branches can be expensive. */
915:
916: #define BRANCH_COST 0
917:
918: /*
919: * We can use the BSD C library routines for the libgcc calls that are
920: * still generated, since that's what they boil down to anyways.
921: */
922:
923: #define UDIVSI3_LIBCALL "*udiv"
924: #define UMODSI3_LIBCALL "*urem"
925:
926: /* Check a `double' value for validity for a particular machine mode. */
927:
928: /* note that it is very hard to accidentally create a number that fits in a
929: double but not in a float, since their ranges are almost the same */
930:
1.1.1.3 root 931: #define CHECK_FLOAT_VALUE(MODE, D, OVERFLOW) \
932: ((OVERFLOW) = check_float_value (MODE, &D, OVERFLOW))
1.1 root 933:
934: /* For future reference:
935: D Float: 9 bit, sign magnitude, excess 128 binary exponent
936: normalized 56 bit fraction, redundant bit not represented
937: approximately 16 decimal digits of precision
938:
939: The values to use if we trust decimal to binary conversions:
940: #define MAX_D_FLOAT 1.7014118346046923e+38
941: #define MIN_D_FLOAT .29387358770557188e-38
942:
943: G float: 12 bit, sign magnitude, excess 1024 binary exponent
944: normalized 53 bit fraction, redundant bit not represented
945: approximately 15 decimal digits precision
946:
947: The values to use if we trust decimal to binary conversions:
948: #define MAX_G_FLOAT .898846567431157e+308
949: #define MIN_G_FLOAT .556268464626800e-308
950: */
951:
952: /* Tell final.c how to eliminate redundant test instructions. */
953:
954: /* Here we define machine-dependent flags and fields in cc_status
955: (see `conditions.h'). No extra ones are needed for the vax. */
956:
957: /* Store in cc_status the expressions
958: that the condition codes will describe
959: after execution of an instruction whose pattern is EXP.
960: Do not alter them if the instruction would not alter the cc's. */
961:
962: #define NOTICE_UPDATE_CC(EXP, INSN) \
963: { if (GET_CODE (EXP) == SET) \
964: { if (GET_CODE (SET_SRC (EXP)) == CALL) \
965: CC_STATUS_INIT; \
1.1.1.5 ! root 966: else if (GET_CODE (SET_DEST (EXP)) != ZERO_EXTRACT \
! 967: && GET_CODE (SET_DEST (EXP)) != PC) \
1.1 root 968: { cc_status.flags = 0; \
969: cc_status.value1 = SET_DEST (EXP); \
970: cc_status.value2 = SET_SRC (EXP); } } \
971: else if (GET_CODE (EXP) == PARALLEL \
972: && GET_CODE (XVECEXP (EXP, 0, 0)) == SET) \
973: { \
974: if (GET_CODE (SET_SRC (XVECEXP (EXP, 0, 0))) == CALL) \
1.1.1.4 root 975: CC_STATUS_INIT; \
1.1 root 976: else if (GET_CODE (SET_DEST (XVECEXP (EXP, 0, 0))) != PC) \
977: { cc_status.flags = 0; \
978: cc_status.value1 = SET_DEST (XVECEXP (EXP, 0, 0)); \
1.1.1.4 root 979: cc_status.value2 = SET_SRC (XVECEXP (EXP, 0, 0)); } \
980: else \
981: /* PARALLELs whose first element sets the PC are aob, \
982: sob insns. They do change the cc's. */ \
983: CC_STATUS_INIT; } \
1.1 root 984: else CC_STATUS_INIT; \
985: if (cc_status.value1 && GET_CODE (cc_status.value1) == REG \
986: && cc_status.value2 \
987: && reg_overlap_mentioned_p (cc_status.value1, cc_status.value2)) \
988: cc_status.value2 = 0; \
989: if (cc_status.value1 && GET_CODE (cc_status.value1) == MEM \
990: && cc_status.value2 \
991: && GET_CODE (cc_status.value2) == MEM) \
992: cc_status.value2 = 0; }
993: /* Actual condition, one line up, should be that value2's address
994: depends on value1, but that is too much of a pain. */
995:
996: #define OUTPUT_JUMP(NORMAL, FLOAT, NO_OV) \
997: { if (cc_status.flags & CC_NO_OVERFLOW) \
998: return NO_OV; \
999: return NORMAL; }
1000:
1001: /* Control the assembler format that we output. */
1002:
1003: /* Output at beginning of assembler file. */
1004:
1005: #define ASM_FILE_START(FILE) fprintf (FILE, "#NO_APP\n");
1006:
1007: /* Output to assembler file text saying following lines
1008: may contain character constants, extra white space, comments, etc. */
1009:
1010: #define ASM_APP_ON "#APP\n"
1011:
1012: /* Output to assembler file text saying following lines
1013: no longer contain unusual constructs. */
1014:
1015: #define ASM_APP_OFF "#NO_APP\n"
1016:
1017: /* Output before read-only data. */
1018:
1019: #define TEXT_SECTION_ASM_OP ".text"
1020:
1021: /* Output before writable data. */
1022:
1023: #define DATA_SECTION_ASM_OP ".data"
1024:
1025: /* How to refer to registers in assembler output.
1026: This sequence is indexed by compiler's hard-register-number (see above). */
1027:
1028: #define REGISTER_NAMES \
1029: {"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", \
1030: "r9", "r10", "r11", "ap", "fp", "sp", "pc"}
1031:
1032: /* This is BSD, so it wants DBX format. */
1033:
1034: #define DBX_DEBUGGING_INFO
1035:
1036: /* How to renumber registers for dbx and gdb.
1037: Vax needs no change in the numeration. */
1038:
1039: #define DBX_REGISTER_NUMBER(REGNO) (REGNO)
1040:
1041: /* Do not break .stabs pseudos into continuations. */
1042:
1043: #define DBX_CONTIN_LENGTH 0
1044:
1045: /* This is the char to use for continuation (in case we need to turn
1046: continuation back on). */
1047:
1048: #define DBX_CONTIN_CHAR '?'
1049:
1050: /* Don't use the `xsfoo;' construct in DBX output; this system
1051: doesn't support it. */
1052:
1053: #define DBX_NO_XREFS
1054:
1055: /* Output the .stabs for a C `static' variable in the data section. */
1056: #define DBX_STATIC_STAB_DATA_SECTION
1057:
1058: /* Vax specific: which type character is used for type double? */
1059:
1060: #define ASM_DOUBLE_CHAR (TARGET_G_FLOAT ? 'g' : 'd')
1061:
1062: /* This is how to output the definition of a user-level label named NAME,
1063: such as the label on a static function or variable NAME. */
1064:
1065: #define ASM_OUTPUT_LABEL(FILE,NAME) \
1066: do { assemble_name (FILE, NAME); fputs (":\n", FILE); } while (0)
1067:
1068: /* This is how to output a command to make the user-level label named NAME
1069: defined for reference from other files. */
1070:
1071: #define ASM_GLOBALIZE_LABEL(FILE,NAME) \
1072: do { fputs (".globl ", FILE); assemble_name (FILE, NAME); fputs ("\n", FILE);} while (0)
1073:
1074: /* This is how to output a reference to a user-level label named NAME. */
1075:
1076: #define ASM_OUTPUT_LABELREF(FILE,NAME) \
1077: fprintf (FILE, "_%s", NAME)
1078:
1079: /* This is how to output an internal numbered label where
1080: PREFIX is the class of label and NUM is the number within the class. */
1081:
1082: #define ASM_OUTPUT_INTERNAL_LABEL(FILE,PREFIX,NUM) \
1083: fprintf (FILE, "%s%d:\n", PREFIX, NUM)
1084:
1085: /* This is how to store into the string LABEL
1086: the symbol_ref name of an internal numbered label where
1087: PREFIX is the class of label and NUM is the number within the class.
1088: This is suitable for output with `assemble_name'. */
1089:
1090: #define ASM_GENERATE_INTERNAL_LABEL(LABEL,PREFIX,NUM) \
1091: sprintf (LABEL, "*%s%d", PREFIX, NUM)
1092:
1093: /* This is how to output an assembler line defining a `double' constant.
1094: It is .dfloat or .gfloat, depending. */
1095:
1096: #define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
1097: do { char dstr[30]; \
1098: REAL_VALUE_TO_DECIMAL (VALUE, "%.20e", dstr); \
1099: fprintf (FILE, "\t.%cfloat 0%c%s\n", ASM_DOUBLE_CHAR, \
1100: ASM_DOUBLE_CHAR, dstr); \
1101: } while (0);
1102:
1103: /* This is how to output an assembler line defining a `float' constant. */
1104:
1105: #define ASM_OUTPUT_FLOAT(FILE,VALUE) \
1106: do { char dstr[30]; \
1107: REAL_VALUE_TO_DECIMAL (VALUE, "%.20e", dstr); \
1108: fprintf (FILE, "\t.float 0f%s\n", dstr); } while (0);
1109:
1110: /* This is how to output an assembler line defining an `int' constant. */
1111:
1112: #define ASM_OUTPUT_INT(FILE,VALUE) \
1113: ( fprintf (FILE, "\t.long "), \
1114: output_addr_const (FILE, (VALUE)), \
1115: fprintf (FILE, "\n"))
1116:
1117: /* Likewise for `char' and `short' constants. */
1118:
1119: #define ASM_OUTPUT_SHORT(FILE,VALUE) \
1120: ( fprintf (FILE, "\t.word "), \
1121: output_addr_const (FILE, (VALUE)), \
1122: fprintf (FILE, "\n"))
1123:
1124: #define ASM_OUTPUT_CHAR(FILE,VALUE) \
1125: ( fprintf (FILE, "\t.byte "), \
1126: output_addr_const (FILE, (VALUE)), \
1127: fprintf (FILE, "\n"))
1128:
1129: /* This is how to output an assembler line for a numeric constant byte. */
1130:
1131: #define ASM_OUTPUT_BYTE(FILE,VALUE) \
1132: fprintf (FILE, "\t.byte 0x%x\n", (VALUE))
1133:
1134: /* This is how to output an insn to push a register on the stack.
1135: It need not be very fast code. */
1136:
1137: #define ASM_OUTPUT_REG_PUSH(FILE,REGNO) \
1138: fprintf (FILE, "\tpushl %s\n", reg_names[REGNO])
1139:
1140: /* This is how to output an insn to pop a register from the stack.
1141: It need not be very fast code. */
1142:
1143: #define ASM_OUTPUT_REG_POP(FILE,REGNO) \
1144: fprintf (FILE, "\tmovl (sp)+,%s\n", reg_names[REGNO])
1145:
1146: /* This is how to output an element of a case-vector that is absolute.
1147: (The Vax does not use such vectors,
1148: but we must define this macro anyway.) */
1149:
1150: #define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE) \
1151: fprintf (FILE, "\t.long L%d\n", VALUE)
1152:
1153: /* This is how to output an element of a case-vector that is relative. */
1154:
1155: #define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, VALUE, REL) \
1156: fprintf (FILE, "\t.word L%d-L%d\n", VALUE, REL)
1157:
1158: /* This is how to output an assembler line
1159: that says to advance the location counter
1160: to a multiple of 2**LOG bytes. */
1161:
1162: #define ASM_OUTPUT_ALIGN(FILE,LOG) \
1163: fprintf (FILE, "\t.align %d\n", (LOG))
1164:
1165: /* This is how to output an assembler line
1166: that says to advance the location counter by SIZE bytes. */
1167:
1168: #define ASM_OUTPUT_SKIP(FILE,SIZE) \
1169: fprintf (FILE, "\t.space %u\n", (SIZE))
1170:
1171: /* This says how to output an assembler line
1172: to define a global common symbol. */
1173:
1174: #define ASM_OUTPUT_COMMON(FILE, NAME, SIZE, ROUNDED) \
1175: ( fputs (".comm ", (FILE)), \
1176: assemble_name ((FILE), (NAME)), \
1177: fprintf ((FILE), ",%u\n", (ROUNDED)))
1178:
1179: /* This says how to output an assembler line
1180: to define a local common symbol. */
1181:
1182: #define ASM_OUTPUT_LOCAL(FILE, NAME, SIZE, ROUNDED) \
1183: ( fputs (".lcomm ", (FILE)), \
1184: assemble_name ((FILE), (NAME)), \
1185: fprintf ((FILE), ",%u\n", (ROUNDED)))
1186:
1187: /* Store in OUTPUT a string (made with alloca) containing
1188: an assembler-name for a local static variable named NAME.
1189: LABELNO is an integer which is different for each call. */
1190:
1191: #define ASM_FORMAT_PRIVATE_NAME(OUTPUT, NAME, LABELNO) \
1192: ( (OUTPUT) = (char *) alloca (strlen ((NAME)) + 10), \
1193: sprintf ((OUTPUT), "%s.%d", (NAME), (LABELNO)))
1194:
1.1.1.3 root 1195: /* When debugging, we want to output an extra dummy label so that gas
1196: can distinguish between D_float and G_float prior to processing the
1197: .stabs directive identifying type double. */
1198:
1199: #define ASM_IDENTIFY_LANGUAGE(FILE) \
1200: do { \
1201: output_lang_identify (FILE); \
1202: if (write_symbols == DBX_DEBUG) \
1203: fprintf (FILE, "___vax_%c_doubles:\n", ASM_DOUBLE_CHAR); \
1204: } while (0)
1205:
1.1 root 1206: /* Define the parentheses used to group arithmetic operations
1207: in assembler code. */
1208:
1209: #define ASM_OPEN_PAREN "("
1210: #define ASM_CLOSE_PAREN ")"
1211:
1212: /* Define results of standard character escape sequences. */
1213: #define TARGET_BELL 007
1214: #define TARGET_BS 010
1215: #define TARGET_TAB 011
1216: #define TARGET_NEWLINE 012
1217: #define TARGET_VT 013
1218: #define TARGET_FF 014
1219: #define TARGET_CR 015
1220:
1221: /* Print an instruction operand X on file FILE.
1222: CODE is the code from the %-spec that requested printing this operand;
1223: if `%z3' was used to print operand 3, then CODE is 'z'.
1224:
1225: VAX operand formatting codes:
1226:
1227: letter print
1228: C reverse branch condition
1229: D 64-bit immediate operand
1230: B the low 8 bits of the complement of a constant operand
1231: H the low 16 bits of the complement of a constant operand
1232: M a mask for the N highest bits of a word
1233: N the complement of a constant integer operand
1234: P constant operand plus 1
1235: R 32 - constant operand
1236: b the low 8 bits of a negated constant operand
1237: h the low 16 bits of a negated constant operand
1238: # 'd' or 'g' depending on whether dfloat or gfloat is used */
1239:
1240: /* The purpose of D is to get around a quirk or bug in vax assembler
1241: whereby -1 in a 64-bit immediate operand means 0x00000000ffffffff,
1242: which is not a 64-bit minus one. */
1243:
1244: #define PRINT_OPERAND_PUNCT_VALID_P(CODE) \
1245: ((CODE) == '#')
1246:
1247: #define PRINT_OPERAND(FILE, X, CODE) \
1248: { extern char *rev_cond_name (); \
1249: if (CODE == '#') fputc (ASM_DOUBLE_CHAR, FILE); \
1250: else if (CODE == 'C') \
1251: fputs (rev_cond_name (X), FILE); \
1252: else if (CODE == 'D' && GET_CODE (X) == CONST_INT && INTVAL (X) < 0) \
1253: fprintf (FILE, "$0xffffffff%08x", INTVAL (X)); \
1254: else if (CODE == 'P' && GET_CODE (X) == CONST_INT) \
1255: fprintf (FILE, "$%d", INTVAL (X) + 1); \
1256: else if (CODE == 'N' && GET_CODE (X) == CONST_INT) \
1257: fprintf (FILE, "$%d", ~ INTVAL (X)); \
1258: /* rotl instruction cannot deal with negative arguments. */ \
1259: else if (CODE == 'R' && GET_CODE (X) == CONST_INT) \
1260: fprintf (FILE, "$%d", 32 - INTVAL (X)); \
1261: else if (CODE == 'H' && GET_CODE (X) == CONST_INT) \
1262: fprintf (FILE, "$%d", 0xffff & ~ INTVAL (X)); \
1263: else if (CODE == 'h' && GET_CODE (X) == CONST_INT) \
1264: fprintf (FILE, "$%d", (short) - INTVAL (x)); \
1265: else if (CODE == 'B' && GET_CODE (X) == CONST_INT) \
1266: fprintf (FILE, "$%d", 0xff & ~ INTVAL (X)); \
1267: else if (CODE == 'b' && GET_CODE (X) == CONST_INT) \
1268: fprintf (FILE, "$%d", 0xff & - INTVAL (X)); \
1269: else if (CODE == 'M' && GET_CODE (X) == CONST_INT) \
1270: fprintf (FILE, "$%d", ~((1 << INTVAL (x)) - 1)); \
1271: else if (GET_CODE (X) == REG) \
1272: fprintf (FILE, "%s", reg_names[REGNO (X)]); \
1273: else if (GET_CODE (X) == MEM) \
1274: output_address (XEXP (X, 0)); \
1275: else if (GET_CODE (X) == CONST_DOUBLE && GET_MODE (X) == SFmode) \
1276: { REAL_VALUE_TYPE r; char dstr[30]; \
1277: REAL_VALUE_FROM_CONST_DOUBLE (r, X); \
1278: REAL_VALUE_TO_DECIMAL (r, "%.20e", dstr); \
1279: fprintf (FILE, "$0f%s", dstr); } \
1280: else if (GET_CODE (X) == CONST_DOUBLE && GET_MODE (X) == DFmode) \
1281: { REAL_VALUE_TYPE r; char dstr[30]; \
1282: REAL_VALUE_FROM_CONST_DOUBLE (r, X); \
1283: REAL_VALUE_TO_DECIMAL (r, "%.20e", dstr); \
1284: fprintf (FILE, "$0%c%s", ASM_DOUBLE_CHAR, dstr); } \
1285: else { putc ('$', FILE); output_addr_const (FILE, X); }}
1286:
1287: /* Print a memory operand whose address is X, on file FILE.
1288: This uses a function in output-vax.c. */
1289:
1290: #define PRINT_OPERAND_ADDRESS(FILE, ADDR) \
1291: print_operand_address (FILE, ADDR)
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.