will be conditionalised if possible. */
static int max_insns_skipped = 5;
-extern FILE * asm_out_file;
-
/* True if we are currently building a constant table. */
int making_const_table;
epilogue. */
static void
-arm_unwind_emit_sequence (FILE * asm_out_file, rtx p)
+arm_unwind_emit_sequence (FILE * out_file, rtx p)
{
int i;
HOST_WIDE_INT offset;
padlast = offset - 4;
gcc_assert (padlast == 0 || padlast == 4);
if (padlast == 4)
- fprintf (asm_out_file, "\t.pad #4\n");
+ fprintf (out_file, "\t.pad #4\n");
reg_size = 4;
- fprintf (asm_out_file, "\t.save {");
+ fprintf (out_file, "\t.save {");
}
else if (IS_VFP_REGNUM (reg))
{
reg_size = 8;
- fprintf (asm_out_file, "\t.vsave {");
+ fprintf (out_file, "\t.vsave {");
}
else
/* Unknown register type. */
gcc_assert (reg >= lastreg);
if (i != 1)
- fprintf (asm_out_file, ", ");
+ fprintf (out_file, ", ");
/* We can't use %r for vfp because we need to use the
double precision register names. */
if (IS_VFP_REGNUM (reg))
- asm_fprintf (asm_out_file, "d%d", (reg - FIRST_VFP_REGNUM) / 2);
+ asm_fprintf (out_file, "d%d", (reg - FIRST_VFP_REGNUM) / 2);
else
- asm_fprintf (asm_out_file, "%r", reg);
+ asm_fprintf (out_file, "%r", reg);
if (flag_checking)
{
offset += reg_size;
}
}
- fprintf (asm_out_file, "}\n");
+ fprintf (out_file, "}\n");
if (padfirst)
- fprintf (asm_out_file, "\t.pad #%d\n", padfirst);
+ fprintf (out_file, "\t.pad #%d\n", padfirst);
}
/* Emit unwind directives for a SET. */
static void
-arm_unwind_emit_set (FILE * asm_out_file, rtx p)
+arm_unwind_emit_set (FILE * out_file, rtx p)
{
rtx e0;
rtx e1;
|| REGNO (XEXP (XEXP (e0, 0), 0)) != SP_REGNUM)
abort ();
- asm_fprintf (asm_out_file, "\t.save ");
+ asm_fprintf (out_file, "\t.save ");
if (IS_VFP_REGNUM (REGNO (e1)))
- asm_fprintf(asm_out_file, "{d%d}\n",
+ asm_fprintf(out_file, "{d%d}\n",
(REGNO (e1) - FIRST_VFP_REGNUM) / 2);
else
- asm_fprintf(asm_out_file, "{%r}\n", REGNO (e1));
+ asm_fprintf(out_file, "{%r}\n", REGNO (e1));
break;
case REG:
|| !CONST_INT_P (XEXP (e1, 1)))
abort ();
- asm_fprintf (asm_out_file, "\t.pad #%wd\n",
+ asm_fprintf (out_file, "\t.pad #%wd\n",
-INTVAL (XEXP (e1, 1)));
}
else if (REGNO (e0) == HARD_FRAME_POINTER_REGNUM)
abort ();
reg = REGNO (XEXP (e1, 0));
offset = INTVAL (XEXP (e1, 1));
- asm_fprintf (asm_out_file, "\t.setfp %r, %r, #%wd\n",
+ asm_fprintf (out_file, "\t.setfp %r, %r, #%wd\n",
HARD_FRAME_POINTER_REGNUM, reg,
offset);
}
else if (REG_P (e1))
{
reg = REGNO (e1);
- asm_fprintf (asm_out_file, "\t.setfp %r, %r\n",
+ asm_fprintf (out_file, "\t.setfp %r, %r\n",
HARD_FRAME_POINTER_REGNUM, reg);
}
else
else if (REG_P (e1) && REGNO (e1) == SP_REGNUM)
{
/* Move from sp to reg. */
- asm_fprintf (asm_out_file, "\t.movsp %r\n", REGNO (e0));
+ asm_fprintf (out_file, "\t.movsp %r\n", REGNO (e0));
}
else if (GET_CODE (e1) == PLUS
&& REG_P (XEXP (e1, 0))
&& CONST_INT_P (XEXP (e1, 1)))
{
/* Set reg to offset from sp. */
- asm_fprintf (asm_out_file, "\t.movsp %r, #%d\n",
+ asm_fprintf (out_file, "\t.movsp %r, #%d\n",
REGNO (e0), (int)INTVAL(XEXP (e1, 1)));
}
else
/* Emit unwind directives for the given insn. */
static void
-arm_unwind_emit (FILE * asm_out_file, rtx_insn *insn)
+arm_unwind_emit (FILE * out_file, rtx_insn *insn)
{
rtx note, pat;
bool handled_one = false;
gcc_assert (src == stack_pointer_rtx);
reg = REGNO (dest);
- asm_fprintf (asm_out_file, "\t.unwind_raw 0, 0x%x @ vsp = r%d\n",
+ asm_fprintf (out_file, "\t.unwind_raw 0, 0x%x @ vsp = r%d\n",
reg + 0x90, reg);
}
handled_one = true;
switch (GET_CODE (pat))
{
case SET:
- arm_unwind_emit_set (asm_out_file, pat);
+ arm_unwind_emit_set (out_file, pat);
break;
case SEQUENCE:
/* Store multiple. */
- arm_unwind_emit_sequence (asm_out_file, pat);
+ arm_unwind_emit_sequence (out_file, pat);
break;
default:
int
machopic_output_data_section_indirection (machopic_indirection **slot,
- FILE *asm_out_file)
+ FILE *out_file)
{
machopic_indirection *p = *slot;
switch_to_section (data_section);
assemble_align (GET_MODE_ALIGNMENT (Pmode));
- assemble_label (asm_out_file, ptr_name);
+ assemble_label (out_file, ptr_name);
assemble_integer (gen_rtx_SYMBOL_REF (Pmode, sym_name),
GET_MODE_SIZE (Pmode),
GET_MODE_ALIGNMENT (Pmode), 1);
int
machopic_output_stub_indirection (machopic_indirection **slot,
- FILE *asm_out_file)
+ FILE *out_file)
{
machopic_indirection *p = *slot;
else
sprintf (stub, "%s%s", user_label_prefix, ptr_name);
- machopic_output_stub (asm_out_file, sym, stub);
+ machopic_output_stub (out_file, sym, stub);
return 1;
}
int
-machopic_output_indirection (machopic_indirection **slot, FILE *asm_out_file)
+machopic_output_indirection (machopic_indirection **slot, FILE *out_file)
{
machopic_indirection *p = *slot;
storage has been allocated. */
&& !TREE_STATIC (decl))
{
- fputs ("\t.weak_reference ", asm_out_file);
- assemble_name (asm_out_file, sym_name);
- fputc ('\n', asm_out_file);
+ fputs ("\t.weak_reference ", out_file);
+ assemble_name (out_file, sym_name);
+ fputc ('\n', out_file);
}
}
- assemble_name (asm_out_file, ptr_name);
- fprintf (asm_out_file, ":\n");
+ assemble_name (out_file, ptr_name);
+ fprintf (out_file, ":\n");
- fprintf (asm_out_file, "\t.indirect_symbol ");
- assemble_name (asm_out_file, sym_name);
- fprintf (asm_out_file, "\n");
+ fprintf (out_file, "\t.indirect_symbol ");
+ assemble_name (out_file, sym_name);
+ fprintf (out_file, "\n");
/* Variables that are marked with MACHO_SYMBOL_FLAG_STATIC need to
have their symbol name instead of 0 in the second entry of
}
static void
-machopic_finish (FILE *asm_out_file)
+machopic_finish (FILE *out_file)
{
if (!machopic_indirections)
return;
/* First output an symbol indirections that have been placed into .data
(we don't expect these now). */
machopic_indirections->traverse_noresize
- <FILE *, machopic_output_data_section_indirection> (asm_out_file);
+ <FILE *, machopic_output_data_section_indirection> (out_file);
machopic_indirections->traverse_noresize
- <FILE *, machopic_output_stub_indirection> (asm_out_file);
+ <FILE *, machopic_output_stub_indirection> (out_file);
machopic_indirections->traverse_noresize
- <FILE *, machopic_output_indirection> (asm_out_file);
+ <FILE *, machopic_output_indirection> (out_file);
}
int
/* Write the extra assembler code needed to declare a function properly. */
void
-ix86_asm_output_function_label (FILE *asm_out_file, const char *fname,
+ix86_asm_output_function_label (FILE *out_file, const char *fname,
tree decl)
{
bool is_ms_hook = ix86_function_ms_hook_prologue (decl);
unsigned int filler_cc = 0xcccccccc;
for (i = 0; i < filler_count; i += 4)
- fprintf (asm_out_file, ASM_LONG " %#x\n", filler_cc);
+ fprintf (out_file, ASM_LONG " %#x\n", filler_cc);
}
#ifdef SUBTARGET_ASM_UNWIND_INIT
- SUBTARGET_ASM_UNWIND_INIT (asm_out_file);
+ SUBTARGET_ASM_UNWIND_INIT (out_file);
#endif
- ASM_OUTPUT_LABEL (asm_out_file, fname);
+ ASM_OUTPUT_LABEL (out_file, fname);
/* Output magic byte marker, if hot-patch attribute is set. */
if (is_ms_hook)
{
/* leaq [%rsp + 0], %rsp */
fputs (ASM_BYTE "0x48, 0x8d, 0xa4, 0x24, 0x00, 0x00, 0x00, 0x00\n",
- asm_out_file);
+ out_file);
}
else
{
/* movl.s %edi, %edi
push %ebp
movl.s %esp, %ebp */
- fputs (ASM_BYTE "0x8b, 0xff, 0x55, 0x8b, 0xec\n", asm_out_file);
+ fputs (ASM_BYTE "0x8b, 0xff, 0x55, 0x8b, 0xec\n", out_file);
}
}
}
required for unwind of this insn. */
void
-i386_pe_seh_unwind_emit (FILE *asm_out_file, rtx_insn *insn)
+i386_pe_seh_unwind_emit (FILE *out_file, rtx_insn *insn)
{
rtx note, pat;
bool handled_one = false;
/* See ix86_seh_fixup_eh_fallthru for the rationale. */
rtx_insn *prev = prev_active_insn (insn);
if (prev && !insn_nothrow_p (prev))
- fputs ("\tnop\n", asm_out_file);
- fputs ("\t.seh_endproc\n", asm_out_file);
+ fputs ("\tnop\n", out_file);
+ fputs ("\t.seh_endproc\n", out_file);
seh->in_cold_section = true;
return;
}
if (GET_CODE (pat) == PARALLEL)
pat = XVECEXP (pat, 0, 0);
}
- seh_cfa_adjust_cfa (asm_out_file, seh, pat);
+ seh_cfa_adjust_cfa (out_file, seh, pat);
handled_one = true;
break;
pat = XEXP (note, 0);
if (pat == NULL)
pat = single_set (insn);
- seh_cfa_offset (asm_out_file, seh, pat);
+ seh_cfa_offset (out_file, seh, pat);
handled_one = true;
break;
return;
pat = PATTERN (insn);
found:
- seh_frame_related_expr (asm_out_file, seh, pat);
+ seh_frame_related_expr (out_file, seh, pat);
}
void
/* The function emits unwind directives for the start of an epilogue. */
static void
-process_epilogue (FILE *asm_out_file, rtx insn ATTRIBUTE_UNUSED,
+process_epilogue (FILE *out_file, rtx insn ATTRIBUTE_UNUSED,
bool unwind, bool frame ATTRIBUTE_UNUSED)
{
/* If this isn't the last block of the function, then we need to label the
if (!last_block)
{
if (unwind)
- fprintf (asm_out_file, "\t.label_state %d\n",
+ fprintf (out_file, "\t.label_state %d\n",
++cfun->machine->state_num);
need_copy_state = true;
}
if (unwind)
- fprintf (asm_out_file, "\t.restore sp\n");
+ fprintf (out_file, "\t.restore sp\n");
}
/* This function processes a SET pattern for REG_CFA_ADJUST_CFA. */
static void
-process_cfa_adjust_cfa (FILE *asm_out_file, rtx pat, rtx insn,
+process_cfa_adjust_cfa (FILE *out_file, rtx pat, rtx insn,
bool unwind, bool frame)
{
rtx dest = SET_DEST (pat);
{
gcc_assert (!frame_pointer_needed);
if (unwind)
- fprintf (asm_out_file,
+ fprintf (out_file,
"\t.fframe " HOST_WIDE_INT_PRINT_DEC"\n",
-INTVAL (op1));
}
else
- process_epilogue (asm_out_file, insn, unwind, frame);
+ process_epilogue (out_file, insn, unwind, frame);
}
else
{
gcc_assert (src == hard_frame_pointer_rtx);
- process_epilogue (asm_out_file, insn, unwind, frame);
+ process_epilogue (out_file, insn, unwind, frame);
}
}
else if (dest == hard_frame_pointer_rtx)
gcc_assert (frame_pointer_needed);
if (unwind)
- fprintf (asm_out_file, "\t.vframe r%d\n",
+ fprintf (out_file, "\t.vframe r%d\n",
ia64_dbx_register_number (REGNO (dest)));
}
else
/* This function processes a SET pattern for REG_CFA_REGISTER. */
static void
-process_cfa_register (FILE *asm_out_file, rtx pat, bool unwind)
+process_cfa_register (FILE *out_file, rtx pat, bool unwind)
{
rtx dest = SET_DEST (pat);
rtx src = SET_SRC (pat);
{
/* Saving return address pointer. */
if (unwind)
- fprintf (asm_out_file, "\t.save rp, r%d\n",
+ fprintf (out_file, "\t.save rp, r%d\n",
ia64_dbx_register_number (dest_regno));
return;
}
case PR_REG (0):
gcc_assert (dest_regno == current_frame_info.r[reg_save_pr]);
if (unwind)
- fprintf (asm_out_file, "\t.save pr, r%d\n",
+ fprintf (out_file, "\t.save pr, r%d\n",
ia64_dbx_register_number (dest_regno));
break;
case AR_UNAT_REGNUM:
gcc_assert (dest_regno == current_frame_info.r[reg_save_ar_unat]);
if (unwind)
- fprintf (asm_out_file, "\t.save ar.unat, r%d\n",
+ fprintf (out_file, "\t.save ar.unat, r%d\n",
ia64_dbx_register_number (dest_regno));
break;
case AR_LC_REGNUM:
gcc_assert (dest_regno == current_frame_info.r[reg_save_ar_lc]);
if (unwind)
- fprintf (asm_out_file, "\t.save ar.lc, r%d\n",
+ fprintf (out_file, "\t.save ar.lc, r%d\n",
ia64_dbx_register_number (dest_regno));
break;
/* This function processes a SET pattern for REG_CFA_OFFSET. */
static void
-process_cfa_offset (FILE *asm_out_file, rtx pat, bool unwind)
+process_cfa_offset (FILE *out_file, rtx pat, bool unwind)
{
rtx dest = SET_DEST (pat);
rtx src = SET_SRC (pat);
case BR_REG (0):
gcc_assert (!current_frame_info.r[reg_save_b0]);
if (unwind)
- fprintf (asm_out_file, "\t%s rp, " HOST_WIDE_INT_PRINT_DEC "\n",
+ fprintf (out_file, "\t%s rp, " HOST_WIDE_INT_PRINT_DEC "\n",
saveop, off);
break;
case PR_REG (0):
gcc_assert (!current_frame_info.r[reg_save_pr]);
if (unwind)
- fprintf (asm_out_file, "\t%s pr, " HOST_WIDE_INT_PRINT_DEC "\n",
+ fprintf (out_file, "\t%s pr, " HOST_WIDE_INT_PRINT_DEC "\n",
saveop, off);
break;
case AR_LC_REGNUM:
gcc_assert (!current_frame_info.r[reg_save_ar_lc]);
if (unwind)
- fprintf (asm_out_file, "\t%s ar.lc, " HOST_WIDE_INT_PRINT_DEC "\n",
+ fprintf (out_file, "\t%s ar.lc, " HOST_WIDE_INT_PRINT_DEC "\n",
saveop, off);
break;
case AR_PFS_REGNUM:
gcc_assert (!current_frame_info.r[reg_save_ar_pfs]);
if (unwind)
- fprintf (asm_out_file, "\t%s ar.pfs, " HOST_WIDE_INT_PRINT_DEC "\n",
+ fprintf (out_file, "\t%s ar.pfs, " HOST_WIDE_INT_PRINT_DEC "\n",
saveop, off);
break;
case AR_UNAT_REGNUM:
gcc_assert (!current_frame_info.r[reg_save_ar_unat]);
if (unwind)
- fprintf (asm_out_file, "\t%s ar.unat, " HOST_WIDE_INT_PRINT_DEC "\n",
+ fprintf (out_file, "\t%s ar.unat, " HOST_WIDE_INT_PRINT_DEC "\n",
saveop, off);
break;
case GR_REG (6):
case GR_REG (7):
if (unwind)
- fprintf (asm_out_file, "\t.save.g 0x%x\n",
+ fprintf (out_file, "\t.save.g 0x%x\n",
1 << (src_regno - GR_REG (4)));
break;
case BR_REG (4):
case BR_REG (5):
if (unwind)
- fprintf (asm_out_file, "\t.save.b 0x%x\n",
+ fprintf (out_file, "\t.save.b 0x%x\n",
1 << (src_regno - BR_REG (1)));
break;
case FR_REG (4):
case FR_REG (5):
if (unwind)
- fprintf (asm_out_file, "\t.save.f 0x%x\n",
+ fprintf (out_file, "\t.save.f 0x%x\n",
1 << (src_regno - FR_REG (2)));
break;
case FR_REG (24): case FR_REG (25): case FR_REG (26): case FR_REG (27):
case FR_REG (28): case FR_REG (29): case FR_REG (30): case FR_REG (31):
if (unwind)
- fprintf (asm_out_file, "\t.save.gf 0x0, 0x%x\n",
+ fprintf (out_file, "\t.save.gf 0x0, 0x%x\n",
1 << (src_regno - FR_REG (12)));
break;
required to unwind this insn. */
static void
-ia64_asm_unwind_emit (FILE *asm_out_file, rtx_insn *insn)
+ia64_asm_unwind_emit (FILE *out_file, rtx_insn *insn)
{
bool unwind = ia64_except_unwind_info (&global_options) == UI_TARGET;
bool frame = dwarf2out_do_frame ();
{
if (unwind)
{
- fprintf (asm_out_file, "\t.body\n");
- fprintf (asm_out_file, "\t.copy_state %d\n",
+ fprintf (out_file, "\t.body\n");
+ fprintf (out_file, "\t.copy_state %d\n",
cfun->machine->state_num);
}
need_copy_state = false;
if (dest_regno == current_frame_info.r[reg_save_ar_pfs])
{
if (unwind)
- fprintf (asm_out_file, "\t.save ar.pfs, r%d\n",
+ fprintf (out_file, "\t.save ar.pfs, r%d\n",
ia64_dbx_register_number (dest_regno));
}
else
sp" now. */
if (current_frame_info.total_size == 0 && !frame_pointer_needed)
/* if haven't done process_epilogue() yet, do it now */
- process_epilogue (asm_out_file, insn, unwind, frame);
+ process_epilogue (out_file, insn, unwind, frame);
if (unwind)
- fprintf (asm_out_file, "\t.prologue\n");
+ fprintf (out_file, "\t.prologue\n");
}
return;
}
pat = XEXP (note, 0);
if (pat == NULL)
pat = PATTERN (insn);
- process_cfa_adjust_cfa (asm_out_file, pat, insn, unwind, frame);
+ process_cfa_adjust_cfa (out_file, pat, insn, unwind, frame);
handled_one = true;
break;
pat = XEXP (note, 0);
if (pat == NULL)
pat = PATTERN (insn);
- process_cfa_offset (asm_out_file, pat, unwind);
+ process_cfa_offset (out_file, pat, unwind);
handled_one = true;
break;
pat = XEXP (note, 0);
if (pat == NULL)
pat = PATTERN (insn);
- process_cfa_register (asm_out_file, pat, unwind);
+ process_cfa_register (out_file, pat, unwind);
handled_one = true;
break;
/* Write the extra assembler code needed to declare a function properly. */
void
-s390_asm_output_function_label (FILE *asm_out_file, const char *fname,
+s390_asm_output_function_label (FILE *out_file, const char *fname,
tree decl)
{
int hw_before, hw_after;
/* Add a trampoline code area before the function label and initialize it
with two-byte nop instructions. This area can be overwritten with code
that jumps to a patched version of the function. */
- asm_fprintf (asm_out_file, "\tnopr\t%%r0"
+ asm_fprintf (out_file, "\tnopr\t%%r0"
"\t# pre-label NOPs for hotpatch (%d halfwords)\n",
hw_before);
for (i = 1; i < hw_before; i++)
- fputs ("\tnopr\t%r0\n", asm_out_file);
+ fputs ("\tnopr\t%r0\n", out_file);
/* Note: The function label must be aligned so that (a) the bytes of the
following nop do not cross a cacheline boundary, and (b) a jump address
function_alignment
= MAX (function_alignment,
(unsigned int) align_functions.levels[0].get_value ());
- fputs ("\t# alignment for hotpatch\n", asm_out_file);
- ASM_OUTPUT_ALIGN (asm_out_file, align_functions.levels[0].log);
+ fputs ("\t# alignment for hotpatch\n", out_file);
+ ASM_OUTPUT_ALIGN (out_file, align_functions.levels[0].log);
}
if (S390_USE_TARGET_ATTRIBUTE && TARGET_DEBUG_ARG)
{
- asm_fprintf (asm_out_file, "\t# fn:%s ar%d\n", fname, s390_arch);
- asm_fprintf (asm_out_file, "\t# fn:%s tu%d\n", fname, s390_tune);
- asm_fprintf (asm_out_file, "\t# fn:%s sg%d\n", fname, s390_stack_guard);
- asm_fprintf (asm_out_file, "\t# fn:%s ss%d\n", fname, s390_stack_size);
- asm_fprintf (asm_out_file, "\t# fn:%s bc%d\n", fname, s390_branch_cost);
- asm_fprintf (asm_out_file, "\t# fn:%s wf%d\n", fname,
+ asm_fprintf (out_file, "\t# fn:%s ar%d\n", fname, s390_arch);
+ asm_fprintf (out_file, "\t# fn:%s tu%d\n", fname, s390_tune);
+ asm_fprintf (out_file, "\t# fn:%s sg%d\n", fname, s390_stack_guard);
+ asm_fprintf (out_file, "\t# fn:%s ss%d\n", fname, s390_stack_size);
+ asm_fprintf (out_file, "\t# fn:%s bc%d\n", fname, s390_branch_cost);
+ asm_fprintf (out_file, "\t# fn:%s wf%d\n", fname,
s390_warn_framesize);
- asm_fprintf (asm_out_file, "\t# fn:%s ba%d\n", fname, TARGET_BACKCHAIN);
- asm_fprintf (asm_out_file, "\t# fn:%s hd%d\n", fname, TARGET_HARD_DFP);
- asm_fprintf (asm_out_file, "\t# fn:%s hf%d\n", fname, !TARGET_SOFT_FLOAT);
- asm_fprintf (asm_out_file, "\t# fn:%s ht%d\n", fname, TARGET_OPT_HTM);
- asm_fprintf (asm_out_file, "\t# fn:%s vx%d\n", fname, TARGET_OPT_VX);
- asm_fprintf (asm_out_file, "\t# fn:%s ps%d\n", fname,
+ asm_fprintf (out_file, "\t# fn:%s ba%d\n", fname, TARGET_BACKCHAIN);
+ asm_fprintf (out_file, "\t# fn:%s hd%d\n", fname, TARGET_HARD_DFP);
+ asm_fprintf (out_file, "\t# fn:%s hf%d\n", fname, !TARGET_SOFT_FLOAT);
+ asm_fprintf (out_file, "\t# fn:%s ht%d\n", fname, TARGET_OPT_HTM);
+ asm_fprintf (out_file, "\t# fn:%s vx%d\n", fname, TARGET_OPT_VX);
+ asm_fprintf (out_file, "\t# fn:%s ps%d\n", fname,
TARGET_PACKED_STACK);
- asm_fprintf (asm_out_file, "\t# fn:%s se%d\n", fname, TARGET_SMALL_EXEC);
- asm_fprintf (asm_out_file, "\t# fn:%s mv%d\n", fname, TARGET_MVCLE);
- asm_fprintf (asm_out_file, "\t# fn:%s zv%d\n", fname, TARGET_ZVECTOR);
- asm_fprintf (asm_out_file, "\t# fn:%s wd%d\n", fname,
+ asm_fprintf (out_file, "\t# fn:%s se%d\n", fname, TARGET_SMALL_EXEC);
+ asm_fprintf (out_file, "\t# fn:%s mv%d\n", fname, TARGET_MVCLE);
+ asm_fprintf (out_file, "\t# fn:%s zv%d\n", fname, TARGET_ZVECTOR);
+ asm_fprintf (out_file, "\t# fn:%s wd%d\n", fname,
s390_warn_dynamicstack_p);
}
- ASM_OUTPUT_LABEL (asm_out_file, fname);
+ ASM_OUTPUT_LABEL (out_file, fname);
if (hw_after > 0)
- asm_fprintf (asm_out_file,
+ asm_fprintf (out_file,
"\t# post-label NOPs for hotpatch (%d halfwords)\n",
hw_after);
}
projects / thirdparty / gcc.git / commitdiff
