From: Petr Machata <pmachata@redhat.com>

Date: Thu, 23 Jan 2014 23:50:06 +0000 (+0100)

Subject: Implement aarch64 support

X-Git-Url: http://anonscm.debian.org/gitweb/?p=collab-maint%2Fltrace.git;a=commitdiff_plain;h=912a0f75b3521803fa724a55f0e883c134c7b4e9;hp=0b5457a9e59978bcd2eb5240f54838910365a93c

Implement aarch64 support

- IFUNC support is not implemented, the rest works well.  The only

  other failure is in wide char functions, and that occurs on x86_64

  as well.

---

diff --git a/configure.ac b/configure.ac

index c6e6bf0..0e9a124 100644

--- a/configure.ac

+++ b/configure.ac

@@ -1,6 +1,6 @@

 # -*- Autoconf -*-

 # This file is part of ltrace.

-# Copyright (C) 2010,2012,2013 Petr Machata, Red Hat Inc.

+# Copyright (C) 2010,2012,2013,2014 Petr Machata, Red Hat Inc.

 # Copyright (C) 2010,2011 Joe Damato

 # Copyright (C) 2010 Marc Kleine-Budde

 # Copyright (C) 2010 Zachary T Welch

@@ -399,6 +399,7 @@ AC_CONFIG_FILES([

 	Makefile

 	sysdeps/Makefile

 	sysdeps/linux-gnu/Makefile

+	sysdeps/linux-gnu/aarch64/Makefile

 	sysdeps/linux-gnu/alpha/Makefile

 	sysdeps/linux-gnu/arm/Makefile

 	sysdeps/linux-gnu/cris/Makefile

diff --git a/sysdeps/linux-gnu/Makefile.am b/sysdeps/linux-gnu/Makefile.am

index ecee577..ec26162 100644

--- a/sysdeps/linux-gnu/Makefile.am

+++ b/sysdeps/linux-gnu/Makefile.am

@@ -1,4 +1,5 @@

 # This file is part of ltrace.

+# Copyright (C) 2014 Petr Machata, Red Hat, Inc.

 # Copyright (C) 2010,2012 Marc Kleine-Budde, Pengutronix

 #

 # This program is free software; you can redistribute it and/or

@@ -16,7 +17,8 @@

 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA

 # 02110-1301 USA

-DIST_SUBDIRS = alpha arm cris ia64 m68k metag mips ppc s390 sparc x86

+DIST_SUBDIRS = aarch64 alpha arm cris ia64 m68k metag mips ppc s390	\

+	       sparc x86

 SUBDIRS = \

 	$(HOST_CPU)

diff --git a/sysdeps/linux-gnu/aarch64/Makefile.am b/sysdeps/linux-gnu/aarch64/Makefile.am

new file mode 100644

index 0000000..0af4e6e

--- /dev/null

+++ b/sysdeps/linux-gnu/aarch64/Makefile.am

@@ -0,0 +1,25 @@

+# This file is part of ltrace.

+# Copyright (C) 2014 Petr Machata, Red Hat, Inc.

+#

+# This program is free software; you can redistribute it and/or

+# modify it under the terms of 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.

+#

+# This program 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 a copy of the GNU General Public License

+# along with this program; if not, write to the Free Software

+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA

+# 02110-1301 USA

+

+noinst_LTLIBRARIES = ../libcpu.la

+

+___libcpu_la_SOURCES = fetch.c plt.c regs.c trace.c

+

+noinst_HEADERS = arch.h ptrace.h signalent.h syscallent.h

+

+MAINTAINERCLEANFILES = Makefile.in

diff --git a/sysdeps/linux-gnu/aarch64/arch.h b/sysdeps/linux-gnu/aarch64/arch.h

new file mode 100644

index 0000000..4137613

--- /dev/null

+++ b/sysdeps/linux-gnu/aarch64/arch.h

@@ -0,0 +1,37 @@

+/*

+ * This file is part of ltrace.

+ * Copyright (C) 2014 Petr Machata, Red Hat, Inc.

+ *

+ * This program is free software; you can redistribute it and/or

+ * modify it under the terms of 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.

+ *

+ * This program 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 a copy of the GNU General Public License

+ * along with this program; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA

+ * 02110-1301 USA

+ */

+#ifndef LTRACE_AARCH64_ARCH_H

+#define LTRACE_AARCH64_ARCH_H

+

+/* | 31                 21 | 20       5 | 4       0 | *

+ * | 1 1 0 1 0 1 0 0 0 0 1 |    imm16   | 0 0 0 0 0 | */

+#define BREAKPOINT_VALUE { 0xd4, 0x20, 0, 0 }

+#define BREAKPOINT_LENGTH 4

+#define DECR_PC_AFTER_BREAK 0

+

+#define LT_ELFCLASS	ELFCLASS64

+#define LT_ELF_MACHINE	EM_AARCH64

+

+#define ARCH_HAVE_FETCH_ARG

+#define ARCH_ENDIAN_BIG

+#define ARCH_HAVE_SIZEOF

+#define ARCH_HAVE_ALIGNOF

+

+#endif /* LTRACE_AARCH64_ARCH_H */

diff --git a/sysdeps/linux-gnu/aarch64/fetch.c b/sysdeps/linux-gnu/aarch64/fetch.c

new file mode 100644

index 0000000..8779f03

--- /dev/null

+++ b/sysdeps/linux-gnu/aarch64/fetch.c

@@ -0,0 +1,365 @@

+/*

+ * This file is part of ltrace.

+ * Copyright (C) 2014 Petr Machata, Red Hat, Inc.

+ *

+ * This program is free software; you can redistribute it and/or

+ * modify it under the terms of 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.

+ *

+ * This program 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 a copy of the GNU General Public License

+ * along with this program; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA

+ * 02110-1301 USA

+ */

+

+#include <sys/ptrace.h>

+#include <asm/ptrace.h>

+#include <stdlib.h>

+#include <string.h>

+

+#include "fetch.h"

+#include "proc.h"

+#include "type.h"

+#include "value.h"

+

+int aarch64_read_gregs(struct process *proc, struct user_pt_regs *regs);

+int aarch64_read_fregs(struct process *proc, struct user_fpsimd_state *regs);

+

+

+struct fetch_context

+{

+	struct user_pt_regs gregs;

+	struct user_fpsimd_state fpregs;

+	arch_addr_t nsaa;

+	unsigned ngrn;

+	unsigned nsrn;

+	arch_addr_t x8;

+};

+

+static int

+context_init(struct fetch_context *context, struct process *proc)

+{

+	if (aarch64_read_gregs(proc, &context->gregs) < 0

+	    || aarch64_read_fregs(proc, &context->fpregs) < 0)

+		return -1;

+

+	context->ngrn = 0;

+	context->nsrn = 0;

+	/* XXX double cast */

+	context->nsaa = (arch_addr_t) (uintptr_t) context->gregs.sp;

+	context->x8 = 0;

+

+	return 0;

+}

+

+struct fetch_context *

+arch_fetch_arg_clone(struct process *proc, struct fetch_context *context)

+{

+	struct fetch_context *ret = malloc(sizeof(*ret));

+	if (ret == NULL)

+		return NULL;

+	return memcpy(ret, context, sizeof(*ret));

+}

+

+static void

+fetch_next_gpr(struct fetch_context *context, unsigned char *buf)

+{

+	uint64_t u = context->gregs.regs[context->ngrn++];

+	memcpy(buf, &u, 8);

+}

+

+static int

+fetch_gpr(struct fetch_context *context, struct value *value, size_t sz)

+{

+	if (sz < 8)

+		sz = 8;

+

+	unsigned char *buf = value_reserve(value, sz);

+	if (buf == NULL)

+		return -1;

+

+	size_t i;

+	for (i = 0; i < sz; i += 8)

+		fetch_next_gpr(context, buf + i);

+

+	return 0;

+}

+

+static void

+fetch_next_sse(struct fetch_context *context, unsigned char *buf, size_t sz)

+{

+	__int128 u = context->fpregs.vregs[context->nsrn++];

+	memcpy(buf, &u, sz);

+}

+

+static int

+fetch_sse(struct fetch_context *context, struct value *value, size_t sz)

+{

+	unsigned char *buf = value_reserve(value, sz);

+	if (buf == NULL)

+		return -1;

+

+	fetch_next_sse(context, buf, sz);

+	return 0;

+}

+

+static int

+fetch_hfa(struct fetch_context *context,

+	  struct value *value, struct arg_type_info *hfa_t, size_t count)

+{

+	size_t sz = type_sizeof(value->inferior, hfa_t);

+	unsigned char *buf = value_reserve(value, sz * count);

+	if (buf == NULL)

+		return -1;

+

+	size_t i;

+	for (i = 0; i < count; ++i) {

+		fetch_next_sse(context, buf, sz);

+		buf += sz;

+	}

+	return 0;

+}

+

+static int

+fetch_stack(struct fetch_context *context, struct value *value,

+	    size_t align, size_t sz)

+{

+	if (align < 8)

+		align = 8;

+	size_t amount = ((sz + align - 1) / align) * align;

+

+	/* XXX double casts */

+	uintptr_t sp = (uintptr_t) context->nsaa;

+	sp = ((sp + align - 1) / align) * align;

+

+	value_in_inferior(value, (arch_addr_t) sp);

+

+	sp += amount;

+	context->nsaa = (arch_addr_t) sp;

+

+	return 0;

+}

+

+enum convert_method {

+	CVT_ERR = -1,

+	CVT_NOP = 0,

+	CVT_BYREF,

+};

+

+enum fetch_method {

+	FETCH_NOP,

+	FETCH_STACK,

+	FETCH_GPR,

+	FETCH_SSE,

+	FETCH_HFA,

+};

+

+struct fetch_script {

+	enum convert_method c;

+	enum fetch_method f;

+	size_t sz;

+	struct arg_type_info *hfa_t;

+	size_t count;

+};

+

+static struct fetch_script

+pass_arg(struct fetch_context const *context,

+	 struct process *proc, struct arg_type_info *info)

+{

+	enum fetch_method cvt = CVT_NOP;

+

+	size_t sz = type_sizeof(proc, info);

+	if (sz == (size_t) -1)

+		return (struct fetch_script) { CVT_ERR, FETCH_NOP, sz };

+

+	switch (info->type) {

+	case ARGTYPE_VOID:

+		return (struct fetch_script) { cvt, FETCH_NOP, sz };

+

+	case ARGTYPE_STRUCT:

+	case ARGTYPE_ARRAY:;

+		size_t count;

+		struct arg_type_info *hfa_t = type_get_hfa_type(info, &count);

+		if (hfa_t != NULL && count <= 4) {

+			if (context->nsrn + count <= 8)

+				return (struct fetch_script)

+					{ cvt, FETCH_HFA, sz, hfa_t, count };

+			return (struct fetch_script)

+				{ cvt, FETCH_STACK, sz, hfa_t, count };

+		}

+

+		if (sz <= 16) {

+			size_t count = sz / 8;

+			if (context->ngrn + count <= 8)

+				return (struct fetch_script)

+					{ cvt, FETCH_GPR, sz };

+		}

+

+		cvt = CVT_BYREF;

+		sz = 8;

+		/* Fall through.  */

+

+	case ARGTYPE_POINTER:

+	case ARGTYPE_INT:

+	case ARGTYPE_UINT:

+	case ARGTYPE_LONG:

+	case ARGTYPE_ULONG:

+	case ARGTYPE_CHAR:

+	case ARGTYPE_SHORT:

+	case ARGTYPE_USHORT:

+		if (context->ngrn < 8 && sz <= 8)

+			return (struct fetch_script) { cvt, FETCH_GPR, sz };

+		/* We don't support types wider than 8 bytes as of

+		 * now.  */

+		assert(sz <= 8);

+

+		return (struct fetch_script) { cvt, FETCH_STACK, sz };

+

+	case ARGTYPE_FLOAT:

+	case ARGTYPE_DOUBLE:

+		if (context->nsrn < 8) {

+			/* ltrace doesn't support float128.  */

+			assert(sz <= 8);

+			return (struct fetch_script) { cvt, FETCH_SSE, sz };

+		}

+

+		return (struct fetch_script) { cvt, FETCH_STACK, sz };

+	}

+

+	assert(! "Failed to allocate argument.");

+	abort();

+}

+

+static int

+convert_arg(struct value *value, struct fetch_script how)

+{

+	switch (how.c) {

+	case CVT_NOP:

+		return 0;

+	case CVT_BYREF:

+		return value_pass_by_reference(value);

+	case CVT_ERR:

+		return -1;

+	}

+

+	assert(! "Don't know how to convert argument.");

+	abort();

+}

+

+static int

+fetch_arg(struct fetch_context *context,

+	  struct process *proc, struct arg_type_info *info,

+	  struct value *value, struct fetch_script how)

+{

+	if (convert_arg(value, how) < 0)

+		return -1;

+

+	switch (how.f) {

+	case FETCH_NOP:

+		return 0;

+

+	case FETCH_STACK:

+		if (how.hfa_t != NULL && how.count != 0 && how.count <= 8)

+			context->nsrn = 8;

+		return fetch_stack(context, value,

+				   type_alignof(proc, info), how.sz);

+

+	case FETCH_GPR:

+		return fetch_gpr(context, value, how.sz);

+

+	case FETCH_SSE:

+		return fetch_sse(context, value, how.sz);

+

+	case FETCH_HFA:

+		return fetch_hfa(context, value, how.hfa_t, how.count);

+	}

+

+	assert(! "Don't know how to fetch argument.");

+	abort();

+}

+

+struct fetch_context *

+arch_fetch_arg_init(enum tof type, struct process *proc,

+		    struct arg_type_info *ret_info)

+{

+	struct fetch_context *context = malloc(sizeof *context);

+	if (context == NULL || context_init(context, proc) < 0) {

+	fail:

+		free(context);

+		return NULL;

+	}

+

+	/* There's a provision in ARMv8 parameter passing convention

+	 * for returning types that, if passed as first argument to a

+	 * function, would be passed on stack.  For those types, x8

+	 * contains an address where the return argument should be

+	 * placed.  The callee doesn't need to preserve the value of

+	 * x8, so we need to fetch it now.

+	 *

+	 * To my knowledge, there are currently no types where this

+	 * holds, but the code is here, utterly untested.  */

+

+	struct fetch_script how = pass_arg(context, proc, ret_info);

+	if (how.c == CVT_ERR)

+		goto fail;

+	if (how.c == CVT_NOP && how.f == FETCH_STACK) {

+		/* XXX double cast.  */

+		context->x8 = (arch_addr_t) (uintptr_t) context->gregs.regs[8];

+		/* See the comment above about the assert.  */

+		assert(! "Unexpected: first argument passed on stack.");

+		abort();

+	}

+

+	return context;

+}

+

+int

+arch_fetch_arg_next(struct fetch_context *context, enum tof type,

+		    struct process *proc, struct arg_type_info *info,

+		    struct value *value)

+{

+	return fetch_arg(context, proc, info, value,

+			 pass_arg(context, proc, info));

+}

+

+int

+arch_fetch_retval(struct fetch_context *context, enum tof type,

+		  struct process *proc, struct arg_type_info *info,

+		  struct value *value)

+{

+	if (context->x8 != 0) {

+		value_in_inferior(value, context->x8);

+		return 0;

+	}

+

+	if (context_init(context, proc) < 0)

+		return -1;

+

+	return fetch_arg(context, proc, info, value,

+			 pass_arg(context, proc, info));

+}

+

+void

+arch_fetch_arg_done(struct fetch_context *context)

+{

+	if (context != NULL)

+		free(context);

+}

+

+size_t

+arch_type_sizeof(struct process *proc, struct arg_type_info *arg)

+{

+	return (size_t) -2;

+}

+

+size_t

+arch_type_alignof(struct process *proc, struct arg_type_info *arg)

+{

+	return (size_t) -2;

+}

diff --git a/sysdeps/linux-gnu/aarch64/plt.c b/sysdeps/linux-gnu/aarch64/plt.c

new file mode 100644

index 0000000..29dc4c9

--- /dev/null

+++ b/sysdeps/linux-gnu/aarch64/plt.c

@@ -0,0 +1,38 @@

+/*

+ * This file is part of ltrace.

+ * Copyright (C) 2014 Petr Machata, Red Hat, Inc.

+ *

+ * This program is free software; you can redistribute it and/or

+ * modify it under the terms of 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.

+ *

+ * This program 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 a copy of the GNU General Public License

+ * along with this program; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA

+ * 02110-1301 USA

+ */

+

+#include <gelf.h>

+

+#include "backend.h"

+#include "proc.h"

+#include "library.h"

+#include "ltrace-elf.h"

+

+arch_addr_t

+sym2addr(struct process *proc, struct library_symbol *sym)

+{

+	return sym->enter_addr;

+}

+

+GElf_Addr

+arch_plt_sym_val(struct ltelf *lte, size_t ndx, GElf_Rela *rela)

+{

+	return lte->plt_addr + 32 + ndx * 16;

+}

diff --git a/sysdeps/linux-gnu/aarch64/ptrace.h b/sysdeps/linux-gnu/aarch64/ptrace.h

new file mode 100644

index 0000000..283c314

--- /dev/null

+++ b/sysdeps/linux-gnu/aarch64/ptrace.h

@@ -0,0 +1,22 @@

+/*

+ * This file is part of ltrace.

+ * Copyright (C) 2014 Petr Machata, Red Hat, Inc.

+ *

+ * This program is free software; you can redistribute it and/or

+ * modify it under the terms of 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.

+ *

+ * This program 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 a copy of the GNU General Public License

+ * along with this program; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA

+ * 02110-1301 USA

+ */

+

+#include <sys/ptrace.h>

+#include <asm/ptrace.h>

diff --git a/sysdeps/linux-gnu/aarch64/regs.c b/sysdeps/linux-gnu/aarch64/regs.c

new file mode 100644

index 0000000..06eb72b

--- /dev/null

+++ b/sysdeps/linux-gnu/aarch64/regs.c

@@ -0,0 +1,130 @@

+/*

+ * This file is part of ltrace.

+ * Copyright (C) 2014 Petr Machata, Red Hat, Inc.

+ *

+ * This program is free software; you can redistribute it and/or

+ * modify it under the terms of 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.

+ *

+ * This program 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 a copy of the GNU General Public License

+ * along with this program; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA

+ * 02110-1301 USA

+ */

+

+#include <sys/ptrace.h>

+#include <asm/ptrace.h>

+#include <linux/uio.h>

+#include <assert.h>

+#include <stdlib.h>

+

+#include "backend.h"

+#include "proc.h"

+

+#define PC_OFF (32 * 4)

+

+int

+aarch64_read_gregs(struct process *proc, struct user_pt_regs *regs)

+{

+	*regs = (struct user_pt_regs) {};

+	struct iovec iovec;

+	iovec.iov_base = regs;

+	iovec.iov_len = sizeof *regs;

+	return ptrace(PTRACE_GETREGSET, proc->pid, NT_PRSTATUS, &iovec) < 0

+		? -1 : 0;

+}

+

+int

+aarch64_write_gregs(struct process *proc, struct user_pt_regs *regs)

+{

+	struct iovec iovec;

+	iovec.iov_base = regs;

+	iovec.iov_len = sizeof *regs;

+	return ptrace(PTRACE_SETREGSET, proc->pid, NT_PRSTATUS, &iovec) < 0

+		? -1 : 0;

+}

+

+int

+aarch64_read_fregs(struct process *proc, struct user_fpsimd_state *regs)

+{

+	*regs = (struct user_fpsimd_state) {};

+	struct iovec iovec;

+	iovec.iov_base = regs;

+	iovec.iov_len = sizeof *regs;

+	return ptrace(PTRACE_GETREGSET, proc->pid, NT_FPREGSET, &iovec) < 0

+		? -1 : 0;

+}

+

+arch_addr_t

+get_instruction_pointer(struct process *proc)

+{

+	struct user_pt_regs regs;

+	if (aarch64_read_gregs(proc, &regs) < 0) {

+		fprintf(stderr, "get_instruction_pointer: "

+			"Couldn't read registers of %d.\n", proc->pid);

+		return 0;

+	}

+

+	/* 

+	char buf[128];

+	sprintf(buf, "cat /proc/%d/maps", proc->pid);

+	system(buf);

+	*/

+

+	/* XXX double cast */

+	return (arch_addr_t) (uintptr_t) regs.pc;

+}

+

+void

+set_instruction_pointer(struct process *proc, arch_addr_t addr)

+{

+	struct user_pt_regs regs;

+	if (aarch64_read_gregs(proc, &regs) < 0) {

+		fprintf(stderr, "get_instruction_pointer: "

+			"Couldn't read registers of %d.\n", proc->pid);

+		return;

+	}

+

+	/* XXX double cast */

+	regs.pc = (uint64_t) (uintptr_t) addr;

+

+	if (aarch64_write_gregs(proc, &regs) < 0) {

+		fprintf(stderr, "get_instruction_pointer: "

+			"Couldn't write registers of %d.\n", proc->pid);

+		return;

+	}

+}

+

+arch_addr_t

+get_stack_pointer(struct process *proc)

+{

+	struct user_pt_regs regs;

+	if (aarch64_read_gregs(proc, &regs) < 0) {

+		fprintf(stderr, "get_stack_pointer: "

+			"Couldn't read registers of %d.\n", proc->pid);

+		return 0;

+	}

+

+	/* XXX double cast */

+	return (arch_addr_t) (uintptr_t) regs.sp;

+}

+

+arch_addr_t

+get_return_addr(struct process *proc, arch_addr_t stack_pointer)

+{

+	struct user_pt_regs regs;

+	if (aarch64_read_gregs(proc, &regs) < 0) {

+		fprintf(stderr, "get_return_addr: "

+			"Couldn't read registers of %d.\n", proc->pid);

+		return 0;

+	}

+

+	/* XXX double cast */

+	return (arch_addr_t) (uintptr_t) regs.regs[30];

+}

diff --git a/sysdeps/linux-gnu/aarch64/signalent.h b/sysdeps/linux-gnu/aarch64/signalent.h

new file mode 100644

index 0000000..bf56ebc

--- /dev/null

+++ b/sysdeps/linux-gnu/aarch64/signalent.h

@@ -0,0 +1,52 @@

+/*

+ * This file is part of ltrace.

+ * Copyright (C) 2006 Ian Wienand

+ *

+ * This program is free software; you can redistribute it and/or

+ * modify it under the terms of 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.