1 /* Subroutines for insn-output.c for VAX.
2 Copyright (C) 1987, 1994, 1995, 1997, 1998, 1999, 2000, 2001, 2002
3 Free Software Foundation, Inc.
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
27 #include "hard-reg-set.h"
29 #include "insn-config.h"
30 #include "conditions.h"
33 #include "insn-attr.h"
40 #include "target-def.h"
42 static int follows_p
PARAMS ((rtx
, rtx
));
43 static void vax_output_function_prologue
PARAMS ((FILE *, HOST_WIDE_INT
));
45 static void vms_asm_out_constructor
PARAMS ((rtx
, int));
46 static void vms_asm_out_destructor
PARAMS ((rtx
, int));
47 static void vms_select_section
PARAMS ((tree
, int, unsigned HOST_WIDE_INT
));
48 static void vms_encode_section_info
PARAMS ((tree
, int));
49 static void vms_globalize_label
PARAMS ((FILE *, const char *));
52 /* Initialize the GCC target structure. */
53 #undef TARGET_ASM_ALIGNED_HI_OP
54 #define TARGET_ASM_ALIGNED_HI_OP "\t.word\t"
56 #undef TARGET_ASM_FUNCTION_PROLOGUE
57 #define TARGET_ASM_FUNCTION_PROLOGUE vax_output_function_prologue
60 #undef TARGET_ASM_SELECT_SECTION
61 #define TARGET_ASM_SELECT_SECTION vms_select_section
62 #undef TARGET_ENCODE_SECTION_INFO
63 #define TARGET_ENCODE_SECTION_INFO vms_encode_section_info
64 #undef TARGET_ASM_GLOBALIZE_LABEL
65 #define TARGET_ASM_GLOBALIZE_LABEL vms_globalize_label
68 struct gcc_target targetm
= TARGET_INITIALIZER
;
70 /* Set global variables as needed for the options enabled. */
75 /* We're VAX floating point, not IEEE floating point. */
76 memset (real_format_for_mode
, 0, sizeof real_format_for_mode
);
77 real_format_for_mode
[SFmode
- QFmode
] = &vax_f_format
;
78 real_format_for_mode
[DFmode
- QFmode
]
79 = (TARGET_G_FLOAT
? &vax_g_format
: &vax_d_format
);
82 /* Generate the assembly code for function entry. FILE is a stdio
83 stream to output the code to. SIZE is an int: how many units of
84 temporary storage to allocate.
86 Refer to the array `regs_ever_live' to determine which registers to
87 save; `regs_ever_live[I]' is nonzero if register number I is ever
88 used in the function. This function is responsible for knowing
89 which registers should not be saved even if used. */
92 vax_output_function_prologue (file
, size
)
97 register int mask
= 0;
99 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
100 if (regs_ever_live
[regno
] && !call_used_regs
[regno
])
103 fprintf (file
, "\t.word 0x%x\n", mask
);
105 if (dwarf2out_do_frame ())
107 const char *label
= dwarf2out_cfi_label ();
110 for (regno
= FIRST_PSEUDO_REGISTER
-1; regno
>= 0; --regno
)
111 if (regs_ever_live
[regno
] && !call_used_regs
[regno
])
112 dwarf2out_reg_save (label
, regno
, offset
-= 4);
114 dwarf2out_reg_save (label
, PC_REGNUM
, offset
-= 4);
115 dwarf2out_reg_save (label
, FRAME_POINTER_REGNUM
, offset
-= 4);
116 dwarf2out_reg_save (label
, ARG_POINTER_REGNUM
, offset
-= 4);
117 dwarf2out_def_cfa (label
, FRAME_POINTER_REGNUM
, -(offset
- 4));
122 /* Adjusting the stack pointer by 4 before calling C$MAIN_ARGS
123 is required when linking with the VMS POSIX version of the C
124 run-time library; using `subl2 $4,r0' is adequate but we use
125 `clrl -(sp)' instead. The extra 4 bytes could be removed
126 after the call because STARTING_FRAME_OFFSET's setting of -4
127 will end up adding them right back again, but don't bother. */
129 if (MAIN_NAME_P (DECL_NAME (current_function_decl
)))
130 asm_fprintf (file
, "\tclrl -(%Rsp)\n\tjsb _C$MAIN_ARGS\n");
133 size
-= STARTING_FRAME_OFFSET
;
135 asm_fprintf (file
, "\tmovab %d(%Rsp),%Rsp\n", -size
);
137 asm_fprintf (file
, "\tsubl2 $%d,%Rsp\n", size
);
140 /* This is like nonimmediate_operand with a restriction on the type of MEM. */
143 split_quadword_operands (operands
, low
, n
)
145 int n ATTRIBUTE_UNUSED
;
148 /* Split operands. */
150 low
[0] = low
[1] = low
[2] = 0;
151 for (i
= 0; i
< 3; i
++)
154 /* it's already been figured out */;
155 else if (GET_CODE (operands
[i
]) == MEM
156 && (GET_CODE (XEXP (operands
[i
], 0)) == POST_INC
))
158 rtx addr
= XEXP (operands
[i
], 0);
159 operands
[i
] = low
[i
] = gen_rtx_MEM (SImode
, addr
);
160 if (which_alternative
== 0 && i
== 0)
162 addr
= XEXP (operands
[i
], 0);
163 operands
[i
+1] = low
[i
+1] = gen_rtx_MEM (SImode
, addr
);
168 low
[i
] = operand_subword (operands
[i
], 0, 0, DImode
);
169 operands
[i
] = operand_subword (operands
[i
], 1, 0, DImode
);
175 print_operand_address (file
, addr
)
179 register rtx reg1
, breg
, ireg
;
183 switch (GET_CODE (addr
))
187 addr
= XEXP (addr
, 0);
191 fprintf (file
, "(%s)", reg_names
[REGNO (addr
)]);
195 fprintf (file
, "-(%s)", reg_names
[REGNO (XEXP (addr
, 0))]);
199 fprintf (file
, "(%s)+", reg_names
[REGNO (XEXP (addr
, 0))]);
203 /* There can be either two or three things added here. One must be a
204 REG. One can be either a REG or a MULT of a REG and an appropriate
205 constant, and the third can only be a constant or a MEM.
207 We get these two or three things and put the constant or MEM in
208 OFFSET, the MULT or REG in IREG, and the REG in BREG. If we have
209 a register and can't tell yet if it is a base or index register,
212 reg1
= 0; ireg
= 0; breg
= 0; offset
= 0;
214 if (CONSTANT_ADDRESS_P (XEXP (addr
, 0))
215 || GET_CODE (XEXP (addr
, 0)) == MEM
)
217 offset
= XEXP (addr
, 0);
218 addr
= XEXP (addr
, 1);
220 else if (CONSTANT_ADDRESS_P (XEXP (addr
, 1))
221 || GET_CODE (XEXP (addr
, 1)) == MEM
)
223 offset
= XEXP (addr
, 1);
224 addr
= XEXP (addr
, 0);
226 else if (GET_CODE (XEXP (addr
, 1)) == MULT
)
228 ireg
= XEXP (addr
, 1);
229 addr
= XEXP (addr
, 0);
231 else if (GET_CODE (XEXP (addr
, 0)) == MULT
)
233 ireg
= XEXP (addr
, 0);
234 addr
= XEXP (addr
, 1);
236 else if (GET_CODE (XEXP (addr
, 1)) == REG
)
238 reg1
= XEXP (addr
, 1);
239 addr
= XEXP (addr
, 0);
241 else if (GET_CODE (XEXP (addr
, 0)) == REG
)
243 reg1
= XEXP (addr
, 0);
244 addr
= XEXP (addr
, 1);
249 if (GET_CODE (addr
) == REG
)
256 else if (GET_CODE (addr
) == MULT
)
258 else if (GET_CODE (addr
) == PLUS
)
260 if (CONSTANT_ADDRESS_P (XEXP (addr
, 0))
261 || GET_CODE (XEXP (addr
, 0)) == MEM
)
265 if (GET_CODE (offset
) == CONST_INT
)
266 offset
= plus_constant (XEXP (addr
, 0), INTVAL (offset
));
267 else if (GET_CODE (XEXP (addr
, 0)) == CONST_INT
)
268 offset
= plus_constant (offset
, INTVAL (XEXP (addr
, 0)));
272 offset
= XEXP (addr
, 0);
274 else if (GET_CODE (XEXP (addr
, 0)) == REG
)
277 ireg
= reg1
, breg
= XEXP (addr
, 0), reg1
= 0;
279 reg1
= XEXP (addr
, 0);
281 else if (GET_CODE (XEXP (addr
, 0)) == MULT
)
285 ireg
= XEXP (addr
, 0);
290 if (CONSTANT_ADDRESS_P (XEXP (addr
, 1))
291 || GET_CODE (XEXP (addr
, 1)) == MEM
)
295 if (GET_CODE (offset
) == CONST_INT
)
296 offset
= plus_constant (XEXP (addr
, 1), INTVAL (offset
));
297 else if (GET_CODE (XEXP (addr
, 1)) == CONST_INT
)
298 offset
= plus_constant (offset
, INTVAL (XEXP (addr
, 1)));
302 offset
= XEXP (addr
, 1);
304 else if (GET_CODE (XEXP (addr
, 1)) == REG
)
307 ireg
= reg1
, breg
= XEXP (addr
, 1), reg1
= 0;
309 reg1
= XEXP (addr
, 1);
311 else if (GET_CODE (XEXP (addr
, 1)) == MULT
)
315 ireg
= XEXP (addr
, 1);
323 /* If REG1 is nonzero, figure out if it is a base or index register. */
326 if (breg
!= 0 || (offset
&& GET_CODE (offset
) == MEM
))
337 output_address (offset
);
340 fprintf (file
, "(%s)", reg_names
[REGNO (breg
)]);
344 if (GET_CODE (ireg
) == MULT
)
345 ireg
= XEXP (ireg
, 0);
346 if (GET_CODE (ireg
) != REG
)
348 fprintf (file
, "[%s]", reg_names
[REGNO (ireg
)]);
353 output_addr_const (file
, addr
);
361 switch (GET_CODE (op
))
393 register enum machine_mode mode
;
394 REAL_VALUE_TYPE r
, s
;
397 if (GET_CODE (c
) != CONST_DOUBLE
)
402 if (c
== const_tiny_rtx
[(int) mode
][0]
403 || c
== const_tiny_rtx
[(int) mode
][1]
404 || c
== const_tiny_rtx
[(int) mode
][2])
407 REAL_VALUE_FROM_CONST_DOUBLE (r
, c
);
409 for (i
= 0; i
< 7; i
++)
412 REAL_VALUE_FROM_INT (s
, x
, 0, mode
);
414 if (REAL_VALUES_EQUAL (r
, s
))
416 if (!exact_real_inverse (mode
, &s
))
418 if (REAL_VALUES_EQUAL (r
, s
))
425 /* Return the cost in cycles of a memory address, relative to register
428 Each of the following adds the indicated number of cycles:
432 1 - indexing and/or offset(register)
437 vax_address_cost (addr
)
440 int reg
= 0, indexed
= 0, indir
= 0, offset
= 0, predec
= 0;
441 rtx plus_op0
= 0, plus_op1
= 0;
443 switch (GET_CODE (addr
))
453 indexed
= 1; /* 2 on VAX 2 */
456 /* byte offsets cost nothing (on a VAX 2, they cost 1 cycle) */
458 offset
= (unsigned)(INTVAL(addr
)+128) > 256;
462 offset
= 1; /* 2 on VAX 2 */
464 case LABEL_REF
: /* this is probably a byte offset from the pc */
470 plus_op1
= XEXP (addr
, 0);
472 plus_op0
= XEXP (addr
, 0);
473 addr
= XEXP (addr
, 1);
476 indir
= 2; /* 3 on VAX 2 */
477 addr
= XEXP (addr
, 0);
483 /* Up to 3 things can be added in an address. They are stored in
484 plus_op0, plus_op1, and addr. */
498 /* Indexing and register+offset can both be used (except on a VAX 2)
499 without increasing execution time over either one alone. */
500 if (reg
&& indexed
&& offset
)
501 return reg
+ indir
+ offset
+ predec
;
502 return reg
+ indexed
+ indir
+ offset
+ predec
;
506 /* Cost of an expression on a VAX. This version has costs tuned for the
507 CVAX chip (found in the VAX 3 series) with comments for variations on
514 register enum rtx_code code
= GET_CODE (x
);
515 enum machine_mode mode
= GET_MODE (x
);
517 int i
= 0; /* may be modified in switch */
518 const char *fmt
= GET_RTX_FORMAT (code
); /* may be modified in switch */
530 c
= 16; /* 4 on VAX 9000 */
533 c
= 9; /* 4 on VAX 9000, 12 on VAX 2 */
536 c
= 16; /* 6 on VAX 9000, 28 on VAX 2 */
541 c
= 10; /* 3-4 on VAX 9000, 20-28 on VAX 2 */
544 return MAX_COST
; /* Mode is not supported. */
549 return MAX_COST
; /* Mode is not supported. */
554 c
= 30; /* highly variable */
555 else if (mode
== DFmode
)
556 /* divide takes 28 cycles if the result is not zero, 13 otherwise */
559 c
= 11; /* 25 on VAX 2 */
566 return MAX_COST
; /* Mode is not supported. */
570 c
= 6 + (mode
== DFmode
) + (GET_MODE (XEXP (x
, 0)) != SImode
);
574 c
= 7; /* 17 on VAX 2 */
582 c
= 10; /* 6 on VAX 9000 */
586 c
= 6; /* 5 on VAX 2, 4 on VAX 9000 */
587 if (GET_CODE (XEXP (x
, 1)) == CONST_INT
)
588 fmt
= "e"; /* all constant rotate counts are short */
591 /* Check for small negative integer operand: subl2 can be used with
592 a short positive constant instead. */
593 if (GET_CODE (XEXP (x
, 1)) == CONST_INT
)
594 if ((unsigned)(INTVAL (XEXP (x
, 1)) + 63) < 127)
597 c
= (mode
== DFmode
) ? 13 : 8; /* 6/8 on VAX 9000, 16/15 on VAX 2 */
603 /* AND is special because the first operand is complemented. */
605 if (GET_CODE (XEXP (x
, 0)) == CONST_INT
)
607 if ((unsigned)~INTVAL (XEXP (x
, 0)) > 63)
616 else if (mode
== SFmode
)
618 else if (mode
== DImode
)
627 if (mode
== DImode
|| mode
== DFmode
)
628 c
= 5; /* 7 on VAX 2 */
630 c
= 3; /* 4 on VAX 2 */
632 if (GET_CODE (x
) == REG
|| GET_CODE (x
) == POST_INC
)
634 return c
+ vax_address_cost (x
);
641 /* Now look inside the expression. Operands which are not registers or
642 short constants add to the cost.
644 FMT and I may have been adjusted in the switch above for instructions
645 which require special handling */
647 while (*fmt
++ == 'e')
649 register rtx op
= XEXP (x
, i
++);
650 code
= GET_CODE (op
);
652 /* A NOT is likely to be found as the first operand of an AND
653 (in which case the relevant cost is of the operand inside
654 the not) and not likely to be found anywhere else. */
656 op
= XEXP (op
, 0), code
= GET_CODE (op
);
661 if ((unsigned)INTVAL (op
) > 63 && GET_MODE (x
) != QImode
)
662 c
+= 1; /* 2 on VAX 2 */
667 c
+= 1; /* 2 on VAX 2 */
670 if (GET_MODE_CLASS (GET_MODE (op
)) == MODE_FLOAT
)
672 /* Registers are faster than floating point constants -- even
673 those constants which can be encoded in a single byte. */
674 if (vax_float_literal (op
))
677 c
+= (GET_MODE (x
) == DFmode
) ? 3 : 2;
681 if (CONST_DOUBLE_HIGH (op
) != 0
682 || (unsigned)CONST_DOUBLE_LOW (op
) > 63)
687 c
+= 1; /* 2 on VAX 2 */
688 if (GET_CODE (XEXP (op
, 0)) != REG
)
689 c
+= vax_address_cost (XEXP (op
, 0));
703 /* Additional support code for VMS target. */
705 /* Linked list of all externals that are to be emitted when optimizing
706 for the global pointer if they haven't been declared by the end of
707 the program with an appropriate .comm or initialization. */
711 struct extern_list
*next
; /* next external */
712 const char *name
; /* name of the external */
713 int size
; /* external's actual size */
714 int in_const
; /* section type flag */
715 } *extern_head
= 0, *pending_head
= 0;
717 /* Check whether NAME is already on the external definition list. If not,
718 add it to either that list or the pending definition list. */
721 vms_check_external (decl
, name
, pending
)
726 register struct extern_list
*p
, *p0
;
728 for (p
= extern_head
; p
; p
= p
->next
)
729 if (!strcmp (p
->name
, name
))
732 for (p
= pending_head
, p0
= 0; p
; p0
= p
, p
= p
->next
)
733 if (!strcmp (p
->name
, name
))
738 /* Was pending, but has now been defined; move it to other list. */
739 if (p
== pending_head
)
740 pending_head
= p
->next
;
743 p
->next
= extern_head
;
748 /* Not previously seen; create a new list entry. */
749 p
= (struct extern_list
*) xmalloc (sizeof (struct extern_list
));
754 /* Save the size and section type and link to `pending' list. */
755 p
->size
= (DECL_SIZE (decl
) == 0) ? 0 :
756 TREE_INT_CST_LOW (size_binop (CEIL_DIV_EXPR
, DECL_SIZE (decl
),
757 size_int (BITS_PER_UNIT
)));
758 p
->in_const
= (TREE_READONLY (decl
) && ! TREE_THIS_VOLATILE (decl
));
760 p
->next
= pending_head
;
765 /* Size and section type don't matter; link to `declared' list. */
766 p
->size
= p
->in_const
= 0; /* arbitrary init */
768 p
->next
= extern_head
;
775 vms_flush_pending_externals (file
)
778 register struct extern_list
*p
;
782 /* Move next pending declaration to the "done" list. */
784 pending_head
= p
->next
;
785 p
->next
= extern_head
;
788 /* Now output the actual declaration. */
793 fputs (".comm ", file
);
794 assemble_name (file
, p
->name
);
795 fprintf (file
, ",%d\n", p
->size
);
800 vms_asm_out_constructor (symbol
, priority
)
802 int priority ATTRIBUTE_UNUSED
;
804 fprintf (asm_out_file
,".globl $$PsectAttributes_NOOVR$$__gxx_init_1\n");
806 fprintf (asm_out_file
,"$$PsectAttributes_NOOVR$$__gxx_init_1:\n\t.long\t");
807 assemble_name (asm_out_file
, XSTR (symbol
, 0));
808 fputc ('\n', asm_out_file
);
812 vms_asm_out_destructor (symbol
, priority
)
814 int priority ATTRIBUTE_UNUSED
;
816 fprintf (asm_out_file
,".globl $$PsectAttributes_NOOVR$$__gxx_clean_1\n");
818 fprintf (asm_out_file
,"$$PsectAttributes_NOOVR$$__gxx_clean_1:\n\t.long\t");
819 assemble_name (asm_out_file
, XSTR (symbol
, 0));
820 fputc ('\n', asm_out_file
);
824 vms_select_section (exp
, reloc
, align
)
826 int reloc ATTRIBUTE_UNUSED
;
827 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED
;
829 if (TREE_CODE (exp
) == VAR_DECL
)
831 if (TREE_READONLY (exp
) && ! TREE_THIS_VOLATILE (exp
)
832 && DECL_INITIAL (exp
)
833 && (DECL_INITIAL (exp
) == error_mark_node
834 || TREE_CONSTANT (DECL_INITIAL (exp
))))
836 if (TREE_PUBLIC (exp
))
844 if (TREE_CODE_CLASS (TREE_CODE (exp
)) == 'c')
846 if (TREE_CODE (exp
) == STRING_CST
&& flag_writable_strings
)
853 /* Make sure that external variables are correctly addressed. Under VMS
854 there is some brain damage in the linker that requires us to do this. */
857 vms_encode_section_info (decl
, first
)
859 int first ATTRIBUTE_UNUSED
;
861 if (DECL_EXTERNAL (decl
) && TREE_PUBLIC (decl
))
862 SYMBOL_REF_FLAG (XEXP (DECL_RTL (decl
), 0)) = 1;
865 /* This is how to output a command to make the user-level label named NAME
866 defined for reference from other files. */
868 vms_globalize_label (stream
, name
)
872 default_globalize_label (stream
, name
);
873 vms_check_external (NULL_TREE
, name
, 0);
875 #endif /* VMS_TARGET */
877 /* Additional support code for VMS host. */
878 /* ??? This should really be in libiberty; vax.c is a target file. */
879 #ifdef QSORT_WORKAROUND
881 Do not use VAXCRTL's qsort() due to a severe bug: once you've
882 sorted something which has a size that's an exact multiple of 4
883 and is longword aligned, you cannot safely sort anything which
884 is either not a multiple of 4 in size or not longword aligned.
885 A static "move-by-longword" optimization flag inside qsort() is
886 never reset. This is known to affect VMS V4.6 through VMS V5.5-1,
887 and was finally fixed in VMS V5.5-2.
889 In this work-around an insertion sort is used for simplicity.
890 The qsort code from glibc should probably be used instead.
893 not_qsort (array
, count
, size
, compare
)
895 unsigned count
, size
;
899 if (size
== sizeof (short))
902 register short *next
, *prev
;
903 short tmp
, *base
= array
;
905 for (next
= base
, i
= count
- 1; i
> 0; i
--)
908 if ((*compare
)(next
, prev
) < 0)
911 do *(prev
+ 1) = *prev
;
912 while (--prev
>= base
? (*compare
)(&tmp
, prev
) < 0 : 0);
917 else if (size
== sizeof (long))
920 register long *next
, *prev
;
921 long tmp
, *base
= array
;
923 for (next
= base
, i
= count
- 1; i
> 0; i
--)
926 if ((*compare
)(next
, prev
) < 0)
929 do *(prev
+ 1) = *prev
;
930 while (--prev
>= base
? (*compare
)(&tmp
, prev
) < 0 : 0);
935 else /* arbitrary size */
938 register char *next
, *prev
, *tmp
= alloca (size
), *base
= array
;
940 for (next
= base
, i
= count
- 1; i
> 0; i
--)
941 { /* count-1 forward iterations */
942 prev
= next
, next
+= size
; /* increment front pointer */
943 if ((*compare
)(next
, prev
) < 0)
944 { /* found element out of order; move others up then re-insert */
945 memcpy (tmp
, next
, size
); /* save smaller element */
946 do { memcpy (prev
+ size
, prev
, size
); /* move larger elem. up */
947 prev
-= size
; /* decrement back pointer */
948 } while (prev
>= base
? (*compare
)(tmp
, prev
) < 0 : 0);
949 memcpy (prev
+ size
, tmp
, size
); /* restore small element */
959 #endif /* QSORT_WORKAROUND */
961 /* Return 1 if insn A follows B. */
969 for (p
= a
; p
!= b
; p
= NEXT_INSN (p
))
976 /* Returns 1 if we know operand OP was 0 before INSN. */
979 reg_was_0_p (insn
, op
)
984 return ((link
= find_reg_note (insn
, REG_WAS_0
, 0))
985 /* Make sure the insn that stored the 0 is still present
986 and doesn't follow INSN in the insn sequence. */
987 && ! INSN_DELETED_P (XEXP (link
, 0))
988 && GET_CODE (XEXP (link
, 0)) != NOTE
989 && ! follows_p (XEXP (link
, 0), insn
)
990 /* Make sure cross jumping didn't happen here. */
991 && no_labels_between_p (XEXP (link
, 0), insn
)
992 /* Make sure the reg hasn't been clobbered. */
993 && ! reg_set_between_p (op
, XEXP (link
, 0), insn
));
997 vax_output_mi_thunk (file
, thunk
, delta
, function
)
999 tree thunk ATTRIBUTE_UNUSED
;
1000 HOST_WIDE_INT delta
;
1003 fprintf (file
, "\t.word 0x0ffc\n");
1004 fprintf (file
, "\taddl2 $");
1005 fprintf (file
, HOST_WIDE_INT_PRINT_DEC
, delta
);
1006 asm_fprintf (file
, ",4(%Rap)\n");
1007 fprintf (file
, "\tjmp ");
1008 assemble_name (file
, XSTR (XEXP (DECL_RTL (function
), 0), 0));
1009 fprintf (file
, "+2\n");