From 51ad2aa71cb69fc84be65295b2837896bc2c3c19 Mon Sep 17 00:00:00 2001 From: Petr Machata Date: Thu, 14 Nov 2013 00:32:30 +0100 Subject: [PATCH] Support AArch64 architecture Signed-off-by: Petr Machata --- backends/ChangeLog | 14 + backends/Makefile.am | 17 +- backends/aarch64_corenote.c | 162 ++++++ backends/aarch64_init.c | 61 ++ backends/aarch64_regs.c | 95 ++++ backends/aarch64_reloc.def | 157 ++++++ backends/aarch64_retval.c | 375 +++++++++++++ backends/aarch64_symbol.c | 56 ++ backends/libebl_CPU.h | 37 +- libebl/ChangeLog | 4 + libebl/eblopenbackend.c | 3 +- src/ChangeLog | 4 + src/elflint.c | 4 +- tests/ChangeLog | 11 + tests/Makefile.am | 8 +- tests/funcretval_test.c | 828 ++++++++++++++++++++++++++++ tests/funcretval_test_aarch64.bz2 | Bin 0 -> 15644 bytes tests/hello_aarch64.ko.bz2 | Bin 0 -> 12768 bytes tests/run-allregs.sh | 74 ++- tests/run-funcretval.sh | 153 +++++ tests/run-readelf-mixed-corenote.sh | 140 +++++ tests/run-strip-reloc.sh | 6 +- tests/testfile_aarch64_core.bz2 | Bin 0 -> 61748 bytes 23 files changed, 2194 insertions(+), 15 deletions(-) create mode 100644 backends/aarch64_corenote.c create mode 100644 backends/aarch64_init.c create mode 100644 backends/aarch64_regs.c create mode 100644 backends/aarch64_reloc.def create mode 100644 backends/aarch64_retval.c create mode 100644 backends/aarch64_symbol.c create mode 100644 tests/funcretval_test.c create mode 100755 tests/funcretval_test_aarch64.bz2 create mode 100644 tests/hello_aarch64.ko.bz2 create mode 100755 tests/run-funcretval.sh create mode 100644 tests/testfile_aarch64_core.bz2 diff --git a/backends/ChangeLog b/backends/ChangeLog index 3c57f8c35..787223d8b 100644 --- a/backends/ChangeLog +++ b/backends/ChangeLog @@ -1,3 +1,17 @@ +2013-11-25 Petr Machata + + * Makefile.am (modules): Add aarch64. + (libebl_pic): Add libebl_aarch64_pic.a. + (aarch64_SRCS): New variable. + (libebl_aarch64_pic_a_SOURCES): Likewise. + (am_libebl_aarch64_pic_a_OBJECTS): Likewise. + (aarch64_regs_no_Wformat): Likewise. + * aarch64_corenote.c, aarch64_init.c: New files. + * aarch64_regs.c, aarch64_reloc.def: Likewise. + * aarch64_retval.c, aarch64_symbol.c: Likewise. + * libebl_CPU.h (dwarf_peel_type): New function. + (dwarf_peeled_die_type): Likewise. + 2013-11-07 Jan Kratochvil Mark Wielaard diff --git a/backends/Makefile.am b/backends/Makefile.am index 5b5e06767..9bca99415 100644 --- a/backends/Makefile.am +++ b/backends/Makefile.am @@ -32,11 +32,12 @@ AM_CPPFLAGS += -I$(top_srcdir)/libebl -I$(top_srcdir)/libasm \ -I$(top_srcdir)/libelf -I$(top_srcdir)/libdw -modules = i386 sh x86_64 ia64 alpha arm sparc ppc ppc64 s390 tilegx -libebl_pic = libebl_i386_pic.a libebl_sh_pic.a libebl_x86_64_pic.a \ - libebl_ia64_pic.a libebl_alpha_pic.a libebl_arm_pic.a \ - libebl_sparc_pic.a libebl_ppc_pic.a libebl_ppc64_pic.a \ - libebl_s390_pic.a libebl_tilegx_pic.a +modules = i386 sh x86_64 ia64 alpha arm aarch64 sparc ppc ppc64 s390 \ + tilegx +libebl_pic = libebl_i386_pic.a libebl_sh_pic.a libebl_x86_64_pic.a \ + libebl_ia64_pic.a libebl_alpha_pic.a libebl_arm_pic.a \ + libebl_aarch64_pic.a libebl_sparc_pic.a libebl_ppc_pic.a \ + libebl_ppc64_pic.a libebl_s390_pic.a libebl_tilegx_pic.a noinst_LIBRARIES = $(libebl_pic) noinst_DATA = $(libebl_pic:_pic.a=.so) @@ -81,6 +82,12 @@ arm_SRCS = arm_init.c arm_symbol.c arm_regs.c arm_corenote.c \ libebl_arm_pic_a_SOURCES = $(arm_SRCS) am_libebl_arm_pic_a_OBJECTS = $(arm_SRCS:.c=.os) +aarch64_SRCS = aarch64_init.c aarch64_regs.c aarch64_symbol.c \ + aarch64_corenote.c aarch64_retval.c +libebl_aarch64_pic_a_SOURCES = $(aarch64_SRCS) +am_libebl_aarch64_pic_a_OBJECTS = $(aarch64_SRCS:.c=.os) +aarch64_regs_no_Wformat = yes + sparc_SRCS = sparc_init.c sparc_symbol.c sparc_regs.c sparc_retval.c \ sparc_corenote.c sparc64_corenote.c sparc_auxv.c libebl_sparc_pic_a_SOURCES = $(sparc_SRCS) diff --git a/backends/aarch64_corenote.c b/backends/aarch64_corenote.c new file mode 100644 index 000000000..8f5b9d5d2 --- /dev/null +++ b/backends/aarch64_corenote.c @@ -0,0 +1,162 @@ +/* AArch64 specific core note handling. + Copyright (C) 2013 Red Hat, Inc. + This file is part of elfutils. + + This file is free software; you can redistribute it and/or modify + it under the terms of either + + * the GNU Lesser General Public License as published by the Free + Software Foundation; either version 3 of the License, or (at + your option) any later version + + or + + * the GNU General Public License as published by the Free + Software Foundation; either version 2 of the License, or (at + your option) any later version + + or both in parallel, as here. + + elfutils is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received copies of the GNU General Public License and + the GNU Lesser General Public License along with this program. If + not, see . */ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#include +#include +#include +#include +#include + +#define BACKEND aarch64_ +#include "libebl_CPU.h" + +#define ULONG uint64_t +#define PID_T int32_t +#define UID_T uint32_t +#define GID_T uint32_t +#define ALIGN_ULONG 8 +#define ALIGN_PID_T 4 +#define ALIGN_UID_T 4 +#define ALIGN_GID_T 4 +#define TYPE_ULONG ELF_T_XWORD +#define TYPE_PID_T ELF_T_SWORD +#define TYPE_UID_T ELF_T_WORD +#define TYPE_GID_T ELF_T_WORD + +#define PRSTATUS_REGS_SIZE (34 * 8) + +static const Ebl_Register_Location prstatus_regs[] = + { + { .offset = 0, .regno = 0, .count = 32, .bits = 64 }, /* x0..x30, sp */ + }; + +#define PRSTATUS_REGSET_ITEMS \ + { \ + .name = "pc", .type = ELF_T_XWORD, .format = 'x', \ + .offset = (offsetof (struct EBLHOOK(prstatus), pr_reg) \ + + PRSTATUS_REGS_SIZE - 16), \ + .group = "register" \ + }, \ + { \ + .name = "pstate", .type = ELF_T_XWORD, .format = 'x', \ + .offset = (offsetof (struct EBLHOOK(prstatus), pr_reg) \ + + PRSTATUS_REGS_SIZE - 8), \ + .group = "register" \ + } + +static const Ebl_Register_Location aarch64_fpregset_regs[] = + { + { .offset = 0, .regno = 64, .count = 32, .bits = 128 }, /* v0..v31 */ + }; + +static const Ebl_Core_Item aarch64_fpregset_items[] = + { + { + .name = "fpsr", .type = ELF_T_WORD, .format = 'x', + .offset = 512, .group = "register" + }, + { + .name = "fpcr", .type = ELF_T_WORD, .format = 'x', + .offset = 516, .group = "register" + } + }; + +static const Ebl_Core_Item aarch64_tls_items[] = + { + { + .name = "tls", .type = ELF_T_XWORD, .format = 'x', + .offset = 0, .group = "register" + } + }; + +#define AARCH64_HWBP_REG(KIND, N) \ + { \ + .name = "DBG" KIND "VR" #N "_EL1", .type = ELF_T_XWORD, .format = 'x', \ + .offset = 8 + N * 16, .group = "register" \ + }, \ + { \ + .name = "DBG" KIND "CR" #N "_EL1", .type = ELF_T_WORD, .format = 'x', \ + .offset = 16 + N * 16, .group = "register" \ + } + +#define AARCH64_BP_WP_GROUP(KIND, NAME) \ + static const Ebl_Core_Item NAME[] = \ + { \ + { \ + .name = "dbg_info", .type = ELF_T_WORD, .format = 'x', \ + .offset = 0, .group = "control" \ + }, \ + /* N.B.: 4 bytes of padding here. */ \ + \ + AARCH64_HWBP_REG(KIND, 0), \ + AARCH64_HWBP_REG(KIND, 1), \ + AARCH64_HWBP_REG(KIND, 2), \ + AARCH64_HWBP_REG(KIND, 3), \ + AARCH64_HWBP_REG(KIND, 4), \ + AARCH64_HWBP_REG(KIND, 5), \ + AARCH64_HWBP_REG(KIND, 6), \ + AARCH64_HWBP_REG(KIND, 7), \ + AARCH64_HWBP_REG(KIND, 8), \ + AARCH64_HWBP_REG(KIND, 9), \ + AARCH64_HWBP_REG(KIND, 10), \ + AARCH64_HWBP_REG(KIND, 11), \ + AARCH64_HWBP_REG(KIND, 12), \ + AARCH64_HWBP_REG(KIND, 13), \ + AARCH64_HWBP_REG(KIND, 14), \ + AARCH64_HWBP_REG(KIND, 15), \ + \ + /* The DBGBVR+DBGBCR pair only takes 12 bytes. There are 4 bytes \ + of padding at the end of each pair. The item formatter in \ + readelf can skip those, but the missing 4 bytes at the end of \ + the whole block cause it to assume the whole item bunch \ + repeats, so it loops around to read more. Insert an explicit \ + (but invisible) padding word. */ \ + { \ + .name = "", .type = ELF_T_WORD, .format = 'h', \ + .offset = 260, .group = "register" \ + } \ + } + +AARCH64_BP_WP_GROUP ("B", aarch64_hw_bp_items); +AARCH64_BP_WP_GROUP ("W", aarch64_hw_wp_items); + +#undef AARCH64_BP_WP_GROUP +#undef AARCH64_HWBP_REG + +#define EXTRA_NOTES \ + EXTRA_REGSET_ITEMS (NT_FPREGSET, 528, \ + aarch64_fpregset_regs, aarch64_fpregset_items) \ + EXTRA_ITEMS (NT_ARM_TLS, 8, aarch64_tls_items) \ + EXTRA_ITEMS (NT_ARM_HW_BREAK, 264, aarch64_hw_bp_items) \ + EXTRA_ITEMS (NT_ARM_HW_WATCH, 264, aarch64_hw_wp_items) + +#include "linux-core-note.c" diff --git a/backends/aarch64_init.c b/backends/aarch64_init.c new file mode 100644 index 000000000..749af2aab --- /dev/null +++ b/backends/aarch64_init.c @@ -0,0 +1,61 @@ +/* Initialization of AArch64 specific backend library. + Copyright (C) 2013 Red Hat, Inc. + This file is part of elfutils. + + This file is free software; you can redistribute it and/or modify + it under the terms of either + + * the GNU Lesser General Public License as published by the Free + Software Foundation; either version 3 of the License, or (at + your option) any later version + + or + + * the GNU General Public License as published by the Free + Software Foundation; either version 2 of the License, or (at + your option) any later version + + or both in parallel, as here. + + elfutils is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received copies of the GNU General Public License and + the GNU Lesser General Public License along with this program. If + not, see . */ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#define BACKEND aarch64_ +#define RELOC_PREFIX R_AARCH64_ +#include "libebl_CPU.h" + +/* This defines the common reloc hooks based on aarch64_reloc.def. */ +#include "common-reloc.c" + + +const char * +aarch64_init (elf, machine, eh, ehlen) + Elf *elf __attribute__ ((unused)); + GElf_Half machine __attribute__ ((unused)); + Ebl *eh; + size_t ehlen; +{ + /* Check whether the Elf_BH object has a sufficent size. */ + if (ehlen < sizeof (Ebl)) + return NULL; + + /* We handle it. */ + eh->name = "AARCH64"; + aarch64_init_reloc (eh); + HOOK (eh, register_info); + HOOK (eh, core_note); + HOOK (eh, reloc_simple_type); + HOOK (eh, return_value_location); + + return MODVERSION; +} diff --git a/backends/aarch64_regs.c b/backends/aarch64_regs.c new file mode 100644 index 000000000..5952b9691 --- /dev/null +++ b/backends/aarch64_regs.c @@ -0,0 +1,95 @@ +/* Register names and numbers for AArch64 DWARF. + Copyright (C) 2013 Red Hat, Inc. + This file is part of elfutils. + + This file is free software; you can redistribute it and/or modify + it under the terms of either + + * the GNU Lesser General Public License as published by the Free + Software Foundation; either version 3 of the License, or (at + your option) any later version + + or + + * the GNU General Public License as published by the Free + Software Foundation; either version 2 of the License, or (at + your option) any later version + + or both in parallel, as here. + + elfutils is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received copies of the GNU General Public License and + the GNU Lesser General Public License along with this program. If + not, see . */ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#include +#include +#include + +#define BACKEND aarch64_ +#include "libebl_CPU.h" + +ssize_t +aarch64_register_info (Ebl *ebl __attribute__ ((unused)), + int regno, char *name, size_t namelen, + const char **prefix, const char **setnamep, + int *bits, int *typep) +{ + if (name == NULL) + return 128; + + ssize_t + regtype (const char *setname, int type, const char *fmt, int arg) + { + *setnamep = setname; + *typep = type; + int s = snprintf (name, namelen, fmt, arg); + if (s < 0 || (unsigned) s >= namelen) + return -1; + return s + 1; + } + + *prefix = NULL; + *bits = 64; + + switch (regno) + { + case 0 ... 30: + return regtype ("integer", DW_ATE_signed, "x%d", regno); + + case 31: + return regtype ("integer", DW_ATE_address, "sp", 0); + + case 32: + return 0; + + case 33: + return regtype ("integer", DW_ATE_address, "elr", 0); + + case 34 ... 63: + return 0; + + case 64 ... 95: + /* FP/SIMD register file supports a variety of data types--it + can be thought of as a register holding a single integer or + floating-point value, or a vector of 8-, 16-, 32- or 64-bit + integers. 128-bit quad-word is the only singular value that + covers the whole register, so mark the register thus. */ + *bits = 128; + return regtype ("FP/SIMD", DW_ATE_unsigned, "v%d", regno - 64); + + case 96 ... 127: + return 0; + + default: + return -1; + } +} diff --git a/backends/aarch64_reloc.def b/backends/aarch64_reloc.def new file mode 100644 index 000000000..f63315735 --- /dev/null +++ b/backends/aarch64_reloc.def @@ -0,0 +1,157 @@ +/* List the relocation types for AArch64. -*- C -*- + Copyright (C) 2013 Red Hat, Inc. + This file is part of elfutils. + + This file is free software; you can redistribute it and/or modify + it under the terms of either + + * the GNU Lesser General Public License as published by the Free + Software Foundation; either version 3 of the License, or (at + your option) any later version + + or + + * the GNU General Public License as published by the Free + Software Foundation; either version 2 of the License, or (at + your option) any later version + + or both in parallel, as here. + + elfutils is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received copies of the GNU General Public License and + the GNU Lesser General Public License along with this program. If + not, see . */ + +/* NAME, REL|EXEC|DYN */ + +RELOC_TYPE (ABS64, EXEC|DYN) +RELOC_TYPE (ABS32, EXEC|DYN) +RELOC_TYPE (COPY, EXEC) +RELOC_TYPE (GLOB_DAT, EXEC|DYN) +RELOC_TYPE (JUMP_SLOT, EXEC|DYN) +RELOC_TYPE (RELATIVE, EXEC|DYN) +RELOC_TYPE (TLS_DTPMOD64, EXEC|DYN) +RELOC_TYPE (TLS_DTPREL64, EXEC|DYN) +RELOC_TYPE (TLS_TPREL64, EXEC|DYN) +RELOC_TYPE (TLSDESC, EXEC|DYN) + +/* R_AARCH64_NONE records that the section containing the place to be + relocated depends on the section defining the symbol mentioned in + the relocation directive[.] (ARM IHI 0056B). */ +RELOC_TYPE (NONE, REL) + +RELOC_TYPE (ABS16, REL) +RELOC_TYPE (PREL64, REL) +RELOC_TYPE (PREL32, REL) +RELOC_TYPE (PREL16, REL) +RELOC_TYPE (MOVW_UABS_G0, REL) +RELOC_TYPE (MOVW_UABS_G0_NC, REL) +RELOC_TYPE (MOVW_UABS_G1, REL) +RELOC_TYPE (MOVW_UABS_G1_NC, REL) +RELOC_TYPE (MOVW_UABS_G2, REL) +RELOC_TYPE (MOVW_UABS_G2_NC, REL) +RELOC_TYPE (MOVW_UABS_G3, REL) +RELOC_TYPE (MOVW_SABS_G0, REL) +RELOC_TYPE (MOVW_SABS_G1, REL) +RELOC_TYPE (MOVW_SABS_G2, REL) +RELOC_TYPE (LD_PREL_LO19, REL) +RELOC_TYPE (ADR_PREL_LO21, REL) +RELOC_TYPE (ADR_PREL_PG_HI21, REL) +RELOC_TYPE (ADR_PREL_PG_HI21_NC, REL) +RELOC_TYPE (ADD_ABS_LO12_NC, REL) +RELOC_TYPE (LDST8_ABS_LO12_NC, REL) +RELOC_TYPE (LDST16_ABS_LO12_NC, REL) +RELOC_TYPE (LDST32_ABS_LO12_NC, REL) +RELOC_TYPE (LDST64_ABS_LO12_NC, REL) +RELOC_TYPE (LDST128_ABS_LO12_NC, REL) +RELOC_TYPE (TSTBR14, REL) +RELOC_TYPE (CONDBR19, REL) +RELOC_TYPE (JUMP26, REL) +RELOC_TYPE (CALL26, REL) +RELOC_TYPE (MOVW_PREL_G0, REL) +RELOC_TYPE (MOVW_PREL_G0_NC, REL) +RELOC_TYPE (MOVW_PREL_G1, REL) +RELOC_TYPE (MOVW_PREL_G1_NC, REL) +RELOC_TYPE (MOVW_PREL_G2, REL) +RELOC_TYPE (MOVW_PREL_G2_NC, REL) +RELOC_TYPE (MOVW_PREL_G3, REL) +RELOC_TYPE (MOVW_GOTOFF_G0, REL) +RELOC_TYPE (MOVW_GOTOFF_G0_NC, REL) +RELOC_TYPE (MOVW_GOTOFF_G1, REL) +RELOC_TYPE (MOVW_GOTOFF_G1_NC, REL) +RELOC_TYPE (MOVW_GOTOFF_G2, REL) +RELOC_TYPE (MOVW_GOTOFF_G2_NC, REL) +RELOC_TYPE (MOVW_GOTOFF_G3, REL) +RELOC_TYPE (GOTREL64, REL) +RELOC_TYPE (GOTREL32, REL) +RELOC_TYPE (GOT_LD_PREL19, REL) +RELOC_TYPE (LD64_GOTOFF_LO15, REL) +RELOC_TYPE (ADR_GOT_PAGE, REL) +RELOC_TYPE (LD64_GOT_LO12_NC, REL) +RELOC_TYPE (LD64_GOTPAGE_LO15, REL) +RELOC_TYPE (TLSGD_ADR_PREL21, REL) +RELOC_TYPE (TLSGD_ADR_PAGE21, REL) +RELOC_TYPE (TLSGD_ADD_LO12_NC, REL) +RELOC_TYPE (TLSGD_MOVW_G1, REL) +RELOC_TYPE (TLSGD_MOVW_G0_NC, REL) +RELOC_TYPE (TLSLD_ADR_PREL21, REL) +RELOC_TYPE (TLSLD_ADR_PAGE21, REL) +RELOC_TYPE (TLSLD_ADD_LO12_NC, REL) +RELOC_TYPE (TLSLD_MOVW_G1, REL) +RELOC_TYPE (TLSLD_MOVW_G0_NC, REL) +RELOC_TYPE (TLSLD_LD_PREL19, REL) +RELOC_TYPE (TLSLD_MOVW_DTPREL_G2, REL) +RELOC_TYPE (TLSLD_MOVW_DTPREL_G1, REL) +RELOC_TYPE (TLSLD_MOVW_DTPREL_G1_NC, REL) +RELOC_TYPE (TLSLD_MOVW_DTPREL_G0, REL) +RELOC_TYPE (TLSLD_MOVW_DTPREL_G0_NC, REL) +RELOC_TYPE (TLSLD_ADD_DTPREL_HI12, REL) +RELOC_TYPE (TLSLD_ADD_DTPREL_LO12, REL) +RELOC_TYPE (TLSLD_ADD_DTPREL_LO12_NC, REL) +RELOC_TYPE (TLSLD_LDST8_DTPREL_LO12, REL) +RELOC_TYPE (TLSLD_LDST8_DTPREL_LO12_NC, REL) +RELOC_TYPE (TLSLD_LDST16_DTPREL_LO12, REL) +RELOC_TYPE (TLSLD_LDST16_DTPREL_LO12_NC, REL) +RELOC_TYPE (TLSLD_LDST32_DTPREL_LO12, REL) +RELOC_TYPE (TLSLD_LDST32_DTPREL_LO12_NC, REL) +RELOC_TYPE (TLSLD_LDST64_DTPREL_LO12, REL) +RELOC_TYPE (TLSLD_LDST64_DTPREL_LO12_NC, REL) +RELOC_TYPE (TLSLD_LDST128_DTPREL_LO12, REL) +RELOC_TYPE (TLSLD_LDST128_DTPREL_LO12_NC, REL) +RELOC_TYPE (TLSIE_MOVW_GOTTPREL_G1, REL) +RELOC_TYPE (TLSIE_MOVW_GOTTPREL_G0_NC, REL) +RELOC_TYPE (TLSIE_ADR_GOTTPREL_PAGE21, REL) +RELOC_TYPE (TLSIE_LD64_GOTTPREL_LO12_NC, REL) +RELOC_TYPE (TLSIE_LD_GOTTPREL_PREL19, REL) +RELOC_TYPE (TLSLE_MOVW_TPREL_G2, REL) +RELOC_TYPE (TLSLE_MOVW_TPREL_G1, REL) +RELOC_TYPE (TLSLE_MOVW_TPREL_G1_NC, REL) +RELOC_TYPE (TLSLE_MOVW_TPREL_G0, REL) +RELOC_TYPE (TLSLE_MOVW_TPREL_G0_NC, REL) +RELOC_TYPE (TLSLE_ADD_TPREL_HI12, REL) +RELOC_TYPE (TLSLE_ADD_TPREL_LO12, REL) +RELOC_TYPE (TLSLE_ADD_TPREL_LO12_NC, REL) +RELOC_TYPE (TLSLE_LDST8_TPREL_LO12, REL) +RELOC_TYPE (TLSLE_LDST8_TPREL_LO12_NC, REL) +RELOC_TYPE (TLSLE_LDST16_TPREL_LO12, REL) +RELOC_TYPE (TLSLE_LDST16_TPREL_LO12_NC, REL) +RELOC_TYPE (TLSLE_LDST32_TPREL_LO12, REL) +RELOC_TYPE (TLSLE_LDST32_TPREL_LO12_NC, REL) +RELOC_TYPE (TLSLE_LDST64_TPREL_LO12, REL) +RELOC_TYPE (TLSLE_LDST64_TPREL_LO12_NC, REL) +RELOC_TYPE (TLSLE_LDST128_TPREL_LO12, REL) +RELOC_TYPE (TLSLE_LDST128_TPREL_LO12_NC, REL) +RELOC_TYPE (TLSDESC_LD_PREL19, REL) +RELOC_TYPE (TLSDESC_ADR_PREL21, REL) +RELOC_TYPE (TLSDESC_ADR_PAGE21, REL) +RELOC_TYPE (TLSDESC_LD64_LO12, REL) +RELOC_TYPE (TLSDESC_ADD_LO12, REL) +RELOC_TYPE (TLSDESC_OFF_G1, REL) +RELOC_TYPE (TLSDESC_OFF_G0_NC, REL) +RELOC_TYPE (TLSDESC_LDR, REL) +RELOC_TYPE (TLSDESC_ADD, REL) +RELOC_TYPE (TLSDESC_CALL, REL) diff --git a/backends/aarch64_retval.c b/backends/aarch64_retval.c new file mode 100644 index 000000000..0ed7d561e --- /dev/null +++ b/backends/aarch64_retval.c @@ -0,0 +1,375 @@ +/* Function return value location for Linux/AArch64 ABI. + Copyright (C) 2013 Red Hat, Inc. + This file is part of elfutils. + + This file is free software; you can redistribute it and/or modify + it under the terms of either + + * the GNU Lesser General Public License as published by the Free + Software Foundation; either version 3 of the License, or (at + your option) any later version + + or + + * the GNU General Public License as published by the Free + Software Foundation; either version 2 of the License, or (at + your option) any later version + + or both in parallel, as here. + + elfutils is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received copies of the GNU General Public License and + the GNU Lesser General Public License along with this program. If + not, see . */ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#include +#include + +#include +#include + +#define BACKEND aarch64_ +#include "libebl_CPU.h" + +static int +skip_until (Dwarf_Die *child, int tag) +{ + int i; + while (DWARF_TAG_OR_RETURN (child) != tag) + if ((i = dwarf_siblingof (child, child)) != 0) + /* If there are no members, then this is not a HFA. Errors + are propagated. */ + return i; + return 0; +} + +static int +dwarf_bytesize_aux (Dwarf_Die *die, Dwarf_Word *sizep) +{ + int bits; + if (((bits = 8 * dwarf_bytesize (die)) < 0 + && (bits = dwarf_bitsize (die)) < 0) + || bits % 8 != 0) + return -1; + + *sizep = bits / 8; + return 0; +} + +/* HFA (Homogeneous Floating-point Aggregate) is an aggregate type + whose members are all of the same floating-point type, which is + then base type of this HFA. Instead of being floating-point types + directly, members can instead themselves be HFA. Such HFA fields + are handled as if their type were HFA base type. + + This function returns 0 if TYPEDIE is HFA, 1 if it is not, or -1 if + there were errors. In the former case, *SIZEP contains byte size + of the base type (e.g. 8 for IEEE double). *COUNT is set to the + number of leaf members of the HFA. */ +static int hfa_type (Dwarf_Die *ftypedie, int tag, + Dwarf_Word *sizep, Dwarf_Word *countp); + +/* Return 0 if MEMBDIE refers to a member with a floating-point or HFA + type, or 1 if it's not. Return -1 for errors. The meaning of the + remaining arguments is as documented at hfa_type. */ +static int +member_is_fp (Dwarf_Die *membdie, Dwarf_Word *sizep, Dwarf_Word *countp) +{ + Dwarf_Die typedie; + int tag = dwarf_peeled_die_type (membdie, &typedie); + switch (tag) + { + case DW_TAG_base_type:; + Dwarf_Word encoding; + Dwarf_Attribute attr_mem; + if (dwarf_attr_integrate (&typedie, DW_AT_encoding, &attr_mem) == NULL + || dwarf_formudata (&attr_mem, &encoding) != 0) + return -1; + + switch (encoding) + { + case DW_ATE_complex_float: + *countp = 2; + break; + + case DW_ATE_float: + *countp = 1; + break; + + default: + return 1; + } + + if (dwarf_bytesize_aux (&typedie, sizep) < 0) + return -1; + + *sizep /= *countp; + return 0; + + case DW_TAG_structure_type: + case DW_TAG_union_type: + case DW_TAG_array_type: + return hfa_type (&typedie, tag, sizep, countp); + } + + return 1; +} + +static int +hfa_type (Dwarf_Die *ftypedie, int tag, Dwarf_Word *sizep, Dwarf_Word *countp) +{ + assert (tag == DW_TAG_structure_type || tag == DW_TAG_class_type + || tag == DW_TAG_union_type || tag == DW_TAG_array_type); + + int i; + if (tag == DW_TAG_array_type) + { + Dwarf_Word tot_size; + if (dwarf_aggregate_size (ftypedie, &tot_size) < 0) + return -1; + + /* For vector types, we don't care about the underlying + type, but only about the vector type itself. */ + bool vec; + Dwarf_Attribute attr_mem; + if (dwarf_formflag (dwarf_attr_integrate (ftypedie, DW_AT_GNU_vector, + &attr_mem), &vec) == 0 + && vec) + { + *sizep = tot_size; + *countp = 1; + + return 0; + } + + if ((i = member_is_fp (ftypedie, sizep, countp)) == 0) + { + *countp = tot_size / *sizep; + return 0; + } + + return i; + } + + /* Find first DW_TAG_member and determine its type. */ + Dwarf_Die member; + if ((i = dwarf_child (ftypedie, &member) != 0)) + return i; + + if ((i = skip_until (&member, DW_TAG_member)) != 0) + return i; + + *countp = 0; + if ((i = member_is_fp (&member, sizep, countp)) != 0) + return i; + + while ((i = dwarf_siblingof (&member, &member)) == 0 + && (i = skip_until (&member, DW_TAG_member)) == 0) + { + Dwarf_Word size, count; + if ((i = member_is_fp (&member, &size, &count)) != 0) + return i; + + if (*sizep != size) + return 1; + + *countp += count; + } + + /* At this point we already have at least one FP member, which means + FTYPEDIE is an HFA. So either return 0, or propagate error. */ + return i < 0 ? i : 0; +} + +static int +pass_in_gpr (const Dwarf_Op **locp, Dwarf_Word size) +{ + static const Dwarf_Op loc[] = + { + { .atom = DW_OP_reg0 }, { .atom = DW_OP_piece, .number = 8 }, + { .atom = DW_OP_reg1 }, { .atom = DW_OP_piece, .number = 8 } + }; + + *locp = loc; + return size <= 8 ? 1 : 4; +} + +static int +pass_by_ref (const Dwarf_Op **locp) +{ + static const Dwarf_Op loc[] = { { .atom = DW_OP_breg0 } }; + + *locp = loc; + return 1; +} + +static int +pass_hfa (const Dwarf_Op **locp, Dwarf_Word size, Dwarf_Word count) +{ + assert (count >= 1 && count <= 4); + assert (size == 2 || size == 4 || size == 8 || size == 16); + +#define DEFINE_FPREG(NAME, SIZE) \ + static const Dwarf_Op NAME[] = { \ + { .atom = DW_OP_regx, .number = 64 }, \ + { .atom = DW_OP_piece, .number = SIZE }, \ + { .atom = DW_OP_regx, .number = 65 }, \ + { .atom = DW_OP_piece, .number = SIZE }, \ + { .atom = DW_OP_regx, .number = 66 }, \ + { .atom = DW_OP_piece, .number = SIZE }, \ + { .atom = DW_OP_regx, .number = 67 }, \ + { .atom = DW_OP_piece, .number = SIZE } \ + } + + switch (size) + { + case 2:; + DEFINE_FPREG (loc_hfa_2, 2); + *locp = loc_hfa_2; + break; + + case 4:; + DEFINE_FPREG (loc_hfa_4, 4); + *locp = loc_hfa_4; + break; + + case 8:; + DEFINE_FPREG (loc_hfa_8, 8); + *locp = loc_hfa_8; + break; + + case 16:; + DEFINE_FPREG (loc_hfa_16, 16); + *locp = loc_hfa_16; + break; + } +#undef DEFINE_FPREG + + return count == 1 ? 1 : 2 * count; +} + +static int +pass_in_simd (const Dwarf_Op **locp) +{ + /* This is like passing single-element HFA. Size doesn't matter, so + pretend it's for example double. */ + return pass_hfa (locp, 8, 1); +} + +int +aarch64_return_value_location (Dwarf_Die *functypedie, const Dwarf_Op **locp) +{ + /* Start with the function's type, and get the DW_AT_type attribute, + which is the type of the return value. */ + Dwarf_Die typedie; + int tag = dwarf_peeled_die_type (functypedie, &typedie); + if (tag <= 0) + return tag; + + Dwarf_Word size = (Dwarf_Word)-1; + + /* If the argument type is a Composite Type that is larger than 16 + bytes, then the argument is copied to memory allocated by the + caller and the argument is replaced by a pointer to the copy. */ + if (tag == DW_TAG_structure_type || tag == DW_TAG_union_type + || tag == DW_TAG_class_type || tag == DW_TAG_array_type) + { + Dwarf_Word base_size, count; + switch (hfa_type (&typedie, tag, &base_size, &count)) + { + default: + return -1; + + case 0: + assert (count > 0); + if (count <= 4) + return pass_hfa (locp, base_size, count); + /* Fall through. */ + + case 1: + /* Not a HFA. */ + if (dwarf_aggregate_size (&typedie, &size) < 0) + return -1; + if (size > 16) + return pass_by_ref (locp); + } + } + + if (tag == DW_TAG_base_type + || tag == DW_TAG_pointer_type || tag == DW_TAG_ptr_to_member_type) + { + if (dwarf_bytesize_aux (&typedie, &size) < 0) + { + if (tag == DW_TAG_pointer_type || tag == DW_TAG_ptr_to_member_type) + size = 8; + else + return -1; + } + + Dwarf_Attribute attr_mem; + if (tag == DW_TAG_base_type) + { + Dwarf_Word encoding; + if (dwarf_formudata (dwarf_attr_integrate (&typedie, DW_AT_encoding, + &attr_mem), + &encoding) != 0) + return -1; + + switch (encoding) + { + /* If the argument is a Half-, Single-, Double- or Quad- + precision Floating-point [...] the argument is allocated + to the least significant bits of register v[NSRN]. */ + case DW_ATE_float: + switch (size) + { + case 2: /* half */ + case 4: /* sigle */ + case 8: /* double */ + case 16: /* quad */ + return pass_in_simd (locp); + + default: + return -2; + } + + case DW_ATE_complex_float: + switch (size) + { + case 8: /* float _Complex */ + case 16: /* double _Complex */ + case 32: /* long double _Complex */ + return pass_hfa (locp, size / 2, 2); + + default: + return -2; + } + + /* If the argument is an Integral or Pointer Type, the + size of the argument is less than or equal to 8 bytes + [...] the argument is copied to the least significant + bits in x[NGRN]. */ + case DW_ATE_signed: + case DW_ATE_unsigned: + case DW_ATE_unsigned_char: + case DW_ATE_signed_char: + return pass_in_gpr (locp, size); + } + + return -2; + } + else + return pass_in_gpr (locp, size); + } + + *locp = NULL; + return 0; +} diff --git a/backends/aarch64_symbol.c b/backends/aarch64_symbol.c new file mode 100644 index 000000000..b0f3377e2 --- /dev/null +++ b/backends/aarch64_symbol.c @@ -0,0 +1,56 @@ +/* AArch64 specific symbolic name handling. + Copyright (C) 2013 Red Hat, Inc. + This file is part of elfutils. + + This file is free software; you can redistribute it and/or modify + it under the terms of either + + * the GNU Lesser General Public License as published by the Free + Software Foundation; either version 3 of the License, or (at + your option) any later version + + or + + * the GNU General Public License as published by the Free + Software Foundation; either version 2 of the License, or (at + your option) any later version + + or both in parallel, as here. + + elfutils is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received copies of the GNU General Public License and + the GNU Lesser General Public License along with this program. If + not, see . */ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#include +#include + +#define BACKEND aarch64_ +#include "libebl_CPU.h" + + +/* Check for the simple reloc types. */ +Elf_Type +aarch64_reloc_simple_type (Ebl *ebl __attribute__ ((unused)), int type) +{ + switch (type) + { + case R_AARCH64_ABS64: + return ELF_T_XWORD; + case R_AARCH64_ABS32: + return ELF_T_WORD; + case R_AARCH64_ABS16: + return ELF_T_HALF; + + default: + return ELF_T_NUM; + } +} diff --git a/backends/libebl_CPU.h b/backends/libebl_CPU.h index 09c8cd10b..3ad925886 100644 --- a/backends/libebl_CPU.h +++ b/backends/libebl_CPU.h @@ -1,5 +1,5 @@ /* Common interface for libebl modules. - Copyright (C) 2000, 2001, 2002, 2003, 2005 Red Hat, Inc. + Copyright (C) 2000, 2001, 2002, 2003, 2005, 2013 Red Hat, Inc. This file is part of elfutils. This file is free software; you can redistribute it and/or modify @@ -29,6 +29,7 @@ #ifndef _LIBEBL_CPU_H #define _LIBEBL_CPU_H 1 +#include #include #define EBLHOOK(name) EBLHOOK_1(BACKEND, name) @@ -52,4 +53,38 @@ extern bool (*generic_debugscn_p) (const char *) attribute_hidden; if (_die == NULL) return -1; \ dwarf_tag (_die); }) +/* Follow typedefs and qualifiers to get to the actual type. */ +static inline int +dwarf_peel_type (Dwarf_Die *typediep, Dwarf_Attribute *attrp) +{ + int tag = DWARF_TAG_OR_RETURN (typediep); + while (tag == DW_TAG_typedef + || tag == DW_TAG_const_type || tag == DW_TAG_volatile_type + || tag == DW_TAG_restrict_type || tag == DW_TAG_mutable_type) + { + attrp = dwarf_attr_integrate (typediep, DW_AT_type, attrp); + typediep = dwarf_formref_die (attrp, typediep); + tag = DWARF_TAG_OR_RETURN (typediep); + } + + return tag; +} + +/* Get a type die corresponding to DIE. Peel CV qualifiers off + it. */ +static inline int +dwarf_peeled_die_type (Dwarf_Die *die, Dwarf_Die *result) +{ + Dwarf_Attribute attr_mem; + Dwarf_Attribute *attr = dwarf_attr_integrate (die, DW_AT_type, &attr_mem); + if (attr == NULL) + /* The function has no return value, like a `void' function in C. */ + return 0; + + if (dwarf_formref_die (attr, result) == NULL) + return -1; + + return dwarf_peel_type (result, attr); +} + #endif /* libebl_CPU.h */ diff --git a/libebl/ChangeLog b/libebl/ChangeLog index eed4481e1..a5c9dae1d 100644 --- a/libebl/ChangeLog +++ b/libebl/ChangeLog @@ -1,3 +1,7 @@ +2013-11-25 Petr Machata + + * eblopenbackend.c (machines): Add entry for AArch64. + 2013-11-14 Jan Kratochvil Code cleanup: Remove const in prototype diff --git a/libebl/eblopenbackend.c b/libebl/eblopenbackend.c index ed0c0ffe2..c19ae1b2c 100644 --- a/libebl/eblopenbackend.c +++ b/libebl/eblopenbackend.c @@ -1,5 +1,5 @@ /* Generate ELF backend handle. - Copyright (C) 2000-2011 Red Hat, Inc. + Copyright (C) 2000-2013 Red Hat, Inc. This file is part of elfutils. This file is free software; you can redistribute it and/or modify @@ -131,6 +131,7 @@ static const struct { "openrisc", "elf_openrisc", "openrisc", 8, EM_OPENRISC, 0, 0 }, { "arc", "elf_arc_a5", "arc_a5", 6, EM_ARC_A5, 0, 0 }, { "xtensa", "elf_xtensa", "xtensa", 6, EM_XTENSA, 0, 0 }, + { "aarch64", "elf_aarch64", "aarch64", 7, EM_AARCH64, ELFCLASS64, 0 }, }; #define nmachines (sizeof (machines) / sizeof (machines[0])) diff --git a/src/ChangeLog b/src/ChangeLog index 665868705..f899858f9 100644 --- a/src/ChangeLog +++ b/src/ChangeLog @@ -1,3 +1,7 @@ +2013-11-25 Petr Machata + + * elflint.c (valid_e_machine): Add EM_AARCH64. + 2013-11-14 Petr Machata * readelf.c (handle_core_item) <'h'>: New branch for handling diff --git a/src/elflint.c b/src/elflint.c index acd458b8c..e42072b23 100644 --- a/src/elflint.c +++ b/src/elflint.c @@ -1,5 +1,5 @@ /* Pedantic checking of ELF files compliance with gABI/psABI spec. - Copyright (C) 2001-2012 Red Hat, Inc. + Copyright (C) 2001-2013 Red Hat, Inc. This file is part of elfutils. Written by Ulrich Drepper , 2001. @@ -331,7 +331,7 @@ static const int valid_e_machine[] = EM_CRIS, EM_JAVELIN, EM_FIREPATH, EM_ZSP, EM_MMIX, EM_HUANY, EM_PRISM, EM_AVR, EM_FR30, EM_D10V, EM_D30V, EM_V850, EM_M32R, EM_MN10300, EM_MN10200, EM_PJ, EM_OPENRISC, EM_ARC_A5, EM_XTENSA, EM_ALPHA, - EM_TILEGX, EM_TILEPRO + EM_TILEGX, EM_TILEPRO, EM_AARCH64 }; #define nvalid_e_machine \ (sizeof (valid_e_machine) / sizeof (valid_e_machine[0])) diff --git a/tests/ChangeLog b/tests/ChangeLog index 9a8ac6132..ee4807436 100644 --- a/tests/ChangeLog +++ b/tests/ChangeLog @@ -1,3 +1,14 @@ +2013-11-25 Petr Machata + + * testfile_aarch64_core.bz2, hello_aarch64.ko.bz2: New files. + * funcretval_test.c, funcretval_test_aarch64.bz2: Likewise. + * Makefile.am (EXTRA_DIST): Add these. + (TESTS): Add run-funcretval.sh. + * run-allregs.sh: Use testfile_aarch64_core.bz2 for a regs_test. + * run-readelf-mixed-corenote.sh: ... and for a readelf -n test. + * run-strip-reloc.sh: Add a test on hello_aarch64.ko.bz2. + * run-funcretval.sh: New file. + 2013-11-18 Josh Stone * testfilebazdbg_plr.bz2: New testfile. diff --git a/tests/Makefile.am b/tests/Makefile.am index 4f8e9e49c..9615d6eaf 100644 --- a/tests/Makefile.am +++ b/tests/Makefile.am @@ -89,7 +89,7 @@ TESTS = run-arextract.sh run-arsymtest.sh newfile test-nlist \ run-test-archive64.sh run-readelf-vmcoreinfo.sh \ run-readelf-mixed-corenote.sh run-dwfllines.sh \ run-dwfl-report-elf-align.sh run-addr2line-test.sh \ - run-addr2line-i-test.sh run-varlocs.sh + run-addr2line-i-test.sh run-varlocs.sh run-funcretval.sh if !STANDALONE check_PROGRAMS += msg_tst md5-sha1-test @@ -124,7 +124,7 @@ EXTRA_DIST = run-arextract.sh run-arsymtest.sh \ run-strip-test4.sh run-strip-test5.sh run-strip-test6.sh \ run-strip-test7.sh run-strip-test8.sh run-strip-groups.sh \ run-strip-reloc.sh hello_i386.ko.bz2 hello_x86_64.ko.bz2 \ - hello_ppc64.ko.bz2 hello_s390.ko.bz2 \ + hello_ppc64.ko.bz2 hello_s390.ko.bz2 hello_aarch64.ko.bz2 \ run-unstrip-test.sh run-unstrip-test2.sh run-unstrip-M.sh\ run-elflint-self.sh run-ranlib-test.sh run-ranlib-test2.sh \ run-ranlib-test3.sh run-ranlib-test4.sh \ @@ -216,7 +216,9 @@ EXTRA_DIST = run-arextract.sh run-arsymtest.sh \ testfile_implicit_pointer.c testfile_implicit_pointer.bz2 \ testfile_parameter_ref.c testfile_parameter_ref.bz2 \ testfile_entry_value.c testfile_entry_value.bz2 \ - testfile_implicit_value.c testfile_implicit_value.bz2 + testfile_implicit_value.c testfile_implicit_value.bz2 \ + testfile_aarch64_core.bz2 \ + funcretval_test.c funcretval_test_aarch64.bz2 if USE_VALGRIND valgrind_cmd='valgrind -q --trace-children=yes --error-exitcode=1 --run-libc-freeres=no' diff --git a/tests/funcretval_test.c b/tests/funcretval_test.c new file mode 100644 index 000000000..7e20f5265 --- /dev/null +++ b/tests/funcretval_test.c @@ -0,0 +1,828 @@ +signed char fun_char (void) { return 5; } +short fun_short (void) { return 6; } +int fun_int (void) { return 7; } +void *fun_ptr (void) { return &fun_ptr; } +int fun_iptr (void) { return 8; } +long fun_long (void) { return 9; } +__int128 fun_int128 (void) { return 10; } + +typedef struct { int i[10]; } large_struct1_t; +large_struct1_t fun_large_struct1 (void) { + large_struct1_t ret = { { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 } }; + return ret; +} + +typedef struct { int i1; int i2; int i3; int i4; int i5; + int i6; int i7; int i8; int i9; int i10; } large_struct2_t; +large_struct2_t fun_large_struct2 (void) { + large_struct2_t ret = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; + return ret; +} + +float fun_float (void) { return 1.5; } +float _Complex fun_float_complex (void) { return 1.5 + 2.5i; } + +double fun_double (void) { return 2.5; } +double _Complex fun_double_complex (void) { return 2.5 + 3.5i; } + +long double fun_long_double (void) { return 3.5; } +long double _Complex fun_long_double_complex (void) { return 4.5 + 5.5i; } + +#ifdef FLOAT128 +__float128 fun_float128 (void) { return 3.5; } +#endif + +// 8 byte vectors. + +typedef signed char __attribute__ ((vector_size (8))) vec_char_8_t; +vec_char_8_t fun_vec_char_8 (void) { + vec_char_8_t ret = { 1, 2, 3, 4, 5, 6, 7, 8 }; + return ret; +} + +typedef short __attribute__ ((vector_size (8))) vec_short_8_t; +vec_short_8_t fun_vec_short_8 (void) { + vec_short_8_t ret = { 2, 3, 4, 5 }; + return ret; +} + +typedef int __attribute__ ((vector_size (8))) vec_int_8_t; +vec_int_8_t fun_vec_int_8 (void) { + vec_int_8_t ret = { 3, 4 }; + return ret; +} + +typedef long __attribute__ ((vector_size (8))) vec_long_8_t; +vec_long_8_t fun_vec_long_8 (void) { + vec_long_8_t ret = { 5 }; + return ret; +} + +typedef float __attribute__ ((vector_size (8))) vec_float_8_t; +vec_float_8_t fun_vec_float_8 (void) { + vec_float_8_t ret = { 1.5, 2.5 }; + return ret; +} + +typedef double __attribute__ ((vector_size (8))) vec_double_8_t; +#ifndef AARCH64_BUG_1032854 +// https://bugzilla.redhat.com/show_bug.cgi?id=1032854 +vec_double_8_t fun_vec_double_8 (void) { + vec_double_8_t ret = { 3.5 }; + return ret; +} +#endif + +// 16 byte vectors. + +typedef signed char __attribute__ ((vector_size (16))) vec_char_16_t; +vec_char_16_t fun_vec_char_16 (void) { + vec_char_16_t ret = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }; + return ret; +} + +typedef short __attribute__ ((vector_size (16))) vec_short_16_t; +vec_short_16_t fun_vec_short_16 (void) { + vec_short_16_t ret = { 2, 3, 4, 5, 6, 7, 8 }; + return ret; +} + +typedef int __attribute__ ((vector_size (16))) vec_int_16_t; +vec_int_16_t fun_vec_int_16 (void) { + vec_int_16_t ret = { 2, 3, 4 }; + return ret; +} + +typedef long __attribute__ ((vector_size (16))) vec_long_16_t; +vec_long_16_t fun_vec_long_16 (void) { + vec_long_16_t ret = { 3, 4 }; + return ret; +} + +typedef __int128 __attribute__ ((vector_size (16))) vec_int128_16_t; +vec_int128_16_t fun_vec_int128_16 (void) { + vec_int128_16_t ret = { 999 }; + return ret; +} + +typedef float __attribute__ ((vector_size (16))) vec_float_16_t; +vec_float_16_t fun_vec_float_16 (void) { + vec_float_16_t ret = { 1.5, 2.5, 3.5, 4.5 }; + return ret; +} + +typedef double __attribute__ ((vector_size (16))) vec_double_16_t; +vec_double_16_t fun_vec_double_16 (void) { + vec_double_16_t ret = { 2.5, 5 }; + return ret; +} + +#ifdef FLOAT128 +typedef __float128 __attribute__ ((vector_size (16))) vec_float128_16_t; +vec_float128_16_t fun_vec_float128_16 (void) { + vec_float128_16_t ret = { 7.5 }; + return ret; +} +#endif + +// Homogeneous floating-point aggregates. + +typedef struct { float f; } hfa1_float_t; +hfa1_float_t fun_hfa1_float (void) { + hfa1_float_t ret = { 1.5 }; + return ret; +} + +typedef struct { double f; } hfa1_double_t; +hfa1_double_t fun_hfa1_double (void) { + hfa1_double_t ret = { 3.0 }; + return ret; +} + +typedef struct { long double f; } hfa1_long_double_t; +hfa1_long_double_t fun_hfa1_long_double (void) { + hfa1_long_double_t ret = { 3.0 }; + return ret; +} + +typedef struct { float f[1]; } hfa1_float_a_t; +hfa1_float_a_t fun_hfa1_float_a (void) { + hfa1_float_a_t ret = { { 1.5 } }; + return ret; +} + +typedef struct { double f[1]; } hfa1_double_a_t; +hfa1_double_a_t fun_hfa1_double_a (void) { + hfa1_double_a_t ret = { { 3.0 } }; + return ret; +} + +typedef struct { long double f[1]; } hfa1_long_double_a_t; +hfa1_long_double_a_t fun_hfa1_long_double_a (void) { + hfa1_long_double_a_t ret = { { 3.0 } }; + return ret; +} + +typedef struct { float f; float g; } hfa2_float_t; +hfa2_float_t fun_hfa2_float (void) { + hfa2_float_t ret = { 1.5, 3.0 }; + return ret; +} + +typedef struct { double f; double g; } hfa2_double_t; +hfa2_double_t fun_hfa2_double (void) { + hfa2_double_t ret = { 3.0, 4.5 }; + return ret; +} + +typedef struct { long double f; long double g; } hfa2_long_double_t; +hfa2_long_double_t fun_hfa2_long_double (void) { + hfa2_long_double_t ret = { 3.0, 4.5 }; + return ret; +} + +typedef struct { float f[2]; } hfa2_float_a_t; +hfa2_float_a_t fun_hfa2_float_a (void) { + hfa2_float_a_t ret = { { 2.5, 3.5 } }; + return ret; +} + +typedef struct { double f[2]; } hfa2_double_a_t; +hfa2_double_a_t fun_hfa2_double_a (void) { + hfa2_double_a_t ret = { { 3.0, 3.5 } }; + return ret; +} + +typedef struct { long double f[2]; } hfa2_long_double_a_t; +hfa2_long_double_a_t fun_hfa2_long_double_a (void) { + hfa2_long_double_a_t ret = { { 3.0, 4.0 } }; + return ret; +} + +typedef struct { float f; float g; float h; } hfa3_float_t; +hfa3_float_t fun_hfa3_float (void) { + hfa3_float_t ret = { 1.5, 3.0, 4.5 }; + return ret; +} + +typedef struct { double f; double g; double h; } hfa3_double_t; +hfa3_double_t fun_hfa3_double (void) { + hfa3_double_t ret = { 3.0, 4.5, 9.5 }; + return ret; +} + +typedef struct { long double f; long double g; long double h; } hfa3_long_double_t; +hfa3_long_double_t fun_hfa3_long_double (void) { + hfa3_long_double_t ret = { 3.0, 4.5, 9.5 }; + return ret; +} + +typedef struct { float f[3]; } hfa3_float_a_t; +hfa3_float_a_t fun_hfa3_float_a (void) { + hfa3_float_a_t ret = { { 3.5, 4.5, 5.5 } }; + return ret; +} + +typedef struct { double f[3]; } hfa3_double_a_t; +hfa3_double_a_t fun_hfa3_double_a (void) { + hfa3_double_a_t ret = { { 3.0, 3.5, 4.0 } }; + return ret; +} + +typedef struct { long double f[3]; } hfa3_long_double_a_t; +hfa3_long_double_a_t fun_hfa3_long_double_a (void) { + hfa3_long_double_a_t ret = { { 3.0, 4.0, 5.0 } }; + return ret; +} + +typedef struct { float f; float g; float h; float i; } hfa4_float_t; +hfa4_float_t fun_hfa4_float (void) { + hfa4_float_t ret = { 1.5, 3.5, 4.5, 9.5 }; + return ret; +} + +typedef struct { double f; double g; double h; double i; } hfa4_double_t; +hfa4_double_t fun_hfa4_double (void) { + hfa4_double_t ret = { 3.5, 4.5, 9.5, 1.5 }; + return ret; +} + +typedef struct { long double f; long double g; long double h; long double i; } hfa4_long_double_t; +hfa4_long_double_t fun_hfa4_long_double (void) { + hfa4_long_double_t ret = { 3.5, 4.5, 9.5, 1.5 }; + return ret; +} + +typedef struct { float f[4]; } hfa4_float_a_t; +hfa4_float_a_t fun_hfa4_float_a (void) { + hfa4_float_a_t ret = { { 4.5, 5.5, 6.5, 7.5 } }; + return ret; +} + +typedef struct { double f[4]; } hfa4_double_a_t; +hfa4_double_a_t fun_hfa4_double_a (void) { + hfa4_double_a_t ret = { { 3.0, 4.5, 5.0, 5.5 } }; + return ret; +} + +typedef struct { long double f[4]; } hfa4_long_double_a_t; +hfa4_long_double_a_t fun_hfa4_long_double_a (void) { + hfa4_long_double_a_t ret = { { 3.0, 4.0, 5.0, 6.0 } }; + return ret; +} + +typedef struct { float f; float g; float h; float i; float j; } nfa5_float_t; +nfa5_float_t fun_nfa5_float (void) { + nfa5_float_t ret = { 1.5, 3.5, 4.5, 9.5, 10.5 }; + return ret; +} + +typedef struct { double f; double g; double h; double i; double j; } nfa5_double_t; +nfa5_double_t fun_nfa5_double (void) { + nfa5_double_t ret = { 3.5, 4.5, 9.5, 1.5, 2.5 }; + return ret; +} + +typedef struct { long double f; long double g; long double h; long double i; long double j; } nfa5_long_double_t; +nfa5_long_double_t fun_nfa5_long_double (void) { + nfa5_long_double_t ret = { 3.5, 4.5, 9.5, 1.5, 2.5 }; + return ret; +} + +typedef struct { float f[5]; } nfa5_float_a_t; +nfa5_float_a_t fun_nfa5_float_a (void) { + nfa5_float_a_t ret = { { 4.5, 5.5, 6.5, 7.5, 9.5 } }; + return ret; +} + +typedef struct { double f[5]; } nfa5_double_a_t; +nfa5_double_a_t fun_nfa5_double_a (void) { + nfa5_double_a_t ret = { { 3.0, 4.5, 5.0, 5.5, 6.5 } }; + return ret; +} + +typedef struct { long double f[5]; } nfa5_long_double_a_t; +nfa5_long_double_a_t fun_nfa5_long_double_a (void) { + nfa5_long_double_a_t ret = { { 3.0, 4.0, 5.0, 6.0, 7.0 } }; + return ret; +} + +#ifdef FLOAT128 +typedef struct { __float128 f; } hfa1_float128_t; +hfa1_float128_t fun_hfa1_float128 (void) { + hfa1_float128_t ret = { 4.5 }; + return ret; +} + +typedef struct { __float128 f; __float128 g; } hfa2_float128_t; +hfa2_float128_t fun_hfa2_float128 (void) { + hfa2_float128_t ret = { 4.5, 9.5 }; + return ret; +} + +typedef struct { __float128 f; __float128 g; __float128 h; } hfa3_float128_t; +hfa3_float128_t fun_hfa3_float128 (void) { + hfa3_float128_t ret = { 4.5, 9.5, 12.5 }; + return ret; +} + +typedef struct { __float128 f; __float128 g; __float128 h; __float128 i; } hfa4_float128_t; +hfa4_float128_t fun_hfa4_float128 (void) { + hfa4_float128_t ret = { 4.5, 9.5, 3.5, 1.5 }; + return ret; +} +#endif + +// Homogeneous vector aggregates of 1 element. + +typedef struct { vec_char_8_t a; } hva1_vec_char_8_t; +hva1_vec_char_8_t fun_hva1_vec_char_8 (void) { + hva1_vec_char_8_t ret = { { 1, 2, 3, 4, 5, 6, 7, 8 } }; + return ret; +} + +typedef struct { vec_short_8_t a; } hva1_vec_short_8_t; +hva1_vec_short_8_t fun_hva1_vec_short_8 (void) { + hva1_vec_short_8_t ret = { { 2, 3, 4, 5 } }; + return ret; +} + +typedef struct { vec_int_8_t a; } hva1_vec_int_8_t; +hva1_vec_int_8_t fun_hva1_vec_int_8 (void) { + hva1_vec_int_8_t ret = { { 3, 4 } }; + return ret; +} + +typedef struct { vec_long_8_t a; } hva1_vec_long_8_t; +hva1_vec_long_8_t fun_hva1_vec_long_8 (void) { + hva1_vec_long_8_t ret = { { 5 } }; + return ret; +} + +typedef struct { vec_float_8_t a; } hva1_vec_float_8_t; +hva1_vec_float_8_t fun_hva1_vec_float_8 (void) { + hva1_vec_float_8_t ret = { { 1.5, 2.5 } }; + return ret; +} + +typedef struct { vec_double_8_t a; } hva1_vec_double_8_t; +hva1_vec_double_8_t fun_hva1_vec_double_8 (void) { + hva1_vec_double_8_t ret = { { 3.5 } }; + return ret; +} + +typedef struct { vec_char_16_t a; } hva1_vec_char_16_t; +hva1_vec_char_16_t fun_hva1_vec_char_16_t (void) { + hva1_vec_char_16_t ret = { { 1, 2, 3, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16 } }; + return ret; +} + +typedef struct { vec_short_16_t a; } hva1_vec_short_16_t; +hva1_vec_short_16_t fun_hva1_vec_short_16_t (void) { + hva1_vec_short_16_t ret = { { 2, 3, 4, 5, 6, 7, 8, 9 } }; + return ret; +} + +typedef struct { vec_int_16_t a; } hva1_vec_int_16_t; +hva1_vec_int_16_t fun_hva1_vec_int_16_t (void) { + hva1_vec_int_16_t ret = { { 3, 4, 5, 6 } }; + return ret; +} + +typedef struct { vec_long_16_t a; } hva1_vec_long_16_t; +hva1_vec_long_16_t fun_hva1_vec_long_16_t (void) { + hva1_vec_long_16_t ret = { { 4, 5 } }; + return ret; +} + +typedef struct { vec_int128_16_t a; } hva1_vec_int128_16_t; +hva1_vec_int128_16_t fun_hva1_vec_int128_16_t (void) { + hva1_vec_int128_16_t ret = { { 6 } }; + return ret; +} + +typedef struct { vec_float_16_t a; } hva1_vec_float_16_t; +hva1_vec_float_16_t fun_hva1_vec_float_16_t (void) { + hva1_vec_float_16_t ret = { { 1.5, 2.5, 3.5, 4.5 } }; + return ret; +} + +typedef struct { vec_double_16_t a; } hva1_vec_double_16_t; +hva1_vec_double_16_t fun_hva1_vec_double_16_t (void) { + hva1_vec_double_16_t ret = { { 2.5, 3.5 } }; + return ret; +} + +#ifdef FLOAT128 +typedef struct { vec_float128_16_t a; } hva1_vec_float128_16_t; +hva1_vec_float128_16_t fun_hva1_vec_float128_16_t (void) { + hva1_vec_float128_16_t ret = { { 4.5 } }; + return ret; +} +#endif + +// Homogeneous vector aggregates of 2 elements. + +typedef struct { vec_char_8_t a; vec_char_8_t b; } hva2_vec_char_8_t; +hva2_vec_char_8_t fun_hva2_vec_char_8 (void) { + hva2_vec_char_8_t ret = { { 1, 2, 3, 4, 5, 6, 7, 8 }, + { 2, 3, 4, 5, 6, 7, 8, 9 } }; + return ret; +} + +typedef struct { vec_short_8_t a; vec_short_8_t b; } hva2_vec_short_8_t; +hva2_vec_short_8_t fun_hva2_vec_short_8 (void) { + hva2_vec_short_8_t ret = { { 2, 3, 4, 5 }, + { 3, 4, 5, 6 } }; + return ret; +} + +typedef struct { vec_int_8_t a; vec_int_8_t b; } hva2_vec_int_8_t; +hva2_vec_int_8_t fun_hva2_vec_int_8 (void) { + hva2_vec_int_8_t ret = { { 3, 4 }, + { 4, 5 } }; + return ret; +} + +typedef struct { vec_long_8_t a; vec_long_8_t b; } hva2_vec_long_8_t; +hva2_vec_long_8_t fun_hva2_vec_long_8 (void) { + hva2_vec_long_8_t ret = { { 5 }, + { 6 } }; + return ret; +} + +typedef struct { vec_float_8_t a; vec_float_8_t b; } hva2_vec_float_8_t; +hva2_vec_float_8_t fun_hva2_vec_float_8 (void) { + hva2_vec_float_8_t ret = { { 1.5, 2.5 }, + { 2.5, 3.5 } }; + return ret; +} + +typedef struct { vec_double_8_t a; vec_double_8_t b; } hva2_vec_double_8_t; +hva2_vec_double_8_t fun_hva2_vec_double_8 (void) { + hva2_vec_double_8_t ret = { { 3.5 }, + { 4.5 } }; + return ret; +} + +typedef struct { vec_char_16_t a; vec_char_16_t b; } hva2_vec_char_16_t; +hva2_vec_char_16_t fun_hva2_vec_char_16_t (void) { + hva2_vec_char_16_t ret = { { 1, 2, 3, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16 }, + { 2, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17 } }; + return ret; +} + +typedef struct { vec_short_16_t a; vec_short_16_t b; } hva2_vec_short_16_t; +hva2_vec_short_16_t fun_hva2_vec_short_16_t (void) { + hva2_vec_short_16_t ret = { { 2, 3, 4, 5, 6, 7, 8, 9 }, + { 3, 4, 5, 6, 7, 8, 9, 10 } }; + return ret; +} + +typedef struct { vec_int_16_t a; vec_int_16_t b; } hva2_vec_int_16_t; +hva2_vec_int_16_t fun_hva2_vec_int_16_t (void) { + hva2_vec_int_16_t ret = { { 3, 4, 5, 6 }, + { 4, 5, 6, 7 } }; + return ret; +} + +typedef struct { vec_long_16_t a; vec_long_16_t b; } hva2_vec_long_16_t; +hva2_vec_long_16_t fun_hva2_vec_long_16_t (void) { + hva2_vec_long_16_t ret = { { 4, 5 }, + { 5, 6 } }; + return ret; +} + +typedef struct { vec_int128_16_t a; vec_int128_16_t b; } hva2_vec_int128_16_t; +hva2_vec_int128_16_t fun_hva2_vec_int128_16_t (void) { + hva2_vec_int128_16_t ret = { { 6 }, + { 7 } }; + return ret; +} + +typedef struct { vec_float_16_t a; vec_float_16_t b; } hva2_vec_float_16_t; +hva2_vec_float_16_t fun_hva2_vec_float_16_t (void) { + hva2_vec_float_16_t ret = { { 1.5, 2.5, 3.5, 4.5 }, + { 2.5, 3.5, 4.5, 5.5 } }; + return ret; +} + +typedef struct { vec_double_16_t a; vec_double_16_t b; } hva2_vec_double_16_t; +hva2_vec_double_16_t fun_hva2_vec_double_16_t (void) { + hva2_vec_double_16_t ret = { { 2.5, 3.5 }, + { 3.5, 4.5 } }; + return ret; +} + +#ifdef FLOAT128 +typedef struct { vec_float128_16_t a; vec_float128_16_t b; } hva2_vec_float128_16_t; +hva2_vec_float128_16_t fun_hva2_vec_float128_16_t (void) { + hva2_vec_float128_16_t ret = { { 4.5 }, + { 5.5 } }; + return ret; +} +#endif + +// Homogeneous vector aggregates of 3 elements. + +typedef struct { vec_char_8_t a; vec_char_8_t b; vec_char_8_t c; } hva3_vec_char_8_t; +hva3_vec_char_8_t fun_hva3_vec_char_8 (void) { + hva3_vec_char_8_t ret = { { 1, 2, 3, 4, 5, 6, 7, 8 }, + { 2, 3, 4, 5, 6, 7, 8, 9 }, + { 3, 4, 5, 6, 7, 8, 9, 10 } }; + return ret; +} + +typedef struct { vec_short_8_t a; vec_short_8_t b; vec_short_8_t c; } hva3_vec_short_8_t; +hva3_vec_short_8_t fun_hva3_vec_short_8 (void) { + hva3_vec_short_8_t ret = { { 2, 3, 4, 5 }, + { 3, 4, 5, 6 }, + { 4, 5, 6, 7 } }; + return ret; +} + +typedef struct { vec_int_8_t a; vec_int_8_t b; vec_int_8_t c; } hva3_vec_int_8_t; +hva3_vec_int_8_t fun_hva3_vec_int_8 (void) { + hva3_vec_int_8_t ret = { { 3, 4 }, + { 4, 5 }, + { 5, 6 } }; + return ret; +} + +typedef struct { vec_long_8_t a; vec_long_8_t b; vec_long_8_t c; } hva3_vec_long_8_t; +hva3_vec_long_8_t fun_hva3_vec_long_8 (void) { + hva3_vec_long_8_t ret = { { 5 }, + { 6 }, + { 7 } }; + return ret; +} + +typedef struct { vec_float_8_t a; vec_float_8_t b; vec_float_8_t c; } hva3_vec_float_8_t; +hva3_vec_float_8_t fun_hva3_vec_float_8 (void) { + hva3_vec_float_8_t ret = { { 1.5, 2.5 }, + { 2.5, 3.5 }, + { 3.5, 4.5 } }; + return ret; +} + +typedef struct { vec_double_8_t a; vec_double_8_t b; vec_double_8_t c; } hva3_vec_double_8_t; +hva3_vec_double_8_t fun_hva3_vec_double_8 (void) { + hva3_vec_double_8_t ret = { { 3.5 }, + { 4.5 }, + { 5.5 } }; + return ret; +} + +typedef struct { vec_char_16_t a; vec_char_16_t b; vec_char_16_t c; } hva3_vec_char_16_t; +hva3_vec_char_16_t fun_hva3_vec_char_16_t (void) { + hva3_vec_char_16_t ret = { { 1, 2, 3, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16 }, + { 2, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17 }, + { 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18 } }; + return ret; +} + +typedef struct { vec_short_16_t a; vec_short_16_t b; vec_short_16_t c; } hva3_vec_short_16_t; +hva3_vec_short_16_t fun_hva3_vec_short_16_t (void) { + hva3_vec_short_16_t ret = { { 2, 3, 4, 5, 6, 7, 8, 9 }, + { 3, 4, 5, 6, 7, 8, 9, 10 }, + { 4, 5, 6, 7, 8, 9, 10, 11 } }; + return ret; +} + +typedef struct { vec_int_16_t a; vec_int_16_t b; vec_int_16_t c; } hva3_vec_int_16_t; +hva3_vec_int_16_t fun_hva3_vec_int_16_t (void) { + hva3_vec_int_16_t ret = { { 3, 4, 5, 6 }, + { 4, 5, 6, 7 }, + { 5, 6, 7, 8 } }; + return ret; +} + +typedef struct { vec_long_16_t a; vec_long_16_t b; vec_long_16_t c; } hva3_vec_long_16_t; +hva3_vec_long_16_t fun_hva3_vec_long_16_t (void) { + hva3_vec_long_16_t ret = { { 3, 4 }, + { 4, 5 }, + { 5, 6 } }; + return ret; +} + +typedef struct { vec_int128_16_t a; vec_int128_16_t b; vec_int128_16_t c; } hva3_vec_int128_16_t; +hva3_vec_int128_16_t fun_hva3_vec_int128_16_t (void) { + hva3_vec_int128_16_t ret = { { 6 }, + { 7 }, + { 8 } }; + return ret; +} + +typedef struct { vec_float_16_t a; vec_float_16_t b; vec_float_16_t c; } hva3_vec_float_16_t; +hva3_vec_float_16_t fun_hva3_vec_float_16_t (void) { + hva3_vec_float_16_t ret = { { 1.5, 2.5, 3.5, 4.5 }, + { 2.5, 3.5, 4.5, 5.5 }, + { 3.5, 4.5, 5.5, 6.5 } }; + return ret; +} + +typedef struct { vec_double_16_t a; vec_double_16_t b; vec_double_16_t c; } hva3_vec_double_16_t; +hva3_vec_double_16_t fun_hva3_vec_double_16_t (void) { + hva3_vec_double_16_t ret = { { 2.5, 3.5 }, + { 3.5, 4.5 }, + { 4.5, 5.5 } }; + return ret; +} + +#ifdef FLOAT128 +typedef struct { vec_float128_16_t a; vec_float128_16_t b; vec_float128_16_t c; } hva3_vec_float128_16_t; +hva3_vec_float128_16_t fun_hva3_vec_float128_16_t (void) { + hva3_vec_float128_16_t ret = { { 4.5 }, + { 5.5 }, + { 6.5 } }; + return ret; +} +#endif + +// Homogeneous vector aggregates of 3 elements. + +typedef struct { vec_char_8_t a; vec_char_8_t b; vec_char_8_t c; vec_char_8_t d; } hva4_vec_char_8_t; +hva4_vec_char_8_t fun_hva4_vec_char_8 (void) { + hva4_vec_char_8_t ret = { { 1, 2, 3, 4, 5, 6, 7, 8 }, + { 2, 3, 4, 5, 6, 7, 8, 9 }, + { 3, 4, 5, 6, 7, 8, 9, 10 }, + { 4, 5, 6, 7, 8, 9, 10, 11 } }; + return ret; +} + +typedef struct { vec_short_8_t a; vec_short_8_t b; vec_short_8_t c; vec_short_8_t d; } hva4_vec_short_8_t; +hva4_vec_short_8_t fun_hva4_vec_short_8 (void) { + hva4_vec_short_8_t ret = { { 2, 3, 4, 5 }, + { 3, 4, 5, 6 }, + { 4, 5, 6, 7 }, + { 5, 6, 7, 8 } }; + return ret; +} + +typedef struct { vec_int_8_t a; vec_int_8_t b; vec_int_8_t c; vec_int_8_t d; } hva4_vec_int_8_t; +hva4_vec_int_8_t fun_hva4_vec_int_8 (void) { + hva4_vec_int_8_t ret = { { 3, 4 }, + { 4, 5 }, + { 5, 6 }, + { 6, 7 } }; + return ret; +} + +typedef struct { vec_long_8_t a; vec_long_8_t b; vec_long_8_t c; vec_long_8_t d; } hva4_vec_long_8_t; +hva4_vec_long_8_t fun_hva4_vec_long_8 (void) { + hva4_vec_long_8_t ret = { { 5 }, + { 6 }, + { 7 }, + { 8 } }; + return ret; +} + +typedef struct { vec_float_8_t a; vec_float_8_t b; vec_float_8_t c; vec_float_8_t d; } hva4_vec_float_8_t; +hva4_vec_float_8_t fun_hva4_vec_float_8 (void) { + hva4_vec_float_8_t ret = { { 1.5, 2.5 }, + { 2.5, 3.5 }, + { 3.5, 4.5 }, + { 4.5, 5.5 } }; + return ret; +} + +typedef struct { vec_double_8_t a; vec_double_8_t b; vec_double_8_t c; vec_double_8_t d; } hva4_vec_double_8_t; +hva4_vec_double_8_t fun_hva4_vec_double_8 (void) { + hva4_vec_double_8_t ret = { { 3.5 }, + { 4.5 }, + { 5.5 }, + { 6.5 } }; + return ret; +} + +typedef struct { vec_char_16_t a; vec_char_16_t b; vec_char_16_t c; vec_char_16_t d; } hva4_vec_char_16_t; +hva4_vec_char_16_t fun_hva4_vec_char_16_t (void) { + hva4_vec_char_16_t ret = { { 1, 2, 3, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16 }, + { 2, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17 }, + { 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18 }, + { 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19 } }; + return ret; +} + +typedef struct { vec_short_16_t a; vec_short_16_t b; vec_short_16_t c; vec_short_16_t d; } hva4_vec_short_16_t; +hva4_vec_short_16_t fun_hva4_vec_short_16_t (void) { + hva4_vec_short_16_t ret = { { 2, 3, 4, 5, 6, 7, 8, 9 }, + { 3, 4, 5, 6, 7, 8, 9, 10 }, + { 4, 5, 6, 7, 8, 9, 10, 11 }, + { 5, 6, 7, 8, 9, 10, 11, 12 } }; + return ret; +} + +typedef struct { vec_int_16_t a; vec_int_16_t b; vec_int_16_t c; vec_int_16_t d; } hva4_vec_int_16_t; +hva4_vec_int_16_t fun_hva4_vec_int_16_t (void) { + hva4_vec_int_16_t ret = { { 3, 4, 5, 6 }, + { 4, 5, 6, 7 }, + { 5, 6, 7, 8 }, + { 6, 7, 8, 9 } }; + return ret; +} + +typedef struct { vec_long_16_t a; vec_long_16_t b; vec_long_16_t c; vec_long_16_t d; } hva4_vec_long_16_t; +hva4_vec_long_16_t fun_hva4_vec_long_16_t (void) { + hva4_vec_long_16_t ret = { { 3, 4 }, + { 4, 5 }, + { 5, 6 }, + { 6, 7 } }; + return ret; +} + +typedef struct { vec_int128_16_t a; vec_int128_16_t b; vec_int128_16_t c; vec_int128_16_t d; } hva4_vec_int128_16_t; +hva4_vec_int128_16_t fun_hva4_vec_int128_16_t (void) { + hva4_vec_int128_16_t ret = { { 6 }, + { 7 }, + { 8 }, + { 9 } }; + return ret; +} + +typedef struct { vec_float_16_t a; vec_float_16_t b; vec_float_16_t c; vec_float_16_t d; } hva4_vec_float_16_t; +hva4_vec_float_16_t fun_hva4_vec_float_16_t (void) { + hva4_vec_float_16_t ret = { { 1.5, 2.5, 3.5, 4.5 }, + { 2.5, 3.5, 4.5, 5.5 }, + { 3.5, 4.5, 5.5, 6.5 }, + { 4.5, 5.5, 6.5, 7.5 } }; + return ret; +} + +typedef struct { vec_double_16_t a; vec_double_16_t b; vec_double_16_t c; vec_double_16_t d; } hva4_vec_double_16_t; +hva4_vec_double_16_t fun_hva4_vec_double_16_t (void) { + hva4_vec_double_16_t ret = { { 2.5, 3.5 }, + { 3.5, 4.5 }, + { 4.5, 5.5 }, + { 5.5, 6.5 } }; + return ret; +} + +#ifdef FLOAT128 +typedef struct { vec_float128_16_t a; vec_float128_16_t b; vec_float128_16_t c; vec_float128_16_t d; } hva4_vec_float128_16_t; +hva4_vec_float128_16_t fun_hva4_vec_float128_16_t (void) { + hva4_vec_float128_16_t ret = { { 4.5 }, + { 5.5 }, + { 6.5 }, + { 7.5 } }; + return ret; +} +#endif + +// Mixed HFA. +typedef struct { float _Complex a; float b; } mixed_hfa3_cff_t; +mixed_hfa3_cff_t fun_mixed_hfa3_cff (void) { + mixed_hfa3_cff_t ret = { 1.5 + 2.5i, 3.5 }; + return ret; +} + +typedef struct { double _Complex a; double b; } mixed_hfa3_cdd_t; +mixed_hfa3_cdd_t fun_mixed_hfa3_cdd (void) { + mixed_hfa3_cdd_t ret = { 1.5 + 2.5i, 3.5 }; + return ret; +} + +typedef struct { long double _Complex a; long double b; } mixed_hfa3_cldld_t; +mixed_hfa3_cldld_t fun_mixed_hfa3_cldld (void) { + mixed_hfa3_cldld_t ret = { 1.5 + 2.5i, 3.5 }; + return ret; +} + +typedef struct { float b; float _Complex a; } mixed_hfa3_fcf_t; +mixed_hfa3_fcf_t fun_mixed_hfa3_fcf (void) { + mixed_hfa3_fcf_t ret = { 3.5, 1.5 + 2.5i }; + return ret; +} + +typedef struct { double b; double _Complex a; } mixed_hfa3_dcd_t; +mixed_hfa3_dcd_t fun_mixed_hfa3_dcd (void) { + mixed_hfa3_dcd_t ret = { 3.5, 1.5 + 2.5i }; + return ret; +} + +typedef struct { long double b; long double _Complex a; } mixed_hfa3_ldcld_t; +mixed_hfa3_ldcld_t fun_mixed_hfa3_ldcld (void) { + mixed_hfa3_ldcld_t ret = { 3.5, 1.5 + 2.5i }; + return ret; +} + +typedef struct { vec_float_8_t a; vec_short_8_t b; } mixed_hfa2_fltsht_t; +mixed_hfa2_fltsht_t fun_mixed_hfa2_fltsht_t (void) { + mixed_hfa2_fltsht_t ret = { { 3.5, 4.5 }, { 1, 2, 3, 4 } }; + return ret; +} + +int main(int argc, char *argv[]) +{ + return 0; +} diff --git a/tests/funcretval_test_aarch64.bz2 b/tests/funcretval_test_aarch64.bz2 new file mode 100755 index 0000000000000000000000000000000000000000..5494e102536b2fda2f73362ae07e93050c923ced GIT binary patch literal 15644 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. + +. $srcdir/test-subr.sh + +# The following files were obtaining by compiling funcretval_test.c +# from this directory as follows: +# +# gcc -g funcretval_test.c -o funcretval_test_ +# +# Pass -DFLOAT128 if the given arch supports __float128. + +testfiles funcretval_test_aarch64 + +# funcretval_test_aarch64 was built with additional flag: +# -DAARCH64_BUG_1032854 +# hence no fun_vec_double_8. +testrun_compare ${abs_top_builddir}/tests/funcretval \ + -e funcretval_test_aarch64 <<\EOF +() fun_char: return value location: {0x50, 0} +() fun_short: return value location: {0x50, 0} +() fun_int: return value location: {0x50, 0} +() fun_ptr: return value location: {0x50, 0} +() fun_iptr: return value location: {0x50, 0} +() fun_long: return value location: {0x50, 0} +() fun_int128: return value location: {0x50, 0} {0x93, 0x8} {0x51, 0} {0x93, 0x8} +() fun_large_struct1: return value location: {0x70, 0} +() fun_large_struct2: return value location: {0x70, 0} +() fun_float: return value location: {0x90, 0x40} +() fun_float_complex: return value location: {0x90, 0x40} {0x93, 0x4} {0x90, 0x41} {0x93, 0x4} +() fun_double: return value location: {0x90, 0x40} +() fun_double_complex: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41} {0x93, 0x8} +() fun_long_double: return value location: {0x90, 0x40} +() fun_long_double_complex: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41} {0x93, 0x10} +() fun_vec_char_8: return value location: {0x90, 0x40} +() fun_vec_short_8: return value location: {0x90, 0x40} +() fun_vec_int_8: return value location: {0x90, 0x40} +() fun_vec_long_8: return value location: {0x90, 0x40} +() fun_vec_float_8: return value location: {0x90, 0x40} +() fun_vec_char_16: return value location: {0x90, 0x40} +() fun_vec_short_16: return value location: {0x90, 0x40} +() fun_vec_int_16: return value location: {0x90, 0x40} +() fun_vec_long_16: return value location: {0x90, 0x40} +() fun_vec_int128_16: return value location: {0x90, 0x40} +() fun_vec_float_16: return value location: {0x90, 0x40} +() fun_vec_double_16: return value location: {0x90, 0x40} +() fun_hfa1_float: return value location: {0x90, 0x40} +() fun_hfa1_double: return value location: {0x90, 0x40} +() fun_hfa1_long_double: return value location: {0x90, 0x40} +() fun_hfa1_float_a: return value location: {0x90, 0x40} +() fun_hfa1_double_a: return value location: {0x90, 0x40} +() fun_hfa1_long_double_a: return value location: {0x90, 0x40} +() fun_hfa2_float: return value location: {0x90, 0x40} {0x93, 0x4} {0x90, 0x41} {0x93, 0x4} +() fun_hfa2_double: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41} {0x93, 0x8} +() fun_hfa2_long_double: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41} {0x93, 0x10} +() fun_hfa2_float_a: return value location: {0x90, 0x40} {0x93, 0x4} {0x90, 0x41} {0x93, 0x4} +() fun_hfa2_double_a: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41} {0x93, 0x8} +() fun_hfa2_long_double_a: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41} {0x93, 0x10} +() fun_hfa3_float: return value location: {0x90, 0x40} {0x93, 0x4} {0x90, 0x41} {0x93, 0x4} {0x90, 0x42} {0x93, 0x4} +() fun_hfa3_double: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41} {0x93, 0x8} {0x90, 0x42} {0x93, 0x8} +() fun_hfa3_long_double: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41} {0x93, 0x10} {0x90, 0x42} {0x93, 0x10} +() fun_hfa3_float_a: return value location: {0x90, 0x40} {0x93, 0x4} {0x90, 0x41} {0x93, 0x4} {0x90, 0x42} {0x93, 0x4} +() fun_hfa3_double_a: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41} {0x93, 0x8} {0x90, 0x42} {0x93, 0x8} +() fun_hfa3_long_double_a: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41} {0x93, 0x10} {0x90, 0x42} {0x93, 0x10} +() fun_hfa4_float: return value location: {0x90, 0x40} {0x93, 0x4} {0x90, 0x41} {0x93, 0x4} {0x90, 0x42} {0x93, 0x4} {0x90, 0x43} {0x93, 0x4} +() fun_hfa4_double: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41} {0x93, 0x8} {0x90, 0x42} {0x93, 0x8} {0x90, 0x43} {0x93, 0x8} +() fun_hfa4_long_double: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41} {0x93, 0x10} {0x90, 0x42} {0x93, 0x10} {0x90, 0x43} {0x93, 0x10} +() fun_hfa4_float_a: return value location: {0x90, 0x40} {0x93, 0x4} {0x90, 0x41} {0x93, 0x4} {0x90, 0x42} {0x93, 0x4} {0x90, 0x43} {0x93, 0x4} +() fun_hfa4_double_a: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41} {0x93, 0x8} {0x90, 0x42} {0x93, 0x8} {0x90, 0x43} {0x93, 0x8} +() fun_hfa4_long_double_a: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41} {0x93, 0x10} {0x90, 0x42} {0x93, 0x10} {0x90, 0x43} {0x93, 0x10} +() fun_nfa5_float: return value location: {0x70, 0} +() fun_nfa5_double: return value location: {0x70, 0} +() fun_nfa5_long_double: return value location: {0x70, 0} +() fun_nfa5_float_a: return value location: {0x70, 0} +() fun_nfa5_double_a: return value location: {0x70, 0} +() fun_nfa5_long_double_a: return value location: {0x70, 0} +() fun_hva1_vec_char_8: return value location: {0x90, 0x40} +() fun_hva1_vec_short_8: return value location: {0x90, 0x40} +() fun_hva1_vec_int_8: return value location: {0x90, 0x40} +() fun_hva1_vec_long_8: return value location: {0x90, 0x40} +() fun_hva1_vec_float_8: return value location: {0x90, 0x40} +() fun_hva1_vec_double_8: return value location: {0x90, 0x40} +() fun_hva1_vec_char_16_t: return value location: {0x90, 0x40} +() fun_hva1_vec_short_16_t: return value location: {0x90, 0x40} +() fun_hva1_vec_int_16_t: return value location: {0x90, 0x40} +() fun_hva1_vec_long_16_t: return value location: {0x90, 0x40} +() fun_hva1_vec_int128_16_t: return value location: {0x90, 0x40} +() fun_hva1_vec_float_16_t: return value location: {0x90, 0x40} +() fun_hva1_vec_double_16_t: return value location: {0x90, 0x40} +() fun_hva2_vec_char_8: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41} {0x93, 0x8} +() fun_hva2_vec_short_8: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41} {0x93, 0x8} +() fun_hva2_vec_int_8: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41} {0x93, 0x8} +() fun_hva2_vec_long_8: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41} {0x93, 0x8} +() fun_hva2_vec_float_8: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41} {0x93, 0x8} +() fun_hva2_vec_double_8: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41} {0x93, 0x8} +() fun_hva2_vec_char_16_t: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41} {0x93, 0x10} +() fun_hva2_vec_short_16_t: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41} {0x93, 0x10} +() fun_hva2_vec_int_16_t: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41} {0x93, 0x10} +() fun_hva2_vec_long_16_t: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41} {0x93, 0x10} +() fun_hva2_vec_int128_16_t: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41} {0x93, 0x10} +() fun_hva2_vec_float_16_t: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41} {0x93, 0x10} +() fun_hva2_vec_double_16_t: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41} {0x93, 0x10} +() fun_hva3_vec_char_8: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41} {0x93, 0x8} {0x90, 0x42} {0x93, 0x8} +() fun_hva3_vec_short_8: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41} {0x93, 0x8} {0x90, 0x42} {0x93, 0x8} +() fun_hva3_vec_int_8: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41} {0x93, 0x8} {0x90, 0x42} {0x93, 0x8} +() fun_hva3_vec_long_8: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41} {0x93, 0x8} {0x90, 0x42} {0x93, 0x8} +() fun_hva3_vec_float_8: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41} {0x93, 0x8} {0x90, 0x42} {0x93, 0x8} +() fun_hva3_vec_double_8: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41} {0x93, 0x8} {0x90, 0x42} {0x93, 0x8} +() fun_hva3_vec_char_16_t: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41} {0x93, 0x10} {0x90, 0x42} {0x93, 0x10} +() fun_hva3_vec_short_16_t: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41} {0x93, 0x10} {0x90, 0x42} {0x93, 0x10} +() fun_hva3_vec_int_16_t: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41} {0x93, 0x10} {0x90, 0x42} {0x93, 0x10} +() fun_hva3_vec_long_16_t: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41} {0x93, 0x10} {0x90, 0x42} {0x93, 0x10} +() fun_hva3_vec_int128_16_t: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41} {0x93, 0x10} {0x90, 0x42} {0x93, 0x10} +() fun_hva3_vec_float_16_t: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41} {0x93, 0x10} {0x90, 0x42} {0x93, 0x10} +() fun_hva3_vec_double_16_t: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41} {0x93, 0x10} {0x90, 0x42} {0x93, 0x10} +() fun_hva4_vec_char_8: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41} {0x93, 0x8} {0x90, 0x42} {0x93, 0x8} {0x90, 0x43} {0x93, 0x8} +() fun_hva4_vec_short_8: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41} {0x93, 0x8} {0x90, 0x42} {0x93, 0x8} {0x90, 0x43} {0x93, 0x8} +() fun_hva4_vec_int_8: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41} {0x93, 0x8} {0x90, 0x42} {0x93, 0x8} {0x90, 0x43} {0x93, 0x8} +() fun_hva4_vec_long_8: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41} {0x93, 0x8} {0x90, 0x42} {0x93, 0x8} {0x90, 0x43} {0x93, 0x8} +() fun_hva4_vec_float_8: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41} {0x93, 0x8} {0x90, 0x42} {0x93, 0x8} {0x90, 0x43} {0x93, 0x8} +() fun_hva4_vec_double_8: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41} {0x93, 0x8} {0x90, 0x42} {0x93, 0x8} {0x90, 0x43} {0x93, 0x8} +() fun_hva4_vec_char_16_t: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41} {0x93, 0x10} {0x90, 0x42} {0x93, 0x10} {0x90, 0x43} {0x93, 0x10} +() fun_hva4_vec_short_16_t: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41} {0x93, 0x10} {0x90, 0x42} {0x93, 0x10} {0x90, 0x43} {0x93, 0x10} +() fun_hva4_vec_int_16_t: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41} {0x93, 0x10} {0x90, 0x42} {0x93, 0x10} {0x90, 0x43} {0x93, 0x10} +() fun_hva4_vec_long_16_t: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41} {0x93, 0x10} {0x90, 0x42} {0x93, 0x10} {0x90, 0x43} {0x93, 0x10} +() fun_hva4_vec_int128_16_t: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41} {0x93, 0x10} {0x90, 0x42} {0x93, 0x10} {0x90, 0x43} {0x93, 0x10} +() fun_hva4_vec_float_16_t: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41} {0x93, 0x10} {0x90, 0x42} {0x93, 0x10} {0x90, 0x43} {0x93, 0x10} +() fun_hva4_vec_double_16_t: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41} {0x93, 0x10} {0x90, 0x42} {0x93, 0x10} {0x90, 0x43} {0x93, 0x10} +() fun_mixed_hfa3_cff: return value location: {0x90, 0x40} {0x93, 0x4} {0x90, 0x41} {0x93, 0x4} {0x90, 0x42} {0x93, 0x4} +() fun_mixed_hfa3_cdd: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41} {0x93, 0x8} {0x90, 0x42} {0x93, 0x8} +() fun_mixed_hfa3_cldld: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41} {0x93, 0x10} {0x90, 0x42} {0x93, 0x10} +() fun_mixed_hfa3_fcf: return value location: {0x90, 0x40} {0x93, 0x4} {0x90, 0x41} {0x93, 0x4} {0x90, 0x42} {0x93, 0x4} +() fun_mixed_hfa3_dcd: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41} {0x93, 0x8} {0x90, 0x42} {0x93, 0x8} +() fun_mixed_hfa3_ldcld: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41} {0x93, 0x10} {0x90, 0x42} {0x93, 0x10} +() fun_mixed_hfa2_fltsht_t: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41} {0x93, 0x8} +() main: return value location: {0x50, 0} +EOF + +exit 0 diff --git a/tests/run-readelf-mixed-corenote.sh b/tests/run-readelf-mixed-corenote.sh index 9a4380951..c176e2835 100755 --- a/tests/run-readelf-mixed-corenote.sh +++ b/tests/run-readelf-mixed-corenote.sh @@ -285,4 +285,144 @@ Note segment of 1476 bytes at offset 0x430: 3e001ba000-3e001bc000 001ba000 8192 /usr/lib64/libc-2.17.so EOF +# To reproduce this core dump, do this on an aarch64 machine: +# $ gcc -x c <(echo 'int main () { return *(int *)0x12345678; }') +# $ ./a.out +testfiles testfile_aarch64_core +testrun_compare ${abs_top_builddir}/src/readelf -n testfile_aarch64_core <<\EOF + +Note segment of 2512 bytes at offset 0x270: + Owner Data size Type + CORE 392 PRSTATUS + info.si_signo: 11, info.si_code: 0, info.si_errno: 0, cursig: 11 + sigpend: <> + sighold: <> + pid: 16547, ppid: 3822, pgrp: 16547, sid: 3822 + utime: 0.010000, stime: 0.000000, cutime: 0.000000, cstime: 0.000000 + pc: 0x0000000000400548, pstate: 0x0000000060000000, fpvalid: 1 + x0: 305419896 x1: 548685596648 + x2: 548685596664 x3: 4195648 + x4: 0 x5: 548536191688 + x6: 0 x7: -6341196323062964528 + x8: 135 x9: 4294967295 + x10: 4195026 x11: 184256 + x12: 144 x13: 15 + x14: 548536635328 x15: 0 + x16: 548534815304 x17: 4262024 + x18: 548685596000 x19: 0 + x20: 0 x21: 4195296 + x22: 0 x23: 0 + x24: 0 x25: 0 + x26: 0 x27: 0 + x28: 0 x29: 548685596320 + x30: 548534815544 sp: 0x0000007fc035c6a0 + CORE 136 PRPSINFO + state: 0, sname: R, zomb: 0, nice: 0, flag: 0x0000000000400400 + uid: 0, gid: 0, pid: 16547, ppid: 3822, pgrp: 16547, sid: 3822 + fname: a.out, psargs: ./a.out + CORE 128 SIGINFO + si_signo: 11, si_errno: 0, si_code: 1 + fault address: 0x12345678 + CORE 304 AUXV + SYSINFO_EHDR: 0x7fb7500000 + HWCAP: 0x3 + PAGESZ: 65536 + CLKTCK: 100 + PHDR: 0x400040 + PHENT: 56 + PHNUM: 7 + BASE: 0x7fb7520000 + FLAGS: 0 + ENTRY: 0x4003e0 + UID: 0 + EUID: 0 + GID: 0 + EGID: 0 + SECURE: 0 + RANDOM: 0x7fc035c9e8 + EXECFN: 0x7fc035fff0 + PLATFORM: 0x7fc035c9f8 + NULL + CORE 306 FILE + 6 files: + 00400000-00410000 00000000 65536 /root/elfutils/build/a.out + 00410000-00420000 00000000 65536 /root/elfutils/build/a.out + 7fb7370000-7fb74d0000 00000000 1441792 /usr/lib64/libc-2.17.so + 7fb74d0000-7fb74f0000 00150000 131072 /usr/lib64/libc-2.17.so + 7fb7520000-7fb7540000 00000000 131072 /usr/lib64/ld-2.17.so + 7fb7540000-7fb7550000 00010000 65536 /usr/lib64/ld-2.17.so + CORE 528 FPREGSET + fpsr: 0x00000000, fpcr: 0x00000000 + v0: 0x00000000000af54b000000000000fe02 + v1: 0x00000000000000000000000000000000 + v2: 0x00000000000000000000000000000000 + v3: 0x00000000000000000000000000000000 + v4: 0x00000000000000000000000000000000 + v5: 0x00000000000000000000000000000000 + v6: 0x00000000000000000000000000000000 + v7: 0x00000000000000000000000000000000 + v8: 0x00000000000000000000000000000000 + v9: 0x00000000000000000000000000000000 + v10: 0x00000000000000000000000000000000 + v11: 0x00000000000000000000000000000000 + v12: 0x00000000000000000000000000000000 + v13: 0x00000000000000000000000000000000 + v14: 0x00000000000000000000000000000000 + v15: 0x00000000000000000000000000000000 + v16: 0x00000000000000000000000000000000 + v17: 0x00000000000000000000000000000000 + v18: 0x00000000000000000000000000000000 + v19: 0x00000000000000000000000000000000 + v20: 0x00000000000000000000000000000000 + v21: 0x00000000000000000000000000000000 + v22: 0x00000000000000000000000000000000 + v23: 0x00000000000000000000000000000000 + v24: 0x00000000000000000000000000000000 + v25: 0x00000000000000000000000000000000 + v26: 0x00000000000000000000000000000000 + v27: 0x00000000000000000000000000000000 + v28: 0x00000000000000000000000000000000 + v29: 0x00000000000000000000000000000000 + v30: 0x00000000000000000000000000000000 + v31: 0x00000000000000000000000000000000 + LINUX 8 ARM_TLS + tls: 0x0000007fb73606f0 + LINUX 264 ARM_HW_BREAK + dbg_info: 0x00000610 + DBGBVR0_EL1: 0x0000000000000000, DBGBCR0_EL1: 0x00000000 + DBGBVR1_EL1: 0x0000000000000000, DBGBCR1_EL1: 0x00000000 + DBGBVR2_EL1: 0x0000000000000000, DBGBCR2_EL1: 0x00000000 + DBGBVR3_EL1: 0x0000000000000000, DBGBCR3_EL1: 0x00000000 + DBGBVR4_EL1: 0x0000000000000000, DBGBCR4_EL1: 0x00000000 + DBGBVR5_EL1: 0x0000000000000000, DBGBCR5_EL1: 0x00000000 + DBGBVR6_EL1: 0x0000000000000000, DBGBCR6_EL1: 0x00000000 + DBGBVR7_EL1: 0x0000000000000000, DBGBCR7_EL1: 0x00000000 + DBGBVR8_EL1: 0x0000000000000000, DBGBCR8_EL1: 0x00000000 + DBGBVR9_EL1: 0x0000000000000000, DBGBCR9_EL1: 0x00000000 + DBGBVR10_EL1: 0x0000000000000000, DBGBCR10_EL1: 0x00000000 + DBGBVR11_EL1: 0x0000000000000000, DBGBCR11_EL1: 0x00000000 + DBGBVR12_EL1: 0x0000000000000000, DBGBCR12_EL1: 0x00000000 + DBGBVR13_EL1: 0x0000000000000000, DBGBCR13_EL1: 0x00000000 + DBGBVR14_EL1: 0x0000000000000000, DBGBCR14_EL1: 0x00000000 + DBGBVR15_EL1: 0x0000000000000000, DBGBCR15_EL1: 0x00000000 + LINUX 264 ARM_HW_WATCH + dbg_info: 0x00000610 + DBGWVR0_EL1: 0x0000000000000000, DBGWCR0_EL1: 0x00000000 + DBGWVR1_EL1: 0x0000000000000000, DBGWCR1_EL1: 0x00000000 + DBGWVR2_EL1: 0x0000000000000000, DBGWCR2_EL1: 0x00000000 + DBGWVR3_EL1: 0x0000000000000000, DBGWCR3_EL1: 0x00000000 + DBGWVR4_EL1: 0x0000000000000000, DBGWCR4_EL1: 0x00000000 + DBGWVR5_EL1: 0x0000000000000000, DBGWCR5_EL1: 0x00000000 + DBGWVR6_EL1: 0x0000000000000000, DBGWCR6_EL1: 0x00000000 + DBGWVR7_EL1: 0x0000000000000000, DBGWCR7_EL1: 0x00000000 + DBGWVR8_EL1: 0x0000000000000000, DBGWCR8_EL1: 0x00000000 + DBGWVR9_EL1: 0x0000000000000000, DBGWCR9_EL1: 0x00000000 + DBGWVR10_EL1: 0x0000000000000000, DBGWCR10_EL1: 0x00000000 + DBGWVR11_EL1: 0x0000000000000000, DBGWCR11_EL1: 0x00000000 + DBGWVR12_EL1: 0x0000000000000000, DBGWCR12_EL1: 0x00000000 + DBGWVR13_EL1: 0x0000000000000000, DBGWCR13_EL1: 0x00000000 + DBGWVR14_EL1: 0x0000000000000000, DBGWCR14_EL1: 0x00000000 + DBGWVR15_EL1: 0x0000000000000000, DBGWCR15_EL1: 0x00000000 +EOF + exit 0 diff --git a/tests/run-strip-reloc.sh b/tests/run-strip-reloc.sh index 221eefbf6..a3245fd88 100755 --- a/tests/run-strip-reloc.sh +++ b/tests/run-strip-reloc.sh @@ -1,5 +1,5 @@ #! /bin/sh -# Copyright (C) 2011 Red Hat, Inc. +# Copyright (C) 2011, 2013 Red Hat, Inc. # This file is part of elfutils. # # This file is free software; you can redistribute it and/or modify @@ -17,7 +17,8 @@ . $srcdir/test-subr.sh -testfiles hello_i386.ko hello_x86_64.ko hello_ppc64.ko hello_s390.ko +testfiles hello_i386.ko hello_x86_64.ko hello_ppc64.ko hello_s390.ko \ + hello_aarch64.ko tempfiles readelf.out readelf.out1 readelf.out2 tempfiles out.stripped1 out.debug1 out.stripped2 out.debug2 @@ -100,6 +101,7 @@ runtest hello_i386.ko 1 runtest hello_x86_64.ko 1 runtest hello_ppc64.ko 1 runtest hello_s390.ko 1 +runtest hello_aarch64.ko 1 # self test, shouldn't impact non-ET_REL files at all. runtest ${abs_top_builddir}/src/strip 0 diff --git a/tests/testfile_aarch64_core.bz2 b/tests/testfile_aarch64_core.bz2 new file mode 100644 index 0000000000000000000000000000000000000000..9d56268843b77dfa5cab57dbeb2746ba881d78e7 GIT binary patch literal 61748 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 literal 0 Hc-jL100001 -- 2.47.2