static void load_reg PARAMS ((int, int, int));
static void set_reg_plus_d PARAMS ((int, int, int, int));
static void pa_output_function_prologue PARAMS ((FILE *, HOST_WIDE_INT));
+static void update_total_code_bytes PARAMS ((int));
static void pa_output_function_epilogue PARAMS ((FILE *, HOST_WIDE_INT));
static int pa_adjust_cost PARAMS ((rtx, rtx, rtx, int));
static int pa_adjust_priority PARAMS ((rtx, int));
static rtx find_addr_reg PARAMS ((rtx));
-/* Keep track of the number of bytes we have output in the CODE subspaces
+/* Keep track of the number of bytes we have output in the CODE subspace
during this compilation so we'll know when to emit inline long-calls. */
unsigned long total_code_bytes;
+/* The last address of the previous function plus the number of bytes in
+ associated thunks that have been output. This is used to determine if
+ a thunk can use an IA-relative branch to reach its target function. */
+static int last_address;
+
/* Variables to handle plabels that we discover are necessary at assembly
output time. They are output after the current function. */
struct deferred_plabel GTY(())
size += TARGET_64BIT ? 48 : 32;
/* Finally, round to the preferred stack boundary. */
- return ((size + PREFERRED_STACK_BOUNDARY / 8 - 1)
- & ~(PREFERRED_STACK_BOUNDARY / 8 - 1));
+ return ((size + PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT - 1)
+ & ~(PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT - 1));
}
/* Generate the assembly code for function entry. FILE is a stdio
}
}
+/* Update the total code bytes output to the text section. */
+
+static void
+update_total_code_bytes (nbytes)
+ int nbytes;
+{
+ if ((TARGET_PORTABLE_RUNTIME || !TARGET_GAS || !TARGET_SOM)
+ && in_text_section ())
+ {
+ if (INSN_ADDRESSES_SET_P ())
+ {
+ unsigned long old_total = total_code_bytes;
+
+ total_code_bytes += nbytes;
+
+ /* Be prepared to handle overflows. */
+ if (old_total > total_code_bytes)
+ total_code_bytes = -1;
+ }
+ else
+ total_code_bytes = -1;
+ }
+}
+
/* This function generates the assembly code for function exit.
Args are as for output_function_prologue ().
FILE *file;
HOST_WIDE_INT size ATTRIBUTE_UNUSED;
{
- int last_address = 0;
rtx insn = get_last_insn ();
+ last_address = 0;
+
/* hppa_expand_epilogue does the dirty work now. We just need
to output the assembler directives which denote the end
of a function.
fputs ("\t.EXIT\n\t.PROCEND\n", file);
- /* Finally, update the total number of code bytes output so far. */
- if ((TARGET_PORTABLE_RUNTIME || !TARGET_GAS || !TARGET_SOM)
- && !flag_function_sections)
+ if (INSN_ADDRESSES_SET_P ())
{
- if (INSN_ADDRESSES_SET_P ())
- {
- unsigned long old_total = total_code_bytes;
-
- insn = get_last_nonnote_insn ();
- last_address += INSN_ADDRESSES (INSN_UID (insn));
- if (INSN_P (insn))
- last_address += insn_default_length (insn);
-
- total_code_bytes += last_address;
- total_code_bytes += FUNCTION_BOUNDARY / BITS_PER_UNIT;
-
- /* Be prepared to handle overflows. */
- if (old_total > total_code_bytes)
- total_code_bytes = -1;
- }
- else
- total_code_bytes = -1;
+ insn = get_last_nonnote_insn ();
+ last_address += INSN_ADDRESSES (INSN_UID (insn));
+ if (INSN_P (insn))
+ last_address += insn_default_length (insn);
+ last_address = ((last_address + FUNCTION_BOUNDARY / BITS_PER_UNIT - 1)
+ & ~(FUNCTION_BOUNDARY / BITS_PER_UNIT - 1));
}
+
+ /* Finally, update the total number of code bytes output so far. */
+ update_total_code_bytes (last_address);
}
void
output_asm_insn ("stw %%r1,-12(%%r30)", xoperands);
}
- if (flag_pic)
+ if (TARGET_PORTABLE_RUNTIME)
+ {
+ output_asm_insn ("ldil L'%0,%%r1", xoperands);
+ output_asm_insn ("ldo R'%0(%%r1),%%r1", xoperands);
+ output_asm_insn ("bv %%r0(%%r1)", xoperands);
+ }
+ else if (flag_pic)
{
output_asm_insn ("{bl|b,l} .+8,%%r1", xoperands);
if (TARGET_SOM || !TARGET_GAS)
rtx insn;
{
unsigned long distance = -1;
+ unsigned long total = in_text_section () ? total_code_bytes : 0;
if (INSN_ADDRESSES_SET_P ())
{
- distance = (total_code_bytes + insn_current_reference_address (insn));
- if (distance < total_code_bytes)
+ distance = (total + insn_current_reference_address (insn));
+ if (distance < total)
distance = -1;
}
int sibcall;
{
unsigned long distance = -1;
+ unsigned long total = in_text_section ()? total_code_bytes : 0;
if (INSN_ADDRESSES_SET_P ())
{
- distance = (total_code_bytes + insn_current_reference_address (insn));
- if (distance < total_code_bytes)
+ distance = (total + insn_current_reference_address (insn));
+ if (distance < total)
distance = -1;
}
int delay_insn_deleted = 0;
int delay_slot_filled = 0;
int seq_length = dbr_sequence_length ();
+ tree call_decl = SYMBOL_REF_DECL (call_dest);
+ int local_call = call_decl && !TREE_PUBLIC (call_decl);
rtx xoperands[2];
xoperands[0] = call_dest;
/* Handle the common case where we're sure that the branch will reach
- the beginning of the $CODE$ subspace. */
+ the beginning of the "$CODE$" subspace. This is the beginning of
+ the current function if we are in a named section. */
if (!TARGET_LONG_CALLS && attr_length_call (insn, sibcall) == 8)
{
xoperands[1] = gen_rtx_REG (word_mode, sibcall ? 0 : 2);
}
else
{
- if (TARGET_64BIT)
+ if (TARGET_64BIT && !local_call)
{
/* ??? As far as I can tell, the HP linker doesn't support the
long pc-relative sequence described in the 64-bit runtime
/* Emit a long call. There are several different sequences
of increasing length and complexity. In most cases,
they don't allow an instruction in the delay slot. */
- if (!(TARGET_LONG_ABS_CALL && !flag_pic)
+ if (!((TARGET_LONG_ABS_CALL || local_call) && !flag_pic)
&& !(TARGET_SOM && TARGET_LONG_PIC_SDIFF_CALL)
- && !(TARGET_GAS && TARGET_LONG_PIC_PCREL_CALL))
+ && !(TARGET_GAS && (TARGET_LONG_PIC_PCREL_CALL || local_call))
+ && !TARGET_64BIT)
indirect_call = 1;
if (seq_length != 0
delay_insn_deleted = 1;
}
- if (TARGET_LONG_ABS_CALL && !flag_pic)
+ if ((TARGET_LONG_ABS_CALL || local_call) && !flag_pic)
{
/* This is the best sequence for making long calls in
non-pic code. Unfortunately, GNU ld doesn't provide
the stub needed for external calls, and GAS's support
- for this with the SOM linker is buggy. */
+ for this with the SOM linker is buggy. It is safe
+ to use this for local calls. */
output_asm_insn ("ldil L'%0,%%r1", xoperands);
if (sibcall)
output_asm_insn ("be R'%0(%%sr4,%%r1)", xoperands);
}
else
{
- if (TARGET_SOM && TARGET_LONG_PIC_SDIFF_CALL)
+ if ((TARGET_SOM && TARGET_LONG_PIC_SDIFF_CALL)
+ || (TARGET_64BIT && !TARGET_GAS))
{
/* The HP assembler and linker can handle relocations
for the difference of two symbols. GAS and the HP
CODE_LABEL_NUMBER (xoperands[1]));
output_asm_insn ("ldo R'%0-%l1(%%r1),%%r1", xoperands);
}
- else if (TARGET_GAS && TARGET_LONG_PIC_PCREL_CALL)
+ else if (TARGET_GAS && (TARGET_LONG_PIC_PCREL_CALL || local_call))
{
/* GAS currently can't generate the relocations that
are needed for the SOM linker under HP-UX using this
CODE_LABEL_NUMBER (xoperands[1]));
}
else
- /* ??? This branch may not reach its target. */
output_asm_insn ("nop\n\tb,n %0", xoperands);
}
else
- /* ??? This branch may not reach its target. */
output_asm_insn ("b,n %0", xoperands);
/* Delete the jump. */
rtx insn;
{
unsigned long distance = -1;
+ unsigned long total = in_text_section () ? total_code_bytes : 0;
if (INSN_ADDRESSES_SET_P ())
{
- distance = (total_code_bytes + insn_current_reference_address (insn));
- if (distance < total_code_bytes)
+ distance = (total + insn_current_reference_address (insn));
+ if (distance < total)
distance = -1;
}
HOST_WIDE_INT vcall_offset ATTRIBUTE_UNUSED;
tree function;
{
- const char *target_name = XSTR (XEXP (DECL_RTL (function), 0), 0);
+ const char *fname = XSTR (XEXP (DECL_RTL (function), 0), 0);
+ const char *tname = XSTR (XEXP (DECL_RTL (thunk_fndecl), 0), 0);
+ int val_14 = VAL_14_BITS_P (delta);
+ int nbytes = 0;
static unsigned int current_thunk_number;
char label[16];
- const char *lab;
- ASM_GENERATE_INTERNAL_LABEL (label, "LTHN", current_thunk_number);
- lab = (*targetm.strip_name_encoding) (label);
- target_name = (*targetm.strip_name_encoding) (target_name);
- /* FIXME: total_code_bytes is not handled correctly in files with
- mi thunks. */
- pa_output_function_prologue (file, 0);
- if (VAL_14_BITS_P (delta))
- {
- if (!TARGET_64BIT && !TARGET_PORTABLE_RUNTIME && flag_pic)
- {
- fprintf (file, "\taddil LT'%s,%%r19\n", lab);
- fprintf (file, "\tldw RT'%s(%%r1),%%r22\n", lab);
- fprintf (file, "\tldw 0(%%sr0,%%r22),%%r22\n");
- fprintf (file, "\tbb,>=,n %%r22,30,.+16\n");
- fprintf (file, "\tdepi 0,31,2,%%r22\n");
- fprintf (file, "\tldw 4(%%sr0,%%r22),%%r19\n");
- fprintf (file, "\tldw 0(%%sr0,%%r22),%%r22\n");
+
+ ASM_OUTPUT_LABEL (file, tname);
+ fprintf (file, "\t.PROC\n\t.CALLINFO FRAME=0,NO_CALLS\n\t.ENTRY\n");
+
+ fname = (*targetm.strip_name_encoding) (fname);
+ tname = (*targetm.strip_name_encoding) (tname);
+
+ /* Output the thunk. We know that the function is in the same
+ translation unit (i.e., the same space) as the thunk, and that
+ thunks are output after their method. Thus, we don't need an
+ external branch to reach the function. With SOM and GAS,
+ functions and thunks are effectively in different sections.
+ Thus, we can always use a IA-relative branch and the linker
+ will add a long branch stub if necessary.
+
+ However, we have to be careful when generating PIC code on the
+ SOM port to ensure that the sequence does not transfer to an
+ import stub for the target function as this could clobber the
+ return value saved at SP-24. This would also apply to the
+ 32-bit linux port if the multi-space model is implemented. */
+ if ((!TARGET_LONG_CALLS && TARGET_SOM && !TARGET_PORTABLE_RUNTIME
+ && !(flag_pic && TREE_PUBLIC (function))
+ && (TARGET_GAS || last_address < 262132))
+ || (!TARGET_LONG_CALLS && !TARGET_SOM && !TARGET_PORTABLE_RUNTIME
+ && ((targetm.have_named_sections
+ && DECL_SECTION_NAME (thunk_fndecl) != NULL
+ /* The GNU 64-bit linker has rather poor stub management.
+ So, we use a long branch from thunks that aren't in
+ the same section as the target function. */
+ && ((!TARGET_64BIT
+ && (DECL_SECTION_NAME (thunk_fndecl)
+ != DECL_SECTION_NAME (function)))
+ || ((DECL_SECTION_NAME (thunk_fndecl)
+ == DECL_SECTION_NAME (function))
+ && last_address < 262132)))
+ || (!targetm.have_named_sections && last_address < 262132))))
+ {
+ if (val_14)
+ {
+ fprintf (file, "\tb %s\n\tldo " HOST_WIDE_INT_PRINT_DEC
+ "(%%r26),%%r26\n", fname, delta);
+ nbytes += 8;
+ }
+ else
+ {
+ fprintf (file, "\taddil L'" HOST_WIDE_INT_PRINT_DEC
+ ",%%r26\n", delta);
+ fprintf (file, "\tb %s\n\tldo R'" HOST_WIDE_INT_PRINT_DEC
+ "(%%r1),%%r26\n", fname, delta);
+ nbytes += 12;
+ }
+ }
+ else if (TARGET_64BIT)
+ {
+ /* We only have one call-clobbered scratch register, so we can't
+ make use of the delay slot if delta doesn't fit in 14 bits. */
+ if (!val_14)
+ fprintf (file, "\taddil L'" HOST_WIDE_INT_PRINT_DEC
+ ",%%r26\n\tldo R'" HOST_WIDE_INT_PRINT_DEC
+ "(%%r1),%%r26\n", delta, delta);
+
+ fprintf (file, "\tb,l .+8,%%r1\n");
+
+ if (TARGET_GAS)
+ {
+ fprintf (file, "\taddil L'%s-$PIC_pcrel$0+4,%%r1\n", fname);
+ fprintf (file, "\tldo R'%s-$PIC_pcrel$0+8(%%r1),%%r1\n", fname);
+ }
+ else
+ {
+ int off = val_14 ? 8 : 16;
+ fprintf (file, "\taddil L'%s-%s-%d,%%r1\n", fname, tname, off);
+ fprintf (file, "\tldo R'%s-%s-%d(%%r1),%%r1\n", fname, tname, off);
+ }
+
+ if (val_14)
+ {
+ fprintf (file, "\tbv %%r0(%%r1)\n\tldo ");
+ fprintf (file, HOST_WIDE_INT_PRINT_DEC "(%%r26),%%r26\n", delta);
+ nbytes += 20;
+ }
+ else
+ {
+ fprintf (file, "\tbv,n %%r0(%%r1)\n");
+ nbytes += 24;
+ }
+ }
+ else if (TARGET_PORTABLE_RUNTIME)
+ {
+ fprintf (file, "\tldil L'%s,%%r1\n", fname);
+ fprintf (file, "\tldo R'%s(%%r1),%%r22\n", fname);
+
+ if (val_14)
+ {
+ fprintf (file, "\tbv %%r0(%%r22)\n\tldo ");
+ fprintf (file, HOST_WIDE_INT_PRINT_DEC "(%%r26),%%r26\n", delta);
+ nbytes += 16;
+ }
+ else
+ {
+ fprintf (file, "\taddil L'" HOST_WIDE_INT_PRINT_DEC
+ ",%%r26\n", delta);
+ fprintf (file, "\tbv %%r0(%%r22)\n\tldo ");
+ fprintf (file, "R'" HOST_WIDE_INT_PRINT_DEC "(%%r1),%%r26\n", delta);
+ nbytes += 20;
+ }
+ }
+ else if (TARGET_SOM && flag_pic && TREE_PUBLIC (function))
+ {
+ /* The function is accessible from outside this module. The only
+ way to avoid an import stub between the thunk and function is to
+ call the function directly with an indirect sequence similar to
+ that used by $$dyncall. This is possible because $$dyncall acts
+ as the import stub in an indirect call. */
+ const char *lab;
+
+ ASM_GENERATE_INTERNAL_LABEL (label, "LTHN", current_thunk_number);
+ lab = (*targetm.strip_name_encoding) (label);
+
+ fprintf (file, "\taddil LT'%s,%%r19\n", lab);
+ fprintf (file, "\tldw RT'%s(%%r1),%%r22\n", lab);
+ fprintf (file, "\tldw 0(%%sr0,%%r22),%%r22\n");
+ fprintf (file, "\tbb,>=,n %%r22,30,.+16\n");
+ fprintf (file, "\tdepi 0,31,2,%%r22\n");
+ fprintf (file, "\tldw 4(%%sr0,%%r22),%%r19\n");
+ fprintf (file, "\tldw 0(%%sr0,%%r22),%%r22\n");
+ if (!val_14)
+ {
+ fprintf (file, "\taddil L'" HOST_WIDE_INT_PRINT_DEC
+ ",%%r26\n", delta);
+ nbytes += 4;
+ }
+ if (TARGET_PA_20)
+ {
+ fprintf (file, "\tbve (%%r22)\n\tldo ");
+ nbytes += 36;
+ }
+ else
+ {
if (TARGET_NO_SPACE_REGS)
- fprintf (file, "\tbe 0(%%sr4,%%r22)\n\tldo ");
+ {
+ fprintf (file, "\tbe 0(%%sr4,%%r22)\n\tldo ");
+ nbytes += 36;
+ }
else
{
fprintf (file, "\tldsid (%%sr0,%%r22),%%r1\n");
- fprintf (file, "\tmtsp %%r1,%%sr0\n");
+ fprintf (file, "\tmtsp %%r21,%%sr0\n");
fprintf (file, "\tbe 0(%%sr0,%%r22)\n\tldo ");
+ nbytes += 44;
}
+ }
+
+ if (val_14)
+ fprintf (file, HOST_WIDE_INT_PRINT_DEC "(%%r26),%%r26\n", delta);
+ else
+ fprintf (file, "R'" HOST_WIDE_INT_PRINT_DEC "(%%r1),%%r26\n", delta);
+ }
+ else if (flag_pic)
+ {
+ if (TARGET_PA_20)
+ fprintf (file, "\tb,l .+8,%%r1\n");
+ else
+ fprintf (file, "\tbl .+8,%%r1\n");
+
+ if (TARGET_SOM || !TARGET_GAS)
+ {
+ fprintf (file, "\taddil L'%s-%s-8,%%r1\n", fname, tname);
+ fprintf (file, "\tldo R'%s-%s-8(%%r1),%%r22\n", fname, tname);
+ }
+ else
+ {
+ fprintf (file, "\taddil L'%s-$PIC_pcrel$0+4,%%r1\n", fname);
+ fprintf (file, "\tldo R'%s-$PIC_pcrel$0+8(%%r1),%%r22\n", fname);
+ }
+
+ if (val_14)
+ {
+ fprintf (file, "\tbv %%r0(%%r22)\n\tldo ");
fprintf (file, HOST_WIDE_INT_PRINT_DEC "(%%r26),%%r26\n", delta);
+ nbytes += 20;
}
else
- fprintf (file, "\tb %s\n\tldo " HOST_WIDE_INT_PRINT_DEC
- "(%%r26),%%r26\n",
- target_name, delta);
+ {
+ fprintf (file, "\taddil L'" HOST_WIDE_INT_PRINT_DEC
+ ",%%r26\n", delta);
+ fprintf (file, "\tbv %%r0(%%r22)\n\tldo ");
+ fprintf (file, "R'" HOST_WIDE_INT_PRINT_DEC "(%%r1),%%r26\n", delta);
+ nbytes += 24;
+ }
}
else
{
- if (!TARGET_64BIT && !TARGET_PORTABLE_RUNTIME && flag_pic)
+ if (!val_14)
+ fprintf (file, "\taddil L'" HOST_WIDE_INT_PRINT_DEC ",%%r26\n", delta);
+
+ fprintf (file, "\tldil L'%s,%%r22\n", fname);
+ fprintf (file, "\tbe R'%s(%%sr4,%%r22)\n\tldo ", fname);
+
+ if (val_14)
{
- fprintf (file, "\taddil L'" HOST_WIDE_INT_PRINT_DEC
- ",%%r26\n\tldo R'" HOST_WIDE_INT_PRINT_DEC "(%%r1),%%r26\n",
- delta, delta);
- fprintf (file, "\taddil LT'%s,%%r19\n", lab);
- fprintf (file, "\tldw RT'%s(%%r1),%%r22\n", lab);
- fprintf (file, "\tldw 0(%%sr0,%%r22),%%r22\n");
- fprintf (file, "\tbb,>=,n %%r22,30,.+16\n");
- fprintf (file, "\tdepi 0,31,2,%%r22\n");
- fprintf (file, "\tldw 4(%%sr0,%%r22),%%r19\n");
- fprintf (file, "\tldw 0(%%sr0,%%r22),%%r22\n");
- if (TARGET_NO_SPACE_REGS)
- fprintf (file, "\tbe 0(%%sr4,%%r22)");
- else
- {
- fprintf (file, "\tldsid (%%sr0,%%r22),%%r1\n");
- fprintf (file, "\tmtsp %%r1,%%sr0\n");
- fprintf (file, "\tbe,n 0(%%sr0,%%r22)\n");
- }
+ fprintf (file, HOST_WIDE_INT_PRINT_DEC "(%%r26),%%r26\n", delta);
+ nbytes += 12;
}
else
- fprintf (file, "\taddil L'" HOST_WIDE_INT_PRINT_DEC
- ",%%r26\n\tb %s\n\tldo R'" HOST_WIDE_INT_PRINT_DEC
- "(%%r1),%%r26\n", delta, target_name, delta);
+ {
+ fprintf (file, "R'" HOST_WIDE_INT_PRINT_DEC "(%%r1),%%r26\n", delta);
+ nbytes += 16;
+ }
}
-
+
fprintf (file, "\t.EXIT\n\t.PROCEND\n");
- if (! TARGET_64BIT && ! TARGET_PORTABLE_RUNTIME && flag_pic)
+
+ if (TARGET_SOM && flag_pic && TREE_PUBLIC (function))
{
data_section ();
fprintf (file, "\t.align 4\n");
- (*targetm.asm_out.internal_label) (file, "LTHN", current_thunk_number);
- fprintf (file, "\t.word P'%s\n", target_name);
+ ASM_OUTPUT_LABEL (file, label);
+ fprintf (file, "\t.word P'%s\n", fname);
function_section (thunk_fndecl);
}
+
current_thunk_number++;
+ nbytes = ((nbytes + FUNCTION_BOUNDARY / BITS_PER_UNIT - 1)
+ & ~(FUNCTION_BOUNDARY / BITS_PER_UNIT - 1));
+ last_address += nbytes;
+ update_total_code_bytes (nbytes);
}
/* Only direct calls to static functions are allowed to be sibling (tail)
OSDN Git Service
