diff --git a/Makefile.am b/Makefile.am

index c3356de..141ff85 100644

--- a/Makefile.am

+++ b/Makefile.am

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

 # This file is part of ltrace.

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

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

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

 # Copyright (C) 2010 Zachary T Welch, CodeSourcery

 #

@@ -33,6 +33,7 @@ noinst_LTLIBRARIES = \

 	libltrace.la

 libltrace_la_SOURCES = \

+	bits.c \

 	breakpoints.c \

 	debug.c \

 	demangle.c \

@@ -83,6 +84,7 @@ ltrace_LDADD = \

 noinst_HEADERS = \

+	bits.h \

 	backend.h \

 	breakpoint.h \

 	common.h \

diff --git a/README b/README

index 3db5bc8..95871d1 100644

--- a/README

+++ b/README

@@ -24,6 +24,8 @@ The following targets are currently (at least somewhat) supported.

 Some of them may be more or less broken in reality, it is not feasible

 to test each release comprehensively on each target.

+	armv6l-*-linux-gnueabi

+	armv7l-*-linux-gnueabihf

 	i[4567]86-*-linux-gnu

 	ia64-*-linux-gnu

 	m68k-*-linux-gnu

@@ -41,11 +43,6 @@ current status is unknown:

 	sparc64*-*-linux-gnu

 	alpha*-*-linux-gnu

-Support of the following systems is known to be broken and requires

-fixing:

-

-	arm-*-linux-gnueabi

-

 Bug Reports

 -----------

@@ -83,7 +80,7 @@ quick one-liner), it is advisable to send an e-mail beforehand.

 -------------------------------------------------------------------------------

-Copyright (C) 2012 Petr Machata <pmachata@redhat.com>

+Copyright (C) 2012,2013 Petr Machata <pmachata@redhat.com>

 Copyright (C) 1997-2009 Juan Cespedes <cespedes@debian.org>

 This file is part of ltrace.

diff --git a/backend.h b/backend.h

index cfac65e..a9de3b4 100644

--- a/backend.h

+++ b/backend.h

@@ -107,10 +107,6 @@ void *get_stack_pointer(struct process *proc);

  * function returns.  */

 void *get_return_addr(struct process *proc, void *stack_pointer);

-/* Adjust PROC so that when the current function returns, it returns

- * to ADDR.  */

-void set_return_addr(struct process *proc, void *addr);

-

 /* Enable breakpoint SBP in process PROC.  */

 void enable_breakpoint(struct process *proc, struct breakpoint *sbp);

diff --git a/bits.c b/bits.c

new file mode 100644

index 0000000..bde2e71

--- /dev/null

+++ b/bits.c

@@ -0,0 +1,34 @@

+/*

+ * This file is part of ltrace.

+ * Copyright (C) 2013 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 "bits.h"

+

+/* This is called rarely, and any overhead will be lost in ptrace

+ * noise, so the algorithm doesn't need to be terribly clever.  For

+ * the same reason we don't bother defining the corresponding _32

+ * variant.  */

+unsigned

+bitcount(uint64_t u)

+{

+	int c = 0;

+	for (; u > 0; u &= u - 1)

+		c++;

+	return c;

+}

diff --git a/bits.h b/bits.h

new file mode 100644

index 0000000..7dbe478

--- /dev/null

+++ b/bits.h

@@ -0,0 +1,29 @@

+/*

+ * This file is part of ltrace.

+ * Copyright (C) 2013 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 _BITS_H_

+#define _BITS_H_

+

+#include <stdint.h>

+

+/* Count bits in U that are 1.  */

+unsigned bitcount(uint64_t u);

+

+#endif /* _BITS_H_ */

diff --git a/breakpoint.h b/breakpoint.h

index 18af7a9..963cc66 100644

--- a/breakpoint.h

+++ b/breakpoint.h

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

 /*

  * This file is part of ltrace.

- * Copyright (C) 2012 Petr Machata, Red Hat Inc.

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

  * Copyright (C) 2009 Juan Cespedes

  *

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

@@ -82,11 +82,10 @@ int breakpoint_init(struct breakpoint *bp, struct process *proc,

 		    arch_addr_t addr, struct library_symbol *libsym);

 /* Make a clone of breakpoint BP into the area of memory pointed to by

- * RETP.  The original breakpoint was assigned to process OLD_PROC,

- * the cloned breakpoint will be attached to process NEW_PROC.

+ * RETP.  Symbols of cloned breakpoint are looked up in NEW_PROC.

  * Returns 0 on success or a negative value on failure.  */

 int breakpoint_clone(struct breakpoint *retp, struct process *new_proc,

-		     struct breakpoint *bp, struct process *old_proc);

+		     struct breakpoint *bp);

 /* Set callbacks.  If CBS is non-NULL, then BP->cbs shall be NULL.  */

 void breakpoint_set_callbacks(struct breakpoint *bp, struct bp_callbacks *cbs);

diff --git a/breakpoints.c b/breakpoints.c

index 8db4e26..7b5530a 100644

--- a/breakpoints.c

+++ b/breakpoints.c

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

 /*

  * This file is part of ltrace.

- * Copyright (C) 2006,2007,2011,2012 Petr Machata, Red Hat Inc.

+ * Copyright (C) 2006,2007,2011,2012,2013 Petr Machata, Red Hat Inc.

  * Copyright (C) 2009 Juan Cespedes

  * Copyright (C) 1998,2001,2002,2003,2007,2008,2009 Juan Cespedes

  * Copyright (C) 2006 Ian Wienand

@@ -117,7 +117,7 @@ arch_breakpoint_clone(struct breakpoint *retp, struct breakpoint *sbp)

 #endif

 static void

-breakpoint_init_base(struct breakpoint *bp, struct process *proc,

+breakpoint_init_base(struct breakpoint *bp,

 		     arch_addr_t addr, struct library_symbol *libsym)

 {

 	bp->cbs = NULL;

@@ -135,7 +135,7 @@ int

 breakpoint_init(struct breakpoint *bp, struct process *proc,

 		arch_addr_t addr, struct library_symbol *libsym)

 {

-	breakpoint_init_base(bp, proc, addr, libsym);

+	breakpoint_init_base(bp, addr, libsym);

 	return arch_breakpoint_init(proc, bp);

 }

@@ -157,7 +157,7 @@ breakpoint_destroy(struct breakpoint *bp)

 int

 breakpoint_clone(struct breakpoint *retp, struct process *new_proc,

-		 struct breakpoint *bp, struct process *old_proc)

+		 struct breakpoint *bp)

 {

 	struct library_symbol *libsym = NULL;

 	if (bp->libsym != NULL) {

@@ -165,7 +165,7 @@ breakpoint_clone(struct breakpoint *retp, struct process *new_proc,

 		assert(rc == 0);

 	}

-	breakpoint_init_base(retp, new_proc, bp->addr, libsym);

+	breakpoint_init_base(retp, bp->addr, libsym);

 	memcpy(retp->orig_value, bp->orig_value, sizeof(bp->orig_value));

 	retp->enabled = bp->enabled;

 	if (arch_breakpoint_clone(retp, bp) < 0)

@@ -211,6 +211,22 @@ insert_breakpoint(struct process *proc, void *addr,

 	assert(addr != 0);

+	/* We first create the breakpoint to find out what it's real

+	 * address is.  This makes a difference on ARM.

+	 *

+	 * XXX The real problem here is that to create a return

+	 * breakpoint ltrace calls get_return_addr and then

+	 * insert_breakpoint.  So get_return_addr needs to encode all

+	 * the information necessary for breakpoint_init into the

+	 * address itself, so ADDR is potentially mangled.  We filter

+	 * the noise out by first creating the breakpoint on stack,

+	 * and then looking at the address of the created breakpoint.

+	 * Replacing get_return_addr with get_return_breakpoint might

+	 * be a better solution.  */

+	struct breakpoint bp;

+	if (breakpoint_init(&bp, proc, addr, libsym) < 0)

+		return NULL;

+

 	/* XXX what we need to do instead is have a list of

 	 * breakpoints that are enabled at this address.  The

 	 * following works if every breakpoint is the same and there's

@@ -218,20 +234,21 @@ insert_breakpoint(struct process *proc, void *addr,

 	 * will suffice, about the only realistic case where we need

 	 * to have more than one breakpoint per address is return from

 	 * a recursive library call.  */

-	struct breakpoint *sbp = dict_find_entry(leader->breakpoints, addr);

-	if (sbp == NULL) {

+	struct breakpoint *sbp = dict_find_entry(leader->breakpoints, bp.addr);

+	if (sbp != NULL) {

+		breakpoint_destroy(&bp);

+	} else {

+	  //fprintf(stderr, "new BP at %p\n", addr);

 		sbp = malloc(sizeof(*sbp));

-		if (sbp == NULL

-		    || breakpoint_init(sbp, proc, addr, libsym) < 0) {

-			free(sbp);

-			return NULL;

-		}

-		if (proc_add_breakpoint(leader, sbp) < 0) {

+		if (sbp == NULL) {

 		fail:

-			breakpoint_destroy(sbp);

 			free(sbp);

+			breakpoint_destroy(&bp);

 			return NULL;

 		}

+		memcpy(sbp, &bp, sizeof(*sbp));

+		if (proc_add_breakpoint(leader, sbp) < 0)

+			goto fail;

 	}

 	if (breakpoint_turn_on(sbp, proc) < 0) {

diff --git a/handle_event.c b/handle_event.c

index 9dbb696..1eaea09 100644

--- a/handle_event.c

+++ b/handle_event.c

@@ -607,7 +607,6 @@ handle_breakpoint(Event *event)

 					calc_time_spent(event->proc);

 				}

 			}

-			event->proc->return_addr = brk_addr;

 			struct library_symbol *libsym =

 			    event->proc->callstack[i].c_un.libfunc;

@@ -663,8 +662,6 @@ handle_breakpoint(Event *event)

 		if (event->proc->state != STATE_IGNORED

 		    && sbp->libsym != NULL) {

 			event->proc->stack_pointer = get_stack_pointer(event->proc);

-			event->proc->return_addr =

-				get_return_addr(event->proc, event->proc->stack_pointer);

 			callstack_push_symfunc(event->proc, sbp->libsym);

 			output_left(LT_TOF_FUNCTION, event->proc, sbp->libsym);

 		}

@@ -722,9 +719,11 @@ callstack_push_symfunc(struct process *proc, struct library_symbol *sym)

 	elem->is_syscall = 0;

 	elem->c_un.libfunc = sym;

-	elem->return_addr = proc->return_addr;

-	if (elem->return_addr)

-		insert_breakpoint(proc, elem->return_addr, NULL);

+	arch_addr_t return_addr = get_return_addr(proc, proc->stack_pointer);

+	struct breakpoint *rbp = NULL;

+	if (return_addr != 0)

+		rbp = insert_breakpoint(proc, return_addr, NULL);

+	elem->return_addr = rbp != NULL ? rbp->addr : 0;

 	if (opt_T || options.summary) {

 		struct timezone tz;

diff --git a/lens_default.c b/lens_default.c

index ed3d0e1..47b8c70 100644

--- a/lens_default.c

+++ b/lens_default.c

@@ -29,6 +29,7 @@

 #include <stdio.h>

 #include <string.h>

+#include "bits.h"

 #include "proc.h"

 #include "lens_default.h"

 #include "value.h"

@@ -608,15 +609,6 @@ out_bits(FILE *stream, size_t low, size_t high)

 		return fprintf(stream, "%zd-%zd", low, high);

 }

-static unsigned

-bitcount(unsigned u)

-{

-	int c = 0;

-	for (; u > 0; u &= u - 1)

-		c++;

-	return c;

-}

-

 static int

 bitvect_lens_format_cb(struct lens *lens, FILE *stream,

 		       struct value *value, struct value_dict *arguments)

diff --git a/ltrace-elf.c b/ltrace-elf.c

index 1d0f769..af25f8f 100644

--- a/ltrace-elf.c

+++ b/ltrace-elf.c

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

 /*

  * This file is part of ltrace.

- * Copyright (C) 2006,2010,2011,2012 Petr Machata, Red Hat Inc.

+ * Copyright (C) 2006,2010,2011,2012,2013 Petr Machata, Red Hat Inc.

  * Copyright (C) 2010 Zachary T Welch, CodeSourcery

  * Copyright (C) 2010 Joe Damato

  * Copyright (C) 1997,1998,2001,2004,2007,2008,2009 Juan Cespedes

@@ -141,8 +141,9 @@ elf_get_section_if(struct ltelf *lte, Elf_Scn **tgt_sec, GElf_Shdr *tgt_shdr,

 			return 0;

 		}

 	}

-	return -1;

+	*tgt_sec = NULL;

+	return 0;

 }

 static int

@@ -203,23 +204,23 @@ elf_get_section_named(struct ltelf *lte, const char *name,

 				  &name_p, &data);

 }

-static int

-need_data(Elf_Data *data, GElf_Xword offset, GElf_Xword size)

+int

+elf_can_read_next(Elf_Data *data, GElf_Xword offset, GElf_Xword size)

 {

 	assert(data != NULL);

 	if (data->d_size < size || offset > data->d_size - size) {

 		debug(1, "Not enough data to read %"PRId64"-byte value"

 		      " at offset %"PRId64".", size, offset);

-		return -1;

+		return 0;

 	}

-	return 0;

+	return 1;

 }

 #define DEF_READER(NAME, SIZE)						\

 	int								\

 	NAME(Elf_Data *data, GElf_Xword offset, uint##SIZE##_t *retp)	\

 	{								\

-		if (!need_data(data, offset, SIZE / 8) < 0)		\

+		if (!elf_can_read_next(data, offset, SIZE / 8))		\

 			return -1;					\

 									\

 		if (data->d_buf == NULL) /* NODATA section */ {		\

@@ -236,12 +237,63 @@ need_data(Elf_Data *data, GElf_Xword offset, GElf_Xword size)

 		return 0;						\

 	}

+DEF_READER(elf_read_u8, 8)

 DEF_READER(elf_read_u16, 16)

 DEF_READER(elf_read_u32, 32)

 DEF_READER(elf_read_u64, 64)

 #undef DEF_READER

+#define DEF_READER(NAME, SIZE)						\

+	int								\

+	NAME(Elf_Data *data, GElf_Xword *offset, uint##SIZE##_t *retp)	\

+	{								\

+		int rc = elf_read_u##SIZE(data, *offset, retp);		\

+		if (rc < 0)						\

+			return rc;					\

+		*offset += SIZE / 8;					\

+		return 0;						\

+	}

+

+DEF_READER(elf_read_next_u8, 8)

+DEF_READER(elf_read_next_u16, 16)

+DEF_READER(elf_read_next_u32, 32)

+DEF_READER(elf_read_next_u64, 64)

+

+#undef DEF_READER

+

+int

+elf_read_next_uleb128(Elf_Data *data, GElf_Xword *offset, uint64_t *retp)

+{

+	uint64_t result = 0;

+	int shift = 0;

+	int size = 8 * sizeof result;

+

+	while (1) {

+		uint8_t byte;

+		if (elf_read_next_u8(data, offset, &byte) < 0)

+			return -1;

+

+		uint8_t payload = byte & 0x7f;

+		result |= (uint64_t)payload << shift;

+		shift += 7;

+		if (shift > size && byte != 0x1)

+			return -1;

+		if ((byte & 0x80) == 0)

+			break;

+	}

+

+	if (retp != NULL)

+		*retp = result;

+	return 0;

+}

+

+int

+elf_read_uleb128(Elf_Data *data, GElf_Xword offset, uint64_t *retp)

+{

+	return elf_read_next_uleb128(data, &offset, retp);

+}

+

 int

 open_elf(struct ltelf *lte, const char *filename)

 {

diff --git a/ltrace-elf.h b/ltrace-elf.h

index b76d1eb..178258b 100644

--- a/ltrace-elf.h

+++ b/ltrace-elf.h

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

 /*

  * This file is part of ltrace.

- * Copyright (C) 2006,2010,2012 Petr Machata, Red Hat Inc.

+ * Copyright (C) 2006,2010,2012,2013 Petr Machata, Red Hat Inc.

  * Copyright (C) 2010 Zachary T Welch

  * Copyright (C) 2001,2004,2007,2009 Juan Cespedes

  * Copyright (C) 2006 Ian Wienand

@@ -95,6 +95,12 @@ int elf_get_sym_info(struct ltelf *lte, const char *filename,

 		     size_t sym_index, GElf_Rela *rela, GElf_Sym *sym);

 Elf_Data *elf_loaddata(Elf_Scn *scn, GElf_Shdr *shdr);

+

+/* The following three look for sections based on various criteria.

+ * They return 0 if there was no error, or a negative value if there

+ * was.  If the section was found, it is returned in *TGT_SEC, and the

+ * header is stored te TGT_SHDR.  If it wasn't found, *TGT_SEC is set

+ * to NULL.  */

 int elf_get_section_covering(struct ltelf *lte, GElf_Addr addr,

 			     Elf_Scn **tgt_sec, GElf_Shdr *tgt_shdr);

 int elf_get_section_type(struct ltelf *lte, GElf_Word type,

@@ -102,13 +108,29 @@ int elf_get_section_type(struct ltelf *lte, GElf_Word type,

 int elf_get_section_named(struct ltelf *lte, const char *name,

 			  Elf_Scn **tgt_sec, GElf_Shdr *tgt_shdr);

-/* Read, respectively, 2, 4, or 8 bytes from Elf data at given OFFSET,

- * and store it in *RETP.  Returns 0 on success or a negative value if

- * there's not enough data.  */

+/* Read, respectively, 1, 2, 4, or 8 bytes from Elf data at given

+ * OFFSET, and store it in *RETP.  Returns 0 on success or a negative

+ * value if there's not enough data.  */

+int elf_read_u8(Elf_Data *data, GElf_Xword offset, uint8_t *retp);

 int elf_read_u16(Elf_Data *data, GElf_Xword offset, uint16_t *retp);

 int elf_read_u32(Elf_Data *data, GElf_Xword offset, uint32_t *retp);

 int elf_read_u64(Elf_Data *data, GElf_Xword offset, uint64_t *retp);

+/* Read at most 64-bit quantity recorded in an ULEB128 variable-length

+ * encoding.  */

+int elf_read_uleb128(Elf_Data *data, GElf_Xword offset, uint64_t *retp);

+

+/* These are same as above, but update *OFFSET with the width

+ * of read datum.  */

+int elf_read_next_u8(Elf_Data *data, GElf_Xword *offset, uint8_t *retp);

+int elf_read_next_u16(Elf_Data *data, GElf_Xword *offset, uint16_t *retp);

+int elf_read_next_u32(Elf_Data *data, GElf_Xword *offset, uint32_t *retp);

+int elf_read_next_u64(Elf_Data *data, GElf_Xword *offset, uint64_t *retp);

+int elf_read_next_uleb128(Elf_Data *data, GElf_Xword *offset, uint64_t *retp);

+

+/* Return whether there's AMOUNT more bytes after OFFSET in DATA.  */

+int elf_can_read_next(Elf_Data *data, GElf_Xword offset, GElf_Xword amount);

+

 #if __WORDSIZE == 32

 #define PRI_ELF_ADDR		PRIx32

 #define GELF_ADDR_CAST(x)	(void *)(uint32_t)(x)

diff --git a/output.c b/output.c

index fe62bb4..f046df8 100644

--- a/output.c

+++ b/output.c

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

 /*

  * This file is part of ltrace.

- * Copyright (C) 2011,2012 Petr Machata, Red Hat Inc.

+ * Copyright (C) 2011,2012,2013 Petr Machata, Red Hat Inc.

  * Copyright (C) 2010 Joe Damato

  * Copyright (C) 1997,1998,1999,2001,2002,2003,2004,2007,2008,2009 Juan Cespedes

  * Copyright (C) 2006 Paul Gilliam, IBM Corporation

@@ -119,12 +119,15 @@ begin_of_line(struct process *proc, int is_func, int indent)

 		}

 	}

 	if (opt_i) {

-		if (is_func)

+		if (is_func) {

+			struct callstack_element *stel

+				= &proc->callstack[proc->callstack_depth - 1];

 			current_column += fprintf(options.output, "[%p] ",

-						  proc->return_addr);

-		else

+						  stel->return_addr);

+		} else {

 			current_column += fprintf(options.output, "[%p] ",

 						  proc->instruction_pointer);

+		}

 	}

 	if (options.indent > 0 && indent) {

 		output_indent(proc);

diff --git a/proc.c b/proc.c

index db3f645..7dfde7c 100644

--- a/proc.c

+++ b/proc.c

@@ -314,8 +314,7 @@ clone_single_bp(void *key, void *value, void *u)

 	struct breakpoint *clone = malloc(sizeof(*clone));

 	if (clone == NULL

-	    || breakpoint_clone(clone, data->new_proc,

-				bp, data->old_proc) < 0) {

+	    || breakpoint_clone(clone, data->new_proc, bp) < 0) {

 	fail:

 		free(clone);

 		data->error = -1;

@@ -1050,6 +1049,7 @@ proc_each_symbol(struct process *proc, struct library_symbol *start_after,

 		return 0;						\

 	}

+DEF_READER(proc_read_8, 8)

 DEF_READER(proc_read_16, 16)

 DEF_READER(proc_read_32, 32)

 DEF_READER(proc_read_64, 64)

diff --git a/proc.h b/proc.h

index 04c0ef7..03708dc 100644

--- a/proc.h

+++ b/proc.h

@@ -65,7 +65,7 @@ struct callstack_element {

 		struct library_symbol * libfunc;

 	} c_un;

 	int is_syscall;

-	void * return_addr;

+	arch_addr_t return_addr;

 	struct timeval time_spent;

 	struct fetch_context *fetch_context;

 	struct value_dict *arguments;

@@ -106,7 +106,6 @@ struct process {

 	/* Arch-dependent: */

 	void * instruction_pointer;

 	void * stack_pointer;      /* To get return addr, args... */

-	void * return_addr;

 	void * arch_ptr;

 	/* XXX We would like to replace this with a pointer to ABI

@@ -116,11 +115,6 @@ struct process {

 	short e_machine;

 	char e_class;

-	/* XXX this shoudl go to ARM's arch_process_data.  */

-#ifdef __arm__

-	int thumb_mode;           /* ARM execution mode: 0: ARM, 1: Thumb */

-#endif

-

 #if defined(HAVE_LIBUNWIND)

 	/* libunwind address space */

 	unw_addr_space_t unwind_as;

@@ -254,10 +248,11 @@ struct library_symbol *proc_each_symbol

 	 enum callback_status (*cb)(struct library_symbol *, void *),

 	 void *data);

-/* Read 16, 32 or 64-bit quantity located at ADDR in PROC.  The

+/* Read 8, 16, 32 or 64-bit quantity located at ADDR in PROC.  The

  * resulting value is stored in *LP.  0 is returned on success or a

  * negative value on failure.  This uses umovebytes under the hood

  * (see backend.h).  */

+int proc_read_8(struct process *proc, arch_addr_t addr, uint8_t *lp);

 int proc_read_16(struct process *proc, arch_addr_t addr, uint16_t *lp);

 int proc_read_32(struct process *proc, arch_addr_t addr, uint32_t *lp);

 int proc_read_64(struct process *proc, arch_addr_t addr, uint64_t *lp);

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

index c197225..9ccd8f2 100644

--- a/sysdeps/linux-gnu/alpha/regs.c

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

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

 /*

  * This file is part of ltrace.

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

  * Copyright (C) 2004,2008,2009 Juan Cespedes

  *

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

@@ -58,9 +59,3 @@ get_return_addr(struct process *proc, void *stack_pointer)

 {

 	return (void *)ptrace(PTRACE_PEEKUSER, proc->pid, 26 /* RA */ , 0);

 }

-

-void

-set_return_addr(struct process *proc, void *addr)

-{

-	ptrace(PTRACE_POKEUSER, proc->pid, 26 /* RA */ , addr);

-}

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

index 385424c..2c180c6 100644

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

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

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

 # This file is part of ltrace.

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

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

 #

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

@@ -16,21 +17,11 @@

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

 # 02110-1301 USA

-noinst_LTLIBRARIES = \

-	../libcpu.la

+noinst_LTLIBRARIES = ../libcpu.la

-___libcpu_la_SOURCES = \

-	breakpoint.c \

-	plt.c \

-	regs.c \

-	trace.c

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

-noinst_HEADERS = \

-	arch.h \

-	arch_syscallent.h \

-	ptrace.h \

-	signalent.h \

-	syscallent.h

+noinst_HEADERS = arch.h arch_syscallent.h ptrace.h regs.h signalent.h	\

+	 syscallent.h

-MAINTAINERCLEANFILES = \

-	Makefile.in

+MAINTAINERCLEANFILES = Makefile.in

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

index 291443a..58a7fdf 100644

--- a/sysdeps/linux-gnu/arm/arch.h

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

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

 /*

  * This file is part of ltrace.

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

  * Copyright (C) 1998,2004,2008 Juan Cespedes

  *

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

@@ -18,6 +19,9 @@

  * 02110-1301 USA

  */

+#ifndef LTRACE_ARM_ARCH_H

+#define LTRACE_ARM_ARCH_H

+

 #define ARCH_HAVE_ENABLE_BREAKPOINT 1

 #define ARCH_HAVE_DISABLE_BREAKPOINT 1

@@ -31,7 +35,24 @@

 #define LT_ELFCLASS	ELFCLASS32

 #define LT_ELF_MACHINE	EM_ARM

+#define ARCH_HAVE_SW_SINGLESTEP

+#define ARCH_HAVE_FETCH_ARG

+#define ARCH_HAVE_FETCH_PACK

+#define ARCH_HAVE_SIZEOF

+#define ARCH_HAVE_ALIGNOF

 #define ARCH_HAVE_BREAKPOINT_DATA

 struct arch_breakpoint_data {

 	int thumb_mode;

 };

+

+#define ARCH_HAVE_LTELF_DATA

+struct arch_ltelf_data {

+	/* We have this only for the hooks.  */

+};

+

+#define ARCH_HAVE_LIBRARY_DATA

+struct arch_library_data {

+	unsigned int hardfp:1;

+};

+

+#endif /* LTRACE_ARM_ARCH_H */

diff --git a/sysdeps/linux-gnu/arm/breakpoint.c b/sysdeps/linux-gnu/arm/breakpoint.c

index 2fb9578..fcd43a7 100644

--- a/sysdeps/linux-gnu/arm/breakpoint.c

+++ b/sysdeps/linux-gnu/arm/breakpoint.c

@@ -94,14 +94,11 @@ arch_disable_breakpoint(pid_t pid, const struct breakpoint *sbp)

 int

 arch_breakpoint_init(struct process *proc, struct breakpoint *sbp)

 {

-	/* XXX That uintptr_t cast is there temporarily until

-	 * arch_addr_t becomes integral type.  */

-	int thumb_mode = ((uintptr_t)sbp->addr) & 1;

-	if (thumb_mode)

-		sbp->addr = (void *)((uintptr_t)sbp->addr & ~1);

-	sbp->arch.thumb_mode = thumb_mode | proc->thumb_mode;

-	/* XXX This doesn't seem like it belongs here.  */

-	proc->thumb_mode = 0;

+	/* XXX double cast  */

+	sbp->arch.thumb_mode = ((uintptr_t)sbp->addr) & 1;

+	if (sbp->arch.thumb_mode)

+		/* XXX double cast */

+		sbp->addr = (arch_addr_t)((uintptr_t)sbp->addr & ~1);

 	return 0;

 }

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

new file mode 100644

index 0000000..0064d91

--- /dev/null

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

@@ -0,0 +1,529 @@

+/*

+ * This file is part of ltrace.

+ * Copyright (C) 2013 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 <assert.h>

+#include <elf.h>

+#include <libelf.h>

+#include <stdint.h>

+#include <stdio.h>

+#include <stdlib.h>

+#include <string.h>

+#include <stdbool.h>

+

+#include "backend.h"

+#include "fetch.h"

+#include "library.h"

+#include "ltrace-elf.h"

+#include "proc.h"

+#include "ptrace.h"

+#include "regs.h"

+#include "type.h"

+#include "value.h"

+

+static int

+get_hardfp(uint64_t abi_vfp_args)

+{

+	if (abi_vfp_args == 2)

+		fprintf(stderr,

+			"Tag_ABI_VFP_args value 2 (tool chain-specific "

+			"conventions) not supported.\n");

+	return abi_vfp_args == 1;

+}

+

+int

+arch_elf_init(struct ltelf *lte, struct library *lib)

+{

+	/* Nothing in this section is strictly critical.  It's not

+	 * that much of a deal if we fail to guess right whether the

+	 * ABI is softfp or hardfp.  */

+	unsigned hardfp = 0;

+

+	Elf_Scn *scn;

+	Elf_Data *data;

+	GElf_Shdr shdr;

+	if (elf_get_section_type(lte, SHT_ARM_ATTRIBUTES, &scn, &shdr) < 0

+	    || (scn != NULL && (data = elf_loaddata(scn, &shdr)) == NULL)) {

+		fprintf(stderr,

+			"Error when obtaining ARM attribute section: %s\n",

+			elf_errmsg(-1));

+		goto done;

+

+	} else if (scn != NULL && data != NULL) {

+		GElf_Xword offset = 0;

+		uint8_t version;

+		if (elf_read_next_u8(data, &offset, &version) < 0) {

+			goto done;

+		} else if (version != 'A') {

+			fprintf(stderr, "Unsupported ARM attribute section "

+				"version %d ('%c').\n", version, version);

+			goto done;

+		}

+

+		do {

+			const char signature[] = "aeabi";

+			/* N.B. LEN is including the length field

+			 * itself.  */

+			uint32_t sec_len;

+			if (elf_read_u32(data, offset, &sec_len) < 0

+			    || !elf_can_read_next(data, offset, sec_len)) {

+				goto done;

+			}

+			const GElf_Xword next_offset = offset + sec_len;

+			offset += 4;

+

+			if (sec_len < 4 + sizeof signature

+			    || strcmp(signature, data->d_buf + offset) != 0)

+				goto skip;

+			offset += sizeof signature;

+

+			const GElf_Xword offset0 = offset;

+			uint64_t tag;

+			uint32_t sub_len;

+			if (elf_read_next_uleb128(data, &offset, &tag) < 0

+			    || elf_read_next_u32(data, &offset, &sub_len) < 0

+			    || !elf_can_read_next(data, offset0, sub_len))

+				goto done;

+

+			if (tag != 1)

+				/* IHI0045D_ABI_addenda: "section and

+				 * symbol attributes are deprecated

+				 * [...] consumers are permitted to

+				 * ignore them."  */

+				goto skip;

+

+			while (offset < offset0 + sub_len) {

+				if (elf_read_next_uleb128(data,

+							  &offset, &tag) < 0)

+					goto done;

+

+				switch (tag) {

+					uint64_t v;

+				case 6: /* Tag_CPU_arch */

+				case 7: /* Tag_CPU_arch_profile */

+				case 8: /* Tag_ARM_ISA_use */

+				case 9: /* Tag_THUMB_ISA_use */

+				case 10: /* Tag_FP_arch */

+				case 11: /* Tag_WMMX_arch */

+				case 12: /* Tag_Advanced_SIMD_arch */

+				case 13: /* Tag_PCS_config */