| Message ID | a8f00e77-07a2-5b8d-b5e5-3f5ebe2aada8@arm.com |
|---|---|
| State | New |
| Headers | show |
| Series | [v2] aarch64: emit .variant_pcs for aarch64_vector_pcs symbol references | expand |
Szabolcs Nagy <Szabolcs.Nagy@arm.com> writes: > v2: > - use aarch64_simd_decl_p to check for aarch64_vector_pcs. > - emit the .variant_pcs directive even for local functions. > - don't require .variant_pcs asm support in compile only tests. > - add weakref tests. > > A dynamic linker with lazy binding support may need to handle vector PCS > function symbols specially, so an ELF symbol table marking was > introduced for such symbols. > > Function symbol references and definitions that follow the vector PCS > are marked in the generated assembly with .variant_pcs and then the > STO_AARCH64_VARIANT_PCS st_other flag is set on the symbol in the object > file. The marking is propagated to the dynamic symbol table by the > static linker so a dynamic linker can handle such symbols specially. > > For this to work, the assembler, the static linker and the dynamic > linker has to be updated on a system. Old assembler does not support > the new .variant_pcs directive, so a toolchain with old binutils won't > be able to compile code that references vector PCS symbols. > > gcc/ChangeLog: > > 2019-05-28 Szabolcs Nagy <szabolcs.nagy@arm.com> > > * config/aarch64/aarch64-protos.h (aarch64_asm_output_alias): Declare. > (aarch64_asm_output_external): Declare. > * config/aarch64/aarch64.c (aarch64_asm_output_variant_pcs): New. > (aarch64_declare_function_name): Call aarch64_asm_output_variant_pcs. > (aarch64_asm_output_alias): New. > (aarch64_asm_output_external): New. > * config/aarch64/aarch64.h (ASM_OUTPUT_DEF_FROM_DECLS): Define. > (ASM_OUTPUT_EXTERNAL): Define. > > gcc/testsuite/ChangeLog: > > 2019-05-28 Szabolcs Nagy <szabolcs.nagy@arm.com> > > * gcc.target/aarch64/pcs_attribute-2.c: New test. > * gcc.target/aarch64/torture/simd-abi-4.c: Check .variant_pcs support. > * lib/target-supports.exp (check_effective_target_aarch64_variant_pcs): > New. LGTM, but an AArch64 maintainer will need to approve. > diff --git a/gcc/testsuite/gcc.target/aarch64/torture/simd-abi-4.c b/gcc/testsuite/gcc.target/aarch64/torture/simd-abi-4.c > index e399690f364..80ebd955e10 100644 > --- a/gcc/testsuite/gcc.target/aarch64/torture/simd-abi-4.c > +++ b/gcc/testsuite/gcc.target/aarch64/torture/simd-abi-4.c > @@ -1,4 +1,5 @@ > /* dg-do run */ > +/* { dg-require-effective-target aarch64_variant_pcs } */ > /* { dg-additional-options "-std=c99" } */ Not your problem of course, but mind fixing the dg-do markup while you're there? It should be /* { dg-do run } */ instead. As things stand, the test only gets compiled, not run. Thanks, Richard
On Wed, May 29, 2019 at 11:00:46AM +0100, Richard Sandiford wrote: > Szabolcs Nagy <Szabolcs.Nagy@arm.com> writes: > > v2: > > - use aarch64_simd_decl_p to check for aarch64_vector_pcs. > > - emit the .variant_pcs directive even for local functions. > > - don't require .variant_pcs asm support in compile only tests. > > - add weakref tests. > > > > A dynamic linker with lazy binding support may need to handle vector PCS > > function symbols specially, so an ELF symbol table marking was > > introduced for such symbols. > > > > Function symbol references and definitions that follow the vector PCS > > are marked in the generated assembly with .variant_pcs and then the > > STO_AARCH64_VARIANT_PCS st_other flag is set on the symbol in the object > > file. The marking is propagated to the dynamic symbol table by the > > static linker so a dynamic linker can handle such symbols specially. > > > > For this to work, the assembler, the static linker and the dynamic > > linker has to be updated on a system. Old assembler does not support > > the new .variant_pcs directive, so a toolchain with old binutils won't > > be able to compile code that references vector PCS symbols. > > > > gcc/ChangeLog: > > > > 2019-05-28 Szabolcs Nagy <szabolcs.nagy@arm.com> > > > > * config/aarch64/aarch64-protos.h (aarch64_asm_output_alias): Declare. > > (aarch64_asm_output_external): Declare. > > * config/aarch64/aarch64.c (aarch64_asm_output_variant_pcs): New. > > (aarch64_declare_function_name): Call aarch64_asm_output_variant_pcs. > > (aarch64_asm_output_alias): New. > > (aarch64_asm_output_external): New. > > * config/aarch64/aarch64.h (ASM_OUTPUT_DEF_FROM_DECLS): Define. > > (ASM_OUTPUT_EXTERNAL): Define. > > > > gcc/testsuite/ChangeLog: > > > > 2019-05-28 Szabolcs Nagy <szabolcs.nagy@arm.com> > > > > * gcc.target/aarch64/pcs_attribute-2.c: New test. > > * gcc.target/aarch64/torture/simd-abi-4.c: Check .variant_pcs support. > > * lib/target-supports.exp (check_effective_target_aarch64_variant_pcs): > > New. > > LGTM, but an AArch64 maintainer will need to approve. OK with Richard's change suggested below. Thanks, James > > > diff --git a/gcc/testsuite/gcc.target/aarch64/torture/simd-abi-4.c b/gcc/testsuite/gcc.target/aarch64/torture/simd-abi-4.c > > index e399690f364..80ebd955e10 100644 > > --- a/gcc/testsuite/gcc.target/aarch64/torture/simd-abi-4.c > > +++ b/gcc/testsuite/gcc.target/aarch64/torture/simd-abi-4.c > > @@ -1,4 +1,5 @@ > > /* dg-do run */ > > +/* { dg-require-effective-target aarch64_variant_pcs } */ > > /* { dg-additional-options "-std=c99" } */ > > Not your problem of course, but mind fixing the dg-do markup while > you're there? It should be > > /* { dg-do run } */ > > instead. As things stand, the test only gets compiled, not run. > > Thanks, > Richard
On Mon, 3 Jun 2019 at 13:28, James Greenhalgh <james.greenhalgh@arm.com> wrote: > > On Wed, May 29, 2019 at 11:00:46AM +0100, Richard Sandiford wrote: > > Szabolcs Nagy <Szabolcs.Nagy@arm.com> writes: > > > v2: > > > - use aarch64_simd_decl_p to check for aarch64_vector_pcs. > > > - emit the .variant_pcs directive even for local functions. > > > - don't require .variant_pcs asm support in compile only tests. > > > - add weakref tests. > > > > > > A dynamic linker with lazy binding support may need to handle vector PCS > > > function symbols specially, so an ELF symbol table marking was > > > introduced for such symbols. > > > > > > Function symbol references and definitions that follow the vector PCS > > > are marked in the generated assembly with .variant_pcs and then the > > > STO_AARCH64_VARIANT_PCS st_other flag is set on the symbol in the object > > > file. The marking is propagated to the dynamic symbol table by the > > > static linker so a dynamic linker can handle such symbols specially. > > > > > > For this to work, the assembler, the static linker and the dynamic > > > linker has to be updated on a system. Old assembler does not support > > > the new .variant_pcs directive, so a toolchain with old binutils won't > > > be able to compile code that references vector PCS symbols. > > > > > > gcc/ChangeLog: > > > > > > 2019-05-28 Szabolcs Nagy <szabolcs.nagy@arm.com> > > > > > > * config/aarch64/aarch64-protos.h (aarch64_asm_output_alias): Declare. > > > (aarch64_asm_output_external): Declare. > > > * config/aarch64/aarch64.c (aarch64_asm_output_variant_pcs): New. > > > (aarch64_declare_function_name): Call aarch64_asm_output_variant_pcs. > > > (aarch64_asm_output_alias): New. > > > (aarch64_asm_output_external): New. > > > * config/aarch64/aarch64.h (ASM_OUTPUT_DEF_FROM_DECLS): Define. > > > (ASM_OUTPUT_EXTERNAL): Define. > > > > > > gcc/testsuite/ChangeLog: > > > > > > 2019-05-28 Szabolcs Nagy <szabolcs.nagy@arm.com> > > > > > > * gcc.target/aarch64/pcs_attribute-2.c: New test. > > > * gcc.target/aarch64/torture/simd-abi-4.c: Check .variant_pcs support. > > > * lib/target-supports.exp (check_effective_target_aarch64_variant_pcs): > > > New. > > > > LGTM, but an AArch64 maintainer will need to approve. > > OK with Richard's change suggested below. > Hi, Since this patch was committed (r271869), I've noticed regressions on aarch64: FAIL: gcc.dg/visibility-14.c scan-hidden hidden[ \t_]*foo FAIL: gcc.dg/visibility-15.c scan-hidden hidden[ \t_]*foo FAIL: gcc.dg/visibility-16.c scan-hidden hidden[ \t_]*foo FAIL: gcc.dg/visibility-17.c scan-hidden hidden[ \t_]*foo FAIL: gcc.dg/visibility-18.c scan-hidden hidden[ \t_]*foo FAIL: gcc.dg/visibility-19.c scan-hidden hidden[ \t_]*foo FAIL: gcc.dg/visibility-23.c scan-hidden hidden[ \t_]*foo Didn't you see them when you tested the patch? Thanks, Christophe > Thanks, > James > > > > > > diff --git a/gcc/testsuite/gcc.target/aarch64/torture/simd-abi-4.c b/gcc/testsuite/gcc.target/aarch64/torture/simd-abi-4.c > > > index e399690f364..80ebd955e10 100644 > > > --- a/gcc/testsuite/gcc.target/aarch64/torture/simd-abi-4.c > > > +++ b/gcc/testsuite/gcc.target/aarch64/torture/simd-abi-4.c > > > @@ -1,4 +1,5 @@ > > > /* dg-do run */ > > > +/* { dg-require-effective-target aarch64_variant_pcs } */ > > > /* { dg-additional-options "-std=c99" } */ > > > > Not your problem of course, but mind fixing the dg-do markup while > > you're there? It should be > > > > /* { dg-do run } */ > > > > instead. As things stand, the test only gets compiled, not run. > > > > Thanks, > > Richard
On 04/06/2019 13:21, Christophe Lyon wrote: > On Mon, 3 Jun 2019 at 13:28, James Greenhalgh <james.greenhalgh@arm.com> wrote: >> >> On Wed, May 29, 2019 at 11:00:46AM +0100, Richard Sandiford wrote: >>> Szabolcs Nagy <Szabolcs.Nagy@arm.com> writes: >>>> v2: >>>> - use aarch64_simd_decl_p to check for aarch64_vector_pcs. >>>> - emit the .variant_pcs directive even for local functions. >>>> - don't require .variant_pcs asm support in compile only tests. >>>> - add weakref tests. >>>> >>>> A dynamic linker with lazy binding support may need to handle vector PCS >>>> function symbols specially, so an ELF symbol table marking was >>>> introduced for such symbols. >>>> >>>> Function symbol references and definitions that follow the vector PCS >>>> are marked in the generated assembly with .variant_pcs and then the >>>> STO_AARCH64_VARIANT_PCS st_other flag is set on the symbol in the object >>>> file. The marking is propagated to the dynamic symbol table by the >>>> static linker so a dynamic linker can handle such symbols specially. >>>> >>>> For this to work, the assembler, the static linker and the dynamic >>>> linker has to be updated on a system. Old assembler does not support >>>> the new .variant_pcs directive, so a toolchain with old binutils won't >>>> be able to compile code that references vector PCS symbols. >>>> >>>> gcc/ChangeLog: >>>> >>>> 2019-05-28 Szabolcs Nagy <szabolcs.nagy@arm.com> >>>> >>>> * config/aarch64/aarch64-protos.h (aarch64_asm_output_alias): Declare. >>>> (aarch64_asm_output_external): Declare. >>>> * config/aarch64/aarch64.c (aarch64_asm_output_variant_pcs): New. >>>> (aarch64_declare_function_name): Call aarch64_asm_output_variant_pcs. >>>> (aarch64_asm_output_alias): New. >>>> (aarch64_asm_output_external): New. >>>> * config/aarch64/aarch64.h (ASM_OUTPUT_DEF_FROM_DECLS): Define. >>>> (ASM_OUTPUT_EXTERNAL): Define. >>>> >>>> gcc/testsuite/ChangeLog: >>>> >>>> 2019-05-28 Szabolcs Nagy <szabolcs.nagy@arm.com> >>>> >>>> * gcc.target/aarch64/pcs_attribute-2.c: New test. >>>> * gcc.target/aarch64/torture/simd-abi-4.c: Check .variant_pcs support. >>>> * lib/target-supports.exp (check_effective_target_aarch64_variant_pcs): >>>> New. >>> >>> LGTM, but an AArch64 maintainer will need to approve. >> >> OK with Richard's change suggested below. >> > > Hi, > > Since this patch was committed (r271869), I've noticed regressions on aarch64: > FAIL: gcc.dg/visibility-14.c scan-hidden hidden[ \t_]*foo > FAIL: gcc.dg/visibility-15.c scan-hidden hidden[ \t_]*foo > FAIL: gcc.dg/visibility-16.c scan-hidden hidden[ \t_]*foo > FAIL: gcc.dg/visibility-17.c scan-hidden hidden[ \t_]*foo > FAIL: gcc.dg/visibility-18.c scan-hidden hidden[ \t_]*foo > FAIL: gcc.dg/visibility-19.c scan-hidden hidden[ \t_]*foo > FAIL: gcc.dg/visibility-23.c scan-hidden hidden[ \t_]*foo > > Didn't you see them when you tested the patch? sorry i missed these. i broke asm visibility declarations for extern symbols, i will have a fix soon. > > Thanks, > > Christophe > > >> Thanks, >> James >> >>> >>>> diff --git a/gcc/testsuite/gcc.target/aarch64/torture/simd-abi-4.c b/gcc/testsuite/gcc.target/aarch64/torture/simd-abi-4.c >>>> index e399690f364..80ebd955e10 100644 >>>> --- a/gcc/testsuite/gcc.target/aarch64/torture/simd-abi-4.c >>>> +++ b/gcc/testsuite/gcc.target/aarch64/torture/simd-abi-4.c >>>> @@ -1,4 +1,5 @@ >>>> /* dg-do run */ >>>> +/* { dg-require-effective-target aarch64_variant_pcs } */ >>>> /* { dg-additional-options "-std=c99" } */ >>> >>> Not your problem of course, but mind fixing the dg-do markup while >>> you're there? It should be >>> >>> /* { dg-do run } */ >>> >>> instead. As things stand, the test only gets compiled, not run. >>> >>> Thanks, >>> Richard
On 28/05/2019 16:01, Szabolcs Nagy wrote: > v2: > - use aarch64_simd_decl_p to check for aarch64_vector_pcs. > - emit the .variant_pcs directive even for local functions. > - don't require .variant_pcs asm support in compile only tests. > - add weakref tests. > > A dynamic linker with lazy binding support may need to handle vector PCS > function symbols specially, so an ELF symbol table marking was > introduced for such symbols. > > Function symbol references and definitions that follow the vector PCS > are marked in the generated assembly with .variant_pcs and then the > STO_AARCH64_VARIANT_PCS st_other flag is set on the symbol in the object > file. The marking is propagated to the dynamic symbol table by the > static linker so a dynamic linker can handle such symbols specially. > > For this to work, the assembler, the static linker and the dynamic > linker has to be updated on a system. Old assembler does not support > the new .variant_pcs directive, so a toolchain with old binutils won't > be able to compile code that references vector PCS symbols. > > gcc/ChangeLog: > > 2019-05-28 Szabolcs Nagy <szabolcs.nagy@arm.com> > > * config/aarch64/aarch64-protos.h (aarch64_asm_output_alias): Declare. > (aarch64_asm_output_external): Declare. > * config/aarch64/aarch64.c (aarch64_asm_output_variant_pcs): New. > (aarch64_declare_function_name): Call aarch64_asm_output_variant_pcs. > (aarch64_asm_output_alias): New. > (aarch64_asm_output_external): New. > * config/aarch64/aarch64.h (ASM_OUTPUT_DEF_FROM_DECLS): Define. > (ASM_OUTPUT_EXTERNAL): Define. > > gcc/testsuite/ChangeLog: > > 2019-05-28 Szabolcs Nagy <szabolcs.nagy@arm.com> > > * gcc.target/aarch64/pcs_attribute-2.c: New test. > * gcc.target/aarch64/torture/simd-abi-4.c: Check .variant_pcs support. > * lib/target-supports.exp (check_effective_target_aarch64_variant_pcs): > New. > i'd like to backport this and follow up fixes to the gcc-9 branch, see attached patch.
Szabolcs Nagy <Szabolcs.Nagy@arm.com> writes: > On 28/05/2019 16:01, Szabolcs Nagy wrote: >> v2: >> - use aarch64_simd_decl_p to check for aarch64_vector_pcs. >> - emit the .variant_pcs directive even for local functions. >> - don't require .variant_pcs asm support in compile only tests. >> - add weakref tests. >> >> A dynamic linker with lazy binding support may need to handle vector PCS >> function symbols specially, so an ELF symbol table marking was >> introduced for such symbols. >> >> Function symbol references and definitions that follow the vector PCS >> are marked in the generated assembly with .variant_pcs and then the >> STO_AARCH64_VARIANT_PCS st_other flag is set on the symbol in the object >> file. The marking is propagated to the dynamic symbol table by the >> static linker so a dynamic linker can handle such symbols specially. >> >> For this to work, the assembler, the static linker and the dynamic >> linker has to be updated on a system. Old assembler does not support >> the new .variant_pcs directive, so a toolchain with old binutils won't >> be able to compile code that references vector PCS symbols. >> >> gcc/ChangeLog: >> >> 2019-05-28 Szabolcs Nagy <szabolcs.nagy@arm.com> >> >> * config/aarch64/aarch64-protos.h (aarch64_asm_output_alias): Declare. >> (aarch64_asm_output_external): Declare. >> * config/aarch64/aarch64.c (aarch64_asm_output_variant_pcs): New. >> (aarch64_declare_function_name): Call aarch64_asm_output_variant_pcs. >> (aarch64_asm_output_alias): New. >> (aarch64_asm_output_external): New. >> * config/aarch64/aarch64.h (ASM_OUTPUT_DEF_FROM_DECLS): Define. >> (ASM_OUTPUT_EXTERNAL): Define. >> >> gcc/testsuite/ChangeLog: >> >> 2019-05-28 Szabolcs Nagy <szabolcs.nagy@arm.com> >> >> * gcc.target/aarch64/pcs_attribute-2.c: New test. >> * gcc.target/aarch64/torture/simd-abi-4.c: Check .variant_pcs support. >> * lib/target-supports.exp (check_effective_target_aarch64_variant_pcs): >> New. >> > > i'd like to backport this and follow up fixes to the gcc-9 branch, > see attached patch. OK. I agree this makes sense since vector PCS functions were a new feature in GCC 9 and since not backporting it could lead to silent wrong code. Richard
diff --git a/gcc/config/aarch64/aarch64-protos.h b/gcc/config/aarch64/aarch64-protos.h index a0723266f22..19e9767c792 100644 --- a/gcc/config/aarch64/aarch64-protos.h +++ b/gcc/config/aarch64/aarch64-protos.h @@ -427,6 +427,8 @@ bool aarch64_is_long_call_p (rtx); bool aarch64_is_noplt_call_p (rtx); bool aarch64_label_mentioned_p (rtx); void aarch64_declare_function_name (FILE *, const char*, tree); +void aarch64_asm_output_alias (FILE *, const tree, const tree); +void aarch64_asm_output_external (FILE *, const tree, const char*); bool aarch64_legitimate_pic_operand_p (rtx); bool aarch64_mask_and_shift_for_ubfiz_p (scalar_int_mode, rtx, rtx); bool aarch64_masks_and_shift_for_bfi_p (scalar_int_mode, unsigned HOST_WIDE_INT, diff --git a/gcc/config/aarch64/aarch64.c b/gcc/config/aarch64/aarch64.c index 83453d03095..16e534b0772 100644 --- a/gcc/config/aarch64/aarch64.c +++ b/gcc/config/aarch64/aarch64.c @@ -15276,6 +15276,19 @@ aarch64_asm_preferred_eh_data_format (int code ATTRIBUTE_UNUSED, int global) return (global ? DW_EH_PE_indirect : 0) | DW_EH_PE_pcrel | type; } +/* Output .variant_pcs for aarch64_vector_pcs function symbols. */ + +static void +aarch64_asm_output_variant_pcs (FILE *stream, const tree decl, const char* name) +{ + if (aarch64_simd_decl_p (decl)) + { + fprintf (stream, "\t.variant_pcs\t"); + assemble_name (stream, name); + fprintf (stream, "\n"); + } +} + /* The last .arch and .tune assembly strings that we printed. */ static std::string aarch64_last_printed_arch_string; static std::string aarch64_last_printed_tune_string; @@ -15325,11 +15338,33 @@ aarch64_declare_function_name (FILE *stream, const char* name, aarch64_last_printed_tune_string = this_tune->name; } + aarch64_asm_output_variant_pcs (stream, fndecl, name); + /* Don't forget the type directive for ELF. */ ASM_OUTPUT_TYPE_DIRECTIVE (stream, name, "function"); ASM_OUTPUT_LABEL (stream, name); } +/* Implement ASM_OUTPUT_DEF_FROM_DECLS. Output .variant_pcs for aliases. */ + +void +aarch64_asm_output_alias (FILE *stream, const tree decl, const tree target) +{ + const char *name = XSTR (XEXP (DECL_RTL (decl), 0), 0); + const char *value = IDENTIFIER_POINTER (target); + aarch64_asm_output_variant_pcs (stream, decl, name); + ASM_OUTPUT_DEF (stream, name, value); +} + +/* Implement ASM_OUTPUT_EXTERNAL. Output .variant_pcs for undefined + function symbol references. */ + +void +aarch64_asm_output_external (FILE *stream, const tree decl, const char* name) +{ + aarch64_asm_output_variant_pcs (stream, decl, name); +} + /* Implements TARGET_ASM_FILE_START. Output the assembly header. */ static void diff --git a/gcc/config/aarch64/aarch64.h b/gcc/config/aarch64/aarch64.h index be6981889ab..f0f50e081ac 100644 --- a/gcc/config/aarch64/aarch64.h +++ b/gcc/config/aarch64/aarch64.h @@ -512,6 +512,15 @@ extern unsigned aarch64_architecture_version; #define ASM_DECLARE_FUNCTION_NAME(STR, NAME, DECL) \ aarch64_declare_function_name (STR, NAME, DECL) +/* Output assembly strings for alias definition. */ +#define ASM_OUTPUT_DEF_FROM_DECLS(STR, DECL, TARGET) \ + aarch64_asm_output_alias (STR, DECL, TARGET) + +/* Output assembly strings for undefined extern symbols. */ +#undef ASM_OUTPUT_EXTERNAL +#define ASM_OUTPUT_EXTERNAL(STR, DECL, NAME) \ + aarch64_asm_output_external (STR, DECL, NAME) + /* For EH returns X4 contains the stack adjustment. */ #define EH_RETURN_STACKADJ_RTX gen_rtx_REG (Pmode, R4_REGNUM) #define EH_RETURN_HANDLER_RTX aarch64_eh_return_handler_rtx () diff --git a/gcc/testsuite/gcc.target/aarch64/pcs_attribute-2.c b/gcc/testsuite/gcc.target/aarch64/pcs_attribute-2.c new file mode 100644 index 00000000000..21fdc9c6eba --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/pcs_attribute-2.c @@ -0,0 +1,114 @@ +/* { dg-do compile } */ +/* { dg-require-effective-target aarch64_variant_pcs } */ + +/* Test that .variant_pcs is emitted for vector PCS symbol references. */ + +#define ATTR __attribute__ ((aarch64_vector_pcs)) + +void f_undef_basepcs (void); + +void f_def_basepcs (void) +{ +} + +ATTR void f_undef_vpcs (void); + +ATTR void f_def_vpcs (void) +{ +} + +__attribute__ ((alias ("f_def_vpcs"))) +ATTR void f_alias_vpcs (void); + +__attribute__ ((weak, alias ("f_def_vpcs"))) +ATTR void f_weak_alias_vpcs (void); + +__attribute__ ((weak)) +ATTR void f_weak_undef_vpcs (void); + +__attribute__ ((visibility ("protected"))) +ATTR void f_protected_vpcs (void) +{ +} + +__attribute__ ((visibility ("hidden"))) +ATTR void f_hidden_vpcs (void) +{ +} + +ATTR static void f_local_vpcs (void) +{ +} + +__attribute__((weakref ("f_undef_vpcs"))) +ATTR static void f_local_weakref_undef_vpcs (void); + +__attribute__((weakref ("f_hidden_vpcs"))) +ATTR static void f_local_weakref_def_vpcs (void); + +ATTR void bar_undef_vpcs (void) __asm__ ("f_undef_renamed_vpcs"); + +ATTR void bar_def_vpcs (void) __asm__ ("f_def_renamed_vpcs"); +ATTR void bar_def_vpcs (void) +{ +} + +static void (*f_ifunc_resolver ()) (void) +{ + return (void (*)(void))f_local_vpcs; +} + +__attribute__ ((ifunc ("f_ifunc_resolver"))) +ATTR void f_ifunc_vpcs (void); + +__attribute__ ((visibility ("hidden"))) +__attribute__ ((ifunc ("f_ifunc_resolver"))) +ATTR void f_hidden_ifunc_vpcs (void); + +__attribute__ ((ifunc ("f_ifunc_resolver"))) +ATTR static void f_local_ifunc_vpcs (void); + +void (*refs_basepcs[]) (void) = { + f_undef_basepcs, + f_def_basepcs, +}; + +void (*ATTR refs_vpcs[]) (void) = { + f_undef_vpcs, + f_def_vpcs, + f_alias_vpcs, + f_weak_alias_vpcs, + f_weak_undef_vpcs, + f_protected_vpcs, + f_hidden_vpcs, + f_local_vpcs, + f_local_weakref_undef_vpcs, + f_local_weakref_def_vpcs, + bar_undef_vpcs, + bar_def_vpcs, + f_ifunc_vpcs, + f_hidden_ifunc_vpcs, + f_local_ifunc_vpcs, +}; + +/* Note: hidden and local symbols don't need .variant_pcs, but gcc generates + it, so we check them here. An undefined weakref does not show up in the + symbol table, only the target symbol, so it does not need .variant_pcs. */ + +/* { dg-final { scan-assembler-not {\.variant_pcs\tf_undef_basepcs} } } */ +/* { dg-final { scan-assembler-not {\.variant_pcs\tf_def_basepcs} } } */ +/* { dg-final { scan-assembler-times {\.variant_pcs\tf_undef_vpcs} 1 } } */ +/* { dg-final { scan-assembler-times {\.variant_pcs\tf_def_vpcs} 1 } } */ +/* { dg-final { scan-assembler-times {\.variant_pcs\tf_alias_vpcs} 1 } } */ +/* { dg-final { scan-assembler-times {\.variant_pcs\tf_weak_alias_vpcs} 1 } } */ +/* { dg-final { scan-assembler-times {\.variant_pcs\tf_weak_undef_vpcs} 1 } } */ +/* { dg-final { scan-assembler-times {\.variant_pcs\tf_protected_vpcs} 1 } } */ +/* { dg-final { scan-assembler-times {\.variant_pcs\tf_hidden_vpcs} 1 } } */ +/* { dg-final { scan-assembler-times {\.variant_pcs\tf_local_vpcs} 1 } } */ +/* { dg-final { scan-assembler-not {\.variant_pcs\tf_local_weakref_undef_vpcs} } } */ +/* { dg-final { scan-assembler-times {\.variant_pcs\tf_local_weakref_def_vpcs} 1 } } */ +/* { dg-final { scan-assembler-times {\.variant_pcs\tf_undef_renamed_vpcs} 1 } } */ +/* { dg-final { scan-assembler-times {\.variant_pcs\tf_def_renamed_vpcs} 1 } } */ +/* { dg-final { scan-assembler-times {\.variant_pcs\tf_ifunc_vpcs} 1 } } */ +/* { dg-final { scan-assembler-times {\.variant_pcs\tf_hidden_ifunc_vpcs} 1 } } */ +/* { dg-final { scan-assembler-times {\.variant_pcs\tf_local_ifunc_vpcs} 1 } } */ diff --git a/gcc/testsuite/gcc.target/aarch64/torture/simd-abi-4.c b/gcc/testsuite/gcc.target/aarch64/torture/simd-abi-4.c index e399690f364..80ebd955e10 100644 --- a/gcc/testsuite/gcc.target/aarch64/torture/simd-abi-4.c +++ b/gcc/testsuite/gcc.target/aarch64/torture/simd-abi-4.c @@ -1,4 +1,5 @@ /* dg-do run */ +/* { dg-require-effective-target aarch64_variant_pcs } */ /* { dg-additional-options "-std=c99" } */ diff --git a/gcc/testsuite/lib/target-supports.exp b/gcc/testsuite/lib/target-supports.exp index 4bcf1a1c8f7..9fb05fc38ed 100644 --- a/gcc/testsuite/lib/target-supports.exp +++ b/gcc/testsuite/lib/target-supports.exp @@ -8591,6 +8591,17 @@ proc check_effective_target_aarch64_large { } { } } +# Return 1 if the assembler accepts the aarch64 .variant_pcs directive. + +proc check_effective_target_aarch64_variant_pcs { } { + if { [istarget aarch64*-*-*] } { + return [check_no_compiler_messages aarch64_variant_pcs object { + __asm__ (".variant_pcs foo"); + }] + } else { + return 0 + } +} # Return 1 if this is a reduced AVR Tiny core. Such cores have different # register set, instruction set, addressing capabilities and ABI.