[obv] Update m4/ChangeLog for m4/biarch.m4 authorship
by Jan Kratochvil
Hi Mark,
checked-in as obvious.
(1) I did not realize first that m4/biarch.m4 is in fact 99% of Roland's work
from CVSROOT sourceware.org:/cvs/systemtap repo tests/ptrace-tests.
(2) It was checked-in by mistake, it is unused now, it is needed only for the
pending tests/ subdir part. But I left it there as is.
Jan
e31e73969793e5e1f9ee4a9ae2d266f5e6ca435d Mon Sep 17 00:00:00 2001
From: Jan Kratochvil <jan.kratochvil(a)redhat.com>
Date: Fri, 15 Nov 2013 17:10:45 +0100
Subject: [PATCH] Update m4/ChangeLog for m4/biarch.m4 authorship.
---
m4/ChangeLog | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git a/m4/ChangeLog b/m4/ChangeLog
index 98de943..0fc7871 100644
--- a/m4/ChangeLog
+++ b/m4/ChangeLog
@@ -1,4 +1,5 @@
-2013-11-07 Jan Kratochvil <jan.kratochvil(a)redhat.com>
+2013-11-07 Roland McGrath <roland(a)redhat.com>
+ Jan Kratochvil <jan.kratochvil(a)redhat.com>
* biarch.m4: New file.
--
1.8.3.1
10 years, 5 months
[patch 2/4] Code cleanup: Remove const in prototype
by Jan Kratochvil
Hi Mark,
jankratochvil/ynonx86base-attach-firstreg
cv-qualifier in declaration has no effect on callers but the parameter needs
to be modified in function implementation in [patch 3/4]. To keep the code
consistent I have removed it everywhere.
Thanks,
Jan
Code cleanup: Remove const in prototype
libdwfl/
2013-11-10 Jan Kratochvil <jan.kratochvil(a)redhat.com>
Code cleanup: Remove const in prototype
* dwfl_frame_regs.c (dwfl_thread_state_registers): Remove const from
firstreg.
* libdwfl.h (dwfl_thread_state_registers): Likewise.
* linux-pid-attach.c (pid_thread_state_registers_cb): Likewise.
libebl/
2013-11-10 Jan Kratochvil <jan.kratochvil(a)redhat.com>
Code cleanup: Remove const in prototype
* libebl.h (ebl_tid_registers_t): Remove const from firstreg.
Signed-off-by: Jan Kratochvil <jan.kratochvil(a)redhat.com>
--- a/libdwfl/dwfl_frame_regs.c
+++ b/libdwfl/dwfl_frame_regs.c
@@ -29,7 +29,7 @@
#include "libdwflP.h"
bool
-dwfl_thread_state_registers (Dwfl_Thread *thread, const int firstreg,
+dwfl_thread_state_registers (Dwfl_Thread *thread, int firstreg,
unsigned nregs, const Dwarf_Word *regs)
{
Dwfl_Frame *state = thread->unwound;
--- a/libdwfl/libdwfl.h
+++ b/libdwfl/libdwfl.h
@@ -657,7 +657,7 @@ Dwfl_Thread *dwfl_frame_thread (Dwfl_Frame *state)
For every known continuous block of registers <FIRSTREG..FIRSTREG+NREGS)
(inclusive..exclusive) set their content to REGS (array of NREGS items).
Function returns false if any of the registers has invalid number. */
-bool dwfl_thread_state_registers (Dwfl_Thread *thread, const int firstreg,
+bool dwfl_thread_state_registers (Dwfl_Thread *thread, int firstreg,
unsigned nregs, const Dwarf_Word *regs)
__nonnull_attribute__ (1, 4);
--- a/libdwfl/linux-pid-attach.c
+++ b/libdwfl/linux-pid-attach.c
@@ -198,10 +198,8 @@ pid_next_thread (Dwfl *dwfl __attribute__ ((unused)), void *dwfl_arg,
/* Implement the ebl_set_initial_registers_tid setfunc callback. */
static bool
-pid_thread_state_registers_cb (const int firstreg,
- unsigned nregs,
- const Dwarf_Word *regs,
- void *arg)
+pid_thread_state_registers_cb (int firstreg, unsigned nregs,
+ const Dwarf_Word *regs, void *arg)
{
Dwfl_Thread *thread = (Dwfl_Thread *) arg;
return INTUSE(dwfl_thread_state_registers) (thread, firstreg, nregs, regs);
--- a/libebl/libebl.h
+++ b/libebl/libebl.h
@@ -384,10 +384,8 @@ extern int ebl_auxv_info (Ebl *ebl, GElf_Xword a_type,
__nonnull_attribute__ (1, 3, 4);
/* Callback type for ebl_set_initial_registers_tid. */
-typedef bool (ebl_tid_registers_t) (const int firstreg,
- unsigned nregs,
- const Dwarf_Word *regs,
- void *arg)
+typedef bool (ebl_tid_registers_t) (int firstreg, unsigned nregs,
+ const Dwarf_Word *regs, void *arg)
__nonnull_attribute__ (3);
/* Callback to fetch process data from live TID.
10 years, 5 months
[patch 1/4] Fix dwfl_attach_state machine->elf
by Jan Kratochvil
Hi Mark,
jankratochvil/ynonx86base-attach
'int machine' does not work as libebl/eblopenbackend.c contains:
/* Prefer taking the information from the ELF file. */
if (elf == NULL)
{
result->machine = machines[cnt].em;
result->class = machines[cnt].class;
result->data = machines[cnt].data;
}
else
{
result->machine = elf->state.elf32.ehdr->e_machine;
result->class = elf->state.elf32.ehdr->e_ident[EI_CLASS];
result->data = elf->state.elf32.ehdr->e_ident[EI_DATA];
}
+
{ "s390", "ebl_s390", "s390", 4, EM_S390, 0, 0 },
^=class
This means that without Elf * one cannot get eh->class properly set in
s390_init() (for 32-bit s390 vs. 64-bit s390x).
The second choice would be to somehow change libebl/eblopenbackend.c...
This change is visible only on the later s390 support [patch 4/4].
Thanks,
Jan
Fix dwfl_attach_state machine->elf
libdwfl/
2013-11-10 Jan Kratochvil <jan.kratochvil(a)redhat.com>
Fix dwfl_attach_state machine->elf.
* dwfl_frame.c (dwfl_attach_state): Change parameter machine to elf.
Call ebl_openbackend instead of ebl_openbackend_machine.
* libdwfl.h (dwfl_attach_state): Change parameter machine to elf.
Update the function description.
* linux-core-attach.c (__libdwfl_attach_state_for_core): Pass CORE to
dwfl_attach_state.
* linux-pid-attach.c (__libdwfl_attach_state_for_pid): Pass NULL to
dwfl_attach_state.
tests/
2013-11-10 Jan Kratochvil <jan.kratochvil(a)redhat.com>
Fix dwfl_attach_state machine->elf.
* backtrace-data.c (main): Pass NULL to dwfl_attach_state.
Signed-off-by: Jan Kratochvil <jan.kratochvil(a)redhat.com>
--- a/libdwfl/dwfl_frame.c
+++ b/libdwfl/dwfl_frame.c
@@ -131,7 +131,7 @@ process_alloc (Dwfl *dwfl)
}
bool
-dwfl_attach_state (Dwfl *dwfl, int machine, pid_t pid,
+dwfl_attach_state (Dwfl *dwfl, Elf *elf, pid_t pid,
const Dwfl_Thread_Callbacks *thread_callbacks, void *arg)
{
if (thread_callbacks == NULL || thread_callbacks->next_thread == NULL
@@ -147,9 +147,9 @@ dwfl_attach_state (Dwfl *dwfl, int machine, pid_t pid,
}
Ebl *ebl;
bool ebl_close;
- if (machine != EM_NONE)
+ if (elf != NULL)
{
- ebl = ebl_openbackend_machine (machine);
+ ebl = ebl_openbackend (elf);
ebl_close = true;
}
else
--- a/libdwfl/libdwfl.h
+++ b/libdwfl/libdwfl.h
@@ -625,13 +625,13 @@ typedef struct
} Dwfl_Thread_Callbacks;
/* PID is the process id associated with the DWFL state. Architecture of DWFL
- modules is specified by MACHINE. Use EM_NONE to detect architecture from
- DWFL. If EBL is NULL the function will detect it from arbitrary Dwfl_Module
- of DWFL. DWFL_ARG is the callback backend state. DWFL_ARG will be provided
- to the callbacks. *THREAD_CALLBACKS function pointers must remain valid
- during lifetime of DWFL. Function returns true on success,
- false otherwise. */
-bool dwfl_attach_state (Dwfl *dwfl, int machine, pid_t pid,
+ modules is specified by ELF, ELF must remain valid during DWFL lifetime.
+ Use NULL ELF to detect architecture from DWFL, the function will then detect
+ it from arbitrary Dwfl_Module of DWFL. DWFL_ARG is the callback backend
+ state. DWFL_ARG will be provided to the callbacks. *THREAD_CALLBACKS
+ function pointers must remain valid during lifetime of DWFL. Function
+ returns true on success, false otherwise. */
+bool dwfl_attach_state (Dwfl *dwfl, Elf *elf, pid_t pid,
const Dwfl_Thread_Callbacks *thread_callbacks,
void *dwfl_arg)
__nonnull_attribute__ (1, 4);
--- a/libdwfl/linux-core-attach.c
+++ b/libdwfl/linux-core-attach.c
@@ -369,8 +369,8 @@ __libdwfl_attach_state_for_core (Dwfl *dwfl, Elf *core)
core_arg->note_data = note_data;
core_arg->thread_note_offset = 0;
core_arg->ebl = ebl;
- if (! INTUSE(dwfl_attach_state) (dwfl, ebl_get_elfmachine (ebl), pid,
- &core_thread_callbacks, core_arg))
+ if (! INTUSE(dwfl_attach_state) (dwfl, core, pid, &core_thread_callbacks,
+ core_arg))
{
free (core_arg);
ebl_closebackend (ebl);
--- a/libdwfl/linux-pid-attach.c
+++ b/libdwfl/linux-pid-attach.c
@@ -271,7 +271,7 @@ __libdwfl_attach_state_for_pid (Dwfl *dwfl, pid_t pid)
}
pid_arg->dir = dir;
pid_arg->tid_attached = 0;
- if (! INTUSE(dwfl_attach_state) (dwfl, EM_NONE, pid, &pid_thread_callbacks,
+ if (! INTUSE(dwfl_attach_state) (dwfl, NULL, pid, &pid_thread_callbacks,
pid_arg))
{
closedir (dir);
--- a/tests/backtrace-data.c
+++ b/tests/backtrace-data.c
@@ -287,7 +287,7 @@ main (int argc __attribute__ ((unused)), char **argv __attribute__ ((unused)))
assert (l == 0);
report_module (dwfl, child, user_regs.rip);
- bool ok = dwfl_attach_state (dwfl, EM_NONE, child, &callbacks, NULL);
+ bool ok = dwfl_attach_state (dwfl, NULL, child, &callbacks, NULL);
assert (ok);
/* Multiple threads are not handled here. */
10 years, 5 months
[PATCH 2/2] Support AArch64 architecture
by Petr Machata
Signed-off-by: Petr Machata <pmachata(a)redhat.com>
---
backends/Makefile.am | 17 +-
backends/aarch64_corenote.c | 162 ++++++++++++++
backends/aarch64_init.c | 61 ++++++
backends/aarch64_regs.c | 101 +++++++++
backends/aarch64_reloc.def | 157 ++++++++++++++
backends/aarch64_retval.c | 394 +++++++++++++++++++++++++++++++++++
backends/aarch64_symbol.c | 56 +++++
libebl/eblopenbackend.c | 3 +-
src/elflint.c | 4 +-
tests/Makefile.am | 3 +-
tests/run-allregs.sh | 72 +++++++-
tests/run-readelf-mixed-corenote.sh | 140 +++++++++++++
tests/testfile_aarch64_core.bz2 | Bin 0 -> 61748 bytes
13 files changed, 1160 insertions(+), 10 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/testfile_aarch64_core.bz2
diff --git a/backends/Makefile.am b/backends/Makefile.am
index 557ed87..d752353 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)
@@ -79,6 +80,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 0000000..8f5b9d5
--- /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 <http://www.gnu.org/licenses/>. */
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <elf.h>
+#include <inttypes.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <sys/time.h>
+
+#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 0000000..749af2a
--- /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 <http://www.gnu.org/licenses/>. */
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#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 0000000..d3e0223
--- /dev/null
+++ b/backends/aarch64_regs.c
@@ -0,0 +1,101 @@
+/* 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 <http://www.gnu.org/licenses/>. */
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <stdio.h>
+#include <string.h>
+#include <dwarf.h>
+
+#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)
+ s = -1;
+ return s;
+ }
+
+ ssize_t
+ reserved (void)
+ {
+ return regtype (NULL, DW_ATE_void, "", 0);
+ }
+
+ *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 reserved ();
+
+ case 33:
+ return regtype ("integer", DW_ATE_address, "elr", 0);
+
+ case 34 ... 63:
+ return reserved ();
+
+ 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 reserved ();
+
+ default:
+ return -1;
+ }
+}
diff --git a/backends/aarch64_reloc.def b/backends/aarch64_reloc.def
new file mode 100644
index 0000000..f633157
--- /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 <http://www.gnu.org/licenses/>. */
+
+/* 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 0000000..6498658
--- /dev/null
+++ b/backends/aarch64_retval.c
@@ -0,0 +1,394 @@
+/* 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 <http://www.gnu.org/licenses/>. */
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <stdio.h>
+#include <inttypes.h>
+
+#include <assert.h>
+#include <dwarf.h>
+
+#define BACKEND aarch64_
+#include "libebl_CPU.h"
+
+static int
+peel_type (Dwarf_Die **typediep, Dwarf_Attribute **attrp)
+{
+ int tag = DWARF_TAG_OR_RETURN (*typediep);
+ /* Follow typedefs and qualifiers to get to the actual type. */
+ 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;
+}
+
+static int
+get_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 peel_type (&result, &attr);
+}
+
+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 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 type_die;
+ int tag = get_die_type (membdie, &type_die);
+ switch (tag)
+ {
+ case DW_TAG_base_type:;
+ Dwarf_Word encoding;
+ Dwarf_Attribute attr_mem;
+ if (dwarf_attr_integrate (&type_die, 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_formudata (dwarf_attr_integrate (&type_die, DW_AT_byte_size,
+ &attr_mem), 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 (&type_die, tag, sizep, countp);
+ }
+
+ return 1;
+}
+
+/* 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)
+{
+ 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 1;
+ }
+
+ /* 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;
+ }
+
+ 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 = get_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)
+ {
+ Dwarf_Attribute attr_mem;
+ if (dwarf_formudata (dwarf_attr_integrate (&typedie, DW_AT_byte_size,
+ &attr_mem), &size) != 0)
+ {
+ if (tag == DW_TAG_pointer_type || tag == DW_TAG_ptr_to_member_type)
+ size = 8;
+ else
+ return -1;
+ }
+
+ 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 0000000..b0f3377
--- /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 <http://www.gnu.org/licenses/>. */
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <elf.h>
+#include <stddef.h>
+
+#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/libebl/eblopenbackend.c b/libebl/eblopenbackend.c
index ed0c0ff..c19ae1b 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/elflint.c b/src/elflint.c
index acd458b..e42072b 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 <drepper(a)redhat.com>, 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/Makefile.am b/tests/Makefile.am
index 0024395..f018131 100644
--- a/tests/Makefile.am
+++ b/tests/Makefile.am
@@ -212,7 +212,8 @@ 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
if USE_VALGRIND
valgrind_cmd='valgrind -q --trace-children=yes --error-exitcode=1 --run-libc-freeres=no'
diff --git a/tests/run-allregs.sh b/tests/run-allregs.sh
index 885a1d1..e4a40ce 100755
--- a/tests/run-allregs.sh
+++ b/tests/run-allregs.sh
@@ -1,5 +1,5 @@
#! /bin/sh
-# Copyright (C) 2005, 2006, 2007, 2012 Red Hat, Inc.
+# Copyright (C) 2005, 2006, 2007, 2012, 2013 Red Hat, Inc.
# This file is part of elfutils.
#
# This file is free software; you can redistribute it and/or modify
@@ -2724,4 +2724,74 @@ VFP registers:
287: d31 (d31), float 64 bits
EOF
+regs_test testfile_aarch64_core <<\EOF
+integer registers:
+ 0: x0 (x0), signed 64 bits
+ 1: x1 (x1), signed 64 bits
+ 2: x2 (x2), signed 64 bits
+ 3: x3 (x3), signed 64 bits
+ 4: x4 (x4), signed 64 bits
+ 5: x5 (x5), signed 64 bits
+ 6: x6 (x6), signed 64 bits
+ 7: x7 (x7), signed 64 bits
+ 8: x8 (x8), signed 64 bits
+ 9: x9 (x9), signed 64 bits
+ 10: x10 (x10), signed 64 bits
+ 11: x11 (x11), signed 64 bits
+ 12: x12 (x12), signed 64 bits
+ 13: x13 (x13), signed 64 bits
+ 14: x14 (x14), signed 64 bits
+ 15: x15 (x15), signed 64 bits
+ 16: x16 (x16), signed 64 bits
+ 17: x17 (x17), signed 64 bits
+ 18: x18 (x18), signed 64 bits
+ 19: x19 (x19), signed 64 bits
+ 20: x20 (x20), signed 64 bits
+ 21: x21 (x21), signed 64 bits
+ 22: x22 (x22), signed 64 bits
+ 23: x23 (x23), signed 64 bits
+ 24: x24 (x24), signed 64 bits
+ 25: x25 (x25), signed 64 bits
+ 26: x26 (x26), signed 64 bits
+ 27: x27 (x27), signed 64 bits
+ 28: x28 (x28), signed 64 bits
+ 29: x29 (x29), signed 64 bits
+ 30: x30 (x30), signed 64 bits
+ 31: sp (sp), address 64 bits
+ 33: elr (elr), address 64 bits
+FP/SIMD registers:
+ 64: v0 (v0), unsigned 128 bits
+ 65: v1 (v1), unsigned 128 bits
+ 66: v2 (v2), unsigned 128 bits
+ 67: v3 (v3), unsigned 128 bits
+ 68: v4 (v4), unsigned 128 bits
+ 69: v5 (v5), unsigned 128 bits
+ 70: v6 (v6), unsigned 128 bits
+ 71: v7 (v7), unsigned 128 bits
+ 72: v8 (v8), unsigned 128 bits
+ 73: v9 (v9), unsigned 128 bits
+ 74: v10 (v10), unsigned 128 bits
+ 75: v11 (v11), unsigned 128 bits
+ 76: v12 (v12), unsigned 128 bits
+ 77: v13 (v13), unsigned 128 bits
+ 78: v14 (v14), unsigned 128 bits
+ 79: v15 (v15), unsigned 128 bits
+ 80: v16 (v16), unsigned 128 bits
+ 81: v17 (v17), unsigned 128 bits
+ 82: v18 (v18), unsigned 128 bits
+ 83: v19 (v19), unsigned 128 bits
+ 84: v20 (v20), unsigned 128 bits
+ 85: v21 (v21), unsigned 128 bits
+ 86: v22 (v22), unsigned 128 bits
+ 87: v23 (v23), unsigned 128 bits
+ 88: v24 (v24), unsigned 128 bits
+ 89: v25 (v25), unsigned 128 bits
+ 90: v26 (v26), unsigned 128 bits
+ 91: v27 (v27), unsigned 128 bits
+ 92: v28 (v28), unsigned 128 bits
+ 93: v29 (v29), unsigned 128 bits
+ 94: v30 (v30), unsigned 128 bits
+ 95: v31 (v31), unsigned 128 bits
+EOF
+
exit 0
diff --git a/tests/run-readelf-mixed-corenote.sh b/tests/run-readelf-mixed-corenote.sh
index 9a43809..c176e28 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/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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�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
literal 0
HcmV?d00001
--
1.7.6.5
10 years, 5 months
[PATCH 0/2] Support AArch64
by Petr Machata
Hi there,
The first patch has been reviewed back in October and adds a possibility
to hide certain core note fields.
The second patch is the meat of the AArch64 backend support. This
passes all tests on x86_64, and almost all tests in AArch64 simulator.
The single failing test is run-elflint-self.sh:
section [36] '.symtab': _GLOBAL_OFFSET_TABLE_ symbol value 0x22fb8 does not match .got.plt section address 0x22fe8
*** failure in /root/elfutils/build/src/elflint --quiet --gnu-ld /root/elfutils/build/libelf/libelf.so
[... more of the same ...]
I tracked this down to a problem in binutils, which has actually been
fixed already (the upcoming binutils release should contain this fix):
http://cygwin.com/ml/binutils/2013-07/msg00013.html
So the failure should disappear eventually with binutils rebase.
Please review.
Thanks,
PM
Petr Machata (2):
Support new 'h' core note item format for hidden fields
Support AArch64 architecture
backends/Makefile.am | 17 +-
backends/aarch64_corenote.c | 162 ++++++++++++++
backends/aarch64_init.c | 61 ++++++
backends/aarch64_regs.c | 101 +++++++++
backends/aarch64_reloc.def | 157 ++++++++++++++
backends/aarch64_retval.c | 394 +++++++++++++++++++++++++++++++++++
backends/aarch64_symbol.c | 56 +++++
libebl/eblopenbackend.c | 3 +-
src/ChangeLog | 5 +
src/elflint.c | 4 +-
src/readelf.c | 3 +
tests/Makefile.am | 3 +-
tests/run-allregs.sh | 72 +++++++-
tests/run-readelf-mixed-corenote.sh | 140 +++++++++++++
tests/testfile_aarch64_core.bz2 | Bin 0 -> 61748 bytes
15 files changed, 1168 insertions(+), 10 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/testfile_aarch64_core.bz2
--
1.7.6.5
10 years, 5 months
[patch 3/4] Provide elf_scnfindvma
by Jan Kratochvil
Hi Mark,
jankratochvil/xauxfile-filep-scnfindvma
obsoletes:
[patch 2/3] ppc64 .opd: Provide elf_scnfindvma
https://lists.fedorahosted.org/pipermail/elfutils-devel/2012-December/002...
it is just a code refactorization, no code change happens.
elf_scnfindvma() will get used in [patch 4/4].
Thanks,
Jan
commit 311207bda9a23a6216b30337baca8bf79a696265
Author: Jan Kratochvil <jan.kratochvil(a)redhat.com>
Date: Mon Nov 4 18:23:49 2013 +0100
Provide elf_scnfindvma
libdwfl/
2013-11-06 Jan Kratochvil <jan.kratochvil(a)redhat.com>
Provide elf_scnfindvma.
* dwfl_module_addrsym.c (dwfl_module_addrsym) (same_section): Call
elf_scnfindvma where is the code from here moved out.
libelf/
2013-11-06 Jan Kratochvil <jan.kratochvil(a)redhat.com>
Provide elf_scnfindvma.
* Makefile.am (libelf_a_SOURCES): Add elf_scnfindvma.c.
* elf_scnfindvma.c: New file.
* libelf.h (elf_scnfindvma): New declaration.
* libelf.map (ELFUTILS_1.156): New with elf_scnfindvma.
Signed-off-by: Jan Kratochvil <jan.kratochvil(a)redhat.com>
diff --git a/libdwfl/dwfl_module_addrsym.c b/libdwfl/dwfl_module_addrsym.c
index d9eb0a2..2926726 100644
--- a/libdwfl/dwfl_module_addrsym.c
+++ b/libdwfl/dwfl_module_addrsym.c
@@ -53,21 +53,9 @@ dwfl_module_addrsym (Dwfl_Module *mod, GElf_Addr addr,
if (addr_shndx == SHN_UNDEF || addr_symfile != symfile)
{
GElf_Addr mod_addr = dwfl_deadjust_st_value (mod, symfile, addr);
- Elf_Scn *scn = NULL;
- addr_shndx = SHN_ABS;
+ Elf_Scn *scn = elf_scnfindvma (symfile->elf, mod_addr);
+ addr_shndx = scn == NULL ? SHN_ABS : elf_ndxscn (scn);
addr_symfile = symfile;
- while ((scn = elf_nextscn (symfile->elf, scn)) != NULL)
- {
- GElf_Shdr shdr_mem;
- GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
- if (likely (shdr != NULL)
- && mod_addr >= shdr->sh_addr
- && mod_addr < shdr->sh_addr + shdr->sh_size)
- {
- addr_shndx = elf_ndxscn (scn);
- break;
- }
- }
}
return shndx == addr_shndx && addr_symfile == symfile;
diff --git a/libelf/Makefile.am b/libelf/Makefile.am
index 5903ea8..4b83e23 100644
--- a/libelf/Makefile.am
+++ b/libelf/Makefile.am
@@ -90,7 +90,7 @@ libelf_a_SOURCES = elf_version.c elf_hash.c elf_error.c elf_fill.c \
elf32_offscn.c elf64_offscn.c gelf_offscn.c \
elf_getaroff.c \
elf_gnu_hash.c \
- elf_scnshndx.c
+ elf_scnshndx.c elf_scnfindvma.c
if !MUDFLAP
libelf_pic_a_SOURCES =
diff --git a/libelf/elf_scnfindvma.c b/libelf/elf_scnfindvma.c
new file mode 100644
index 0000000..04fd451
--- /dev/null
+++ b/libelf/elf_scnfindvma.c
@@ -0,0 +1,52 @@
+/* Get section containing VMA address. Return NULL otherwise.
+ Copyright (C) 2013 Red Hat, Inc.
+ This file is part of elfutils.
+ Contributed by Ulrich Drepper <drepper(a)redhat.com>, 1998.
+
+ 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 <http://www.gnu.org/licenses/>. */
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include "libelfP.h"
+
+
+Elf_Scn *
+elf_scnfindvma (Elf *__elf, GElf_Addr __vma)
+{
+ Elf_Scn *scn = NULL;
+ while ((scn = elf_nextscn (__elf, scn)) != NULL)
+ {
+ GElf_Shdr shdr_mem;
+ GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
+ if (likely (shdr != NULL)
+ && __vma >= shdr->sh_addr
+ && __vma < shdr->sh_addr + shdr->sh_size)
+ break;
+ }
+ return scn;
+}
+INTDEF(elf_scnfindvma)
diff --git a/libelf/libelf.h b/libelf/libelf.h
index 5a2b3af..1dd5d2f 100644
--- a/libelf/libelf.h
+++ b/libelf/libelf.h
@@ -219,6 +219,11 @@ extern Elf64_Phdr *elf64_newphdr (Elf *__elf, size_t __cnt);
/* Get section at INDEX. */
extern Elf_Scn *elf_getscn (Elf *__elf, size_t __index);
+/* Get section containing VMA address. Return NULL otherwise.
+ GElf_Addr type cannot be used here for __vma due to include
+ interdependencies. */
+extern Elf_Scn *elf_scnfindvma (Elf *__elf, Elf64_Addr __vma);
+
/* Get section at OFFSET. */
extern Elf_Scn *elf32_offscn (Elf *__elf, Elf32_Off __offset);
/* Similar bug this time the binary calls is ELFCLASS64. */
diff --git a/libelf/libelf.map b/libelf/libelf.map
index de6d912..199bcfb 100644
--- a/libelf/libelf.map
+++ b/libelf/libelf.map
@@ -138,3 +138,8 @@ ELFUTILS_1.6 {
global:
elf_getphdrnum;
} ELFUTILS_1.5;
+
+ELFUTILS_1.158 {
+ global:
+ elf_scnfindvma;
+} ELFUTILS_1.6;
10 years, 5 months
[patch 1/4] Fix dwfl_module_addrsym for minidebuginfo
by Jan Kratochvil
Hi Mark,
jankratochvil/xauxfile
the existing condition is clearly wrong:
((size_t) i < mod->syments ? mod->symfile : &mod->aux_sym)
Additionally same_section() cannot compare section number from file X with
section number from file Y, it is moreover done just for caching/performance
reasons. My fix there is performance-suboptimal but still only twice as slow
as it could be, I think.
The existing code worked due to a luck. This fix does not have a new testcase
but the later testcase for ppc64 .opd FAILs without this fix so it gets tested
somehow.
The added function i_to_symfile() is deleted in the next patch so its content
does not matter much I think.
Thanks,
Jan
commit 7a58010a1862eaa3f7292b387347ecae6178243a
Author: Jan Kratochvil <jan.kratochvil(a)redhat.com>
Date: Wed Nov 6 20:23:44 2013 +0100
Fix dwfl_module_addrsym for minidebuginfo
libdwfl/
2013-11-06 Jan Kratochvil <jan.kratochvil(a)redhat.com>
Fix dwfl_module_addrsym for minidebuginfo.
* dwfl_module_addrsym.c (dwfl_module_addrsym): New variable
addr_symfile.
(dwfl_module_addrsym) (same_section): Use it.
(dwfl_module_addrsym) (i_to_symfile): New function.
(dwfl_module_addrsym) (search_table): Use it.
Signed-off-by: Jan Kratochvil <jan.kratochvil(a)redhat.com>
diff --git a/libdwfl/dwfl_module_addrsym.c b/libdwfl/dwfl_module_addrsym.c
index 732b698..3d19943 100644
--- a/libdwfl/dwfl_module_addrsym.c
+++ b/libdwfl/dwfl_module_addrsym.c
@@ -41,6 +41,7 @@ dwfl_module_addrsym (Dwfl_Module *mod, GElf_Addr addr,
/* Return true iff we consider ADDR to lie in the same section as SYM. */
GElf_Word addr_shndx = SHN_UNDEF;
+ struct dwfl_file *addr_symfile = NULL;
inline bool same_section (const GElf_Sym *sym, struct dwfl_file *symfile,
GElf_Word shndx)
{
@@ -49,11 +50,12 @@ dwfl_module_addrsym (Dwfl_Module *mod, GElf_Addr addr,
return sym->st_value == addr;
/* Figure out what section ADDR lies in. */
- if (addr_shndx == SHN_UNDEF)
+ if (addr_shndx == SHN_UNDEF || addr_symfile != symfile)
{
GElf_Addr mod_addr = dwfl_deadjust_st_value (mod, symfile, addr);
Elf_Scn *scn = NULL;
addr_shndx = SHN_ABS;
+ addr_symfile = symfile;
while ((scn = elf_nextscn (symfile->elf, scn)) != NULL)
{
GElf_Shdr shdr_mem;
@@ -68,7 +70,7 @@ dwfl_module_addrsym (Dwfl_Module *mod, GElf_Addr addr,
}
}
- return shndx == addr_shndx;
+ return shndx == addr_shndx && addr_symfile == symfile;
}
/* Keep track of the closest symbol we have seen so far.
@@ -84,6 +86,20 @@ dwfl_module_addrsym (Dwfl_Module *mod, GElf_Addr addr,
/* Keep track of the lowest address a relevant sizeless symbol could have. */
GElf_Addr min_label = 0;
+ inline struct dwfl_file *i_to_symfile (int ndx)
+ {
+ int skip_aux_zero = (mod->syments > 0 && mod->aux_syments > 0) ? 1 : 0;
+ if (ndx < mod->first_global)
+ return mod->symfile; // main symbol table (locals).
+ else if (ndx < mod->first_global + mod->aux_first_global - skip_aux_zero)
+ return &mod->aux_sym; // aux symbol table (locals).
+ else if ((size_t) ndx
+ < mod->syments + mod->aux_first_global - skip_aux_zero)
+ return mod->symfile; // main symbol table (globals).
+ else
+ return &mod->aux_sym; // aux symbol table (globals).
+ }
+
/* Look through the symbol table for a matching symbol. */
inline void search_table (int start, int end)
{
@@ -136,11 +152,7 @@ dwfl_module_addrsym (Dwfl_Module *mod, GElf_Addr addr,
}
else if (closest_name == NULL
&& sym.st_value >= min_label
- && same_section (&sym,
- ((size_t) i < mod->syments
- ? mod->symfile
- : &mod->aux_sym),
- shndx))
+ && same_section (&sym, i_to_symfile (i), shndx))
{
/* Handwritten assembly symbols sometimes have no
st_size. If no symbol with proper size includes
10 years, 5 months
elflint test on aarch64 [Was: Regarding systemtap support for AArch64]
by Petr Machata
William Cohen <wcohen(a)redhat.com> writes:
> As a sanity check I ran a "make -s check" on the locally built aarch64
> elfutils to see if there were any issues with it.
>
> FAIL: run-elflint-self.sh
elflint needs to know that EM_AARCH64 is a valid value for e_machine
field of ELF header. With that in, it still fails, becasue
_GLOBAL_OFFSET_TABLE_ points to .got instead of .got.plt. That was
fixed by the following commit to binutils:
http://cygwin.com/ml/binutils/2013-07/msg00013.html
I'll see about updating that to a more recent version in Fedora images.
There is one more failure, run-native-test.sh, I'll fix that next.
Thanks,
PM
10 years, 5 months
[PATCH] stack: Add basic argp version and bug definitions.
by Mark Wielaard
Signed-off-by: Mark Wielaard <mjw(a)redhat.com>
---
src/ChangeLog | 6 ++++++
src/stack.c | 15 +++++++++++++++
2 files changed, 21 insertions(+)
diff --git a/src/ChangeLog b/src/ChangeLog
index 94bc27a..df5297e 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,9 @@
+2013-11-10 Mark Wielaard <mjw(a)redhat.com>
+
+ * stack.c: Use ARGP_PROGRAM_VERSION_HOOK_DEF and
+ ARGP_PROGRAM_BUG_ADDRESS_DEF.
+ (print_version): New function.
+
2013-11-09 Mark Wielaard <mjw(a)redhat.com>
* arlib.c (arlib_init): Call snprintf before using the result
diff --git a/src/stack.c b/src/stack.c
index 948325d..f428ed0 100644
--- a/src/stack.c
+++ b/src/stack.c
@@ -27,6 +27,15 @@
#include <fcntl.h>
#include ELFUTILS_HEADER(dwfl)
+#include <system.h>
+
+/* Name and version of program. */
+static void print_version (FILE *stream, struct argp_state *state);
+ARGP_PROGRAM_VERSION_HOOK_DEF = print_version;
+
+/* Bug report address. */
+ARGP_PROGRAM_BUG_ADDRESS_DEF = PACKAGE_BUGREPORT;
+
static bool verbose = false;
static int
@@ -92,6 +101,12 @@ thread_callback (Dwfl_Thread *thread, void *thread_arg __attribute__ ((unused)))
return DWARF_CB_OK;
}
+static void
+print_version (FILE *stream, struct argp_state *state __attribute__ ((unused)))
+{
+ fprintf (stream, "stack (%s) %s\n", PACKAGE_NAME, PACKAGE_VERSION);
+}
+
static error_t
parse_opt (int key, char *arg __attribute__ ((unused)),
struct argp_state *state)
--
1.8.3.1
10 years, 5 months
[PATCH] libelf: Only memcpy ehdr back when not already directly mmapped.
by Mark Wielaard
When the elf file is mmapped ehdr can still point to ehdr_mem if the
address is unaligned. In such cases we do need to memcpy the ehdr back
to the file. We shouldn't when ehdr already comes directly from the mmapped
file, because that would cause an memcpy call with overlapping addresses
(ehdr being copied directly over itself).
Signed-off-by: Mark Wielaard <mjw(a)redhat.com>
---
libelf/ChangeLog | 5 +++++
libelf/elf32_updatefile.c | 2 +-
2 files changed, 6 insertions(+), 1 deletions(-)
diff --git a/libelf/ChangeLog b/libelf/ChangeLog
index a996ccf..148c945 100644
--- a/libelf/ChangeLog
+++ b/libelf/ChangeLog
@@ -1,3 +1,8 @@
+2013-11-08 Mark Wielaard <mjw(a)redhat.com>
+
+ * elf32_updatefile.c (elfXX_updatemmap): Only memcpy ehdr when not
+ already directly mmapped.
+
2013-11-05 Mark Wielaard <mjw(a)redhat.com>
* elf32_updatefile.c (elfXX_updatefile): Copy all section headers
diff --git a/libelf/elf32_updatefile.c b/libelf/elf32_updatefile.c
index c4af9c0..b39e284 100644
--- a/libelf/elf32_updatefile.c
+++ b/libelf/elf32_updatefile.c
@@ -133,7 +133,7 @@ __elfw2(LIBELFBITS,updatemmap) (Elf *elf, int change_bo, size_t shnum)
(*fctp) ((char *) elf->map_address + elf->start_offset, ehdr,
sizeof (ElfW2(LIBELFBITS,Ehdr)), 1);
}
- else
+ else if (elf->map_address + elf->start_offset != ehdr)
memcpy (elf->map_address + elf->start_offset, ehdr,
sizeof (ElfW2(LIBELFBITS,Ehdr)));
--
1.7.1
10 years, 5 months