use libunwind for ARM in case of McTernan unwinder

Change-Id: I6fb6f95df6f09a1b4c7e38489606aaab1e452e59

24 files changed, 45 insertions, 5419 deletions

diff --git a/packaging/crash-worker.spec b/packaging/crash-worker.spec
index 7d058b7..061844f 100644
--- a/packaging/crash-worker.spec
+++ b/packaging/crash-worker.spec
@@ -27,6 +27,9 @@ BuildRequires:  pkgconfig(libunwind)
 BuildRequires:  libelf-devel libelf
 BuildRequires:  libebl-devel libebl
 BuildRequires:  libdw-devel libdw
+%ifarch %{arm}
+BuildRequires:  pkgconfig(libunwind-ptrace)
+%endif
 %if %{with doc}
 BuildRequires:  doxygen
 %endif
@@ -34,7 +37,6 @@ BuildRequires:  doxygen
 Requires(post): coreutils
 Requires(post): tar
 Requires(post): gzip
-Requires: libunwind
 Requires: zip
 # If you need support for core dump files (see building below),
 # you should add this dependency
@@ -194,4 +196,3 @@ sed -i "/${pattern}/D" %{_sysconfdir}/ld.so.preload
 %files doc
 %{_datadir}/doc/crash-worker
 %endif
-
diff --git a/src/crash-stack/CMakeLists.txt b/src/crash-stack/CMakeLists.txt
index ebe8121..6ad84d1 100644
--- a/src/crash-stack/CMakeLists.txt
+++ b/src/crash-stack/CMakeLists.txt
@@ -1,3 +1,5 @@
+cmake_minimum_required(VERSION 2.8.11)
+
 option(WITH_CORE_DUMP "builds with support for core dump files (with GPL2 license)")
 set(CRASH_STACK_BIN "crash-stack")
 
@@ -5,7 +7,7 @@ set(CRASH_STACK_BIN "crash-stack")
 set(CRASH_STACK_SRCS crash-stack.c crash-stack-libelf-helpers.c)
 # Add architecture dependent source files
 if (${CMAKE_SYSTEM_PROCESSOR} STREQUAL "armv7l")
-  set(CRASH_STACK_SRCS ${CRASH_STACK_SRCS} crash-stack-arm.c wind/unwarm.c wind/unwarm_thumb.c wind/unwarm_arm.c wind/unwarmmem.c)
+  set(CRASH_STACK_SRCS ${CRASH_STACK_SRCS} crash-stack-arm.c)
 else()
   if (${CMAKE_SYSTEM_PROCESSOR} STREQUAL "aarch64")
     set(CRASH_STACK_SRCS ${CRASH_STACK_SRCS} crash-stack-aarch64.c)
@@ -23,8 +25,9 @@ add_executable(${CRASH_STACK_BIN} ${CRASH_STACK_SRCS})
 
 # Set architecture dependent options for the binary - it must be already added
 if (${CMAKE_SYSTEM_PROCESSOR} STREQUAL "armv7l")
-  set_property(TARGET ${CRASH_STACK_BIN} APPEND_STRING PROPERTY COMPILE_FLAGS " -DUPGRADE_ARM_STACK_UNWIND")
-#  set_property(TARGET ${CRASH_STACK_BIN} APPEND_STRING PROPERTY COMPILE_FLAGS "-DUPGRADE_ARM_STACK_UNWIND -DUNW_DEBUG")
+  include(FindPkgConfig)
+  pkg_check_modules(LIBUNWIND_PTRACE REQUIRED libunwind-ptrace)
+  set_property(TARGET ${CRASH_STACK_BIN} APPEND_STRING PROPERTY COMPILE_FLAGS ${LIBUNWIND_PTRACE_CFLAGS_OTHER})
 endif()
 
 # Set compilation options for core dump support
@@ -34,7 +37,7 @@ if (${WITH_CORE_DUMP} STREQUAL "ON")
 endif()
 
 # Linking
-target_link_libraries(${CRASH_STACK_BIN} ${EBL_LIBRARY} dw elf dl stdc++)
+target_link_libraries(${CRASH_STACK_BIN} ${LIBUNWIND_PTRACE_LIBRARIES} ${EBL_LIBRARY} dw elf dl stdc++)
 # Installing
 install(TARGETS ${CRASH_STACK_BIN} DESTINATION libexec)
 
diff --git a/src/crash-stack/crash-stack-arm.c b/src/crash-stack/crash-stack-arm.c
index e02f324..29cb493 100644
--- a/src/crash-stack/crash-stack-arm.c
+++ b/src/crash-stack/crash-stack-arm.c
@@ -15,22 +15,27 @@
  * limitations under the License.
  *
  * Author: Adrian Szyndela <adrian.s@samsung.com>
+ *         Rafal Pietruch <r.pietruch@samsung.com>
  */
 /**
  * @file crash-stack-arm.c
  * @brief unwinding call stacks, functions specific for ARM
  */
 #include "crash-stack.h"
-#include "wind/unwarm.h"
+#include <libunwind-ptrace.h>
 
 #include <string.h>
 #include <sys/ptrace.h>
 #include <sys/user.h>
 
-static Elf *g_core = NULL;					///< core file handler
-static Dwfl *g_dwfl = NULL;					///< dwfl handler
-static Mappings *g_mappings = NULL;			///< pointer to mappings database
-static pid_t g_pid = 0;						///< PID of analyzed program
+// definitions copied from previously used McTernan unwinder
+#define REGS_REGULAR_NUM 13
+#define REG_FP 11
+#define REG_IP 12
+#define REG_SP 13
+#define REG_LR 14
+#define REG_PC 15
+#define REG_SPSR 16
 
 /**
  * @brief Important registers for unwinding stack on ARM
@@ -81,113 +86,34 @@ void _crash_stack_set_ptrace_registers(void *regbuf)
 	}
 }
 
-/**
- * @brief Callback function for McTernan's unwinder - call stack frame reporting
- *
- * @param data pointer to call stack database
- * @param address return address of the function in the reported call frame
- */
-static Boolean __report(void *data, Int32 address)
-{
-	Callstack *callstack = (Callstack *)(data);
-	callstack->tab[callstack->elems++] = address;
-
-	return callstack->elems < MAX_CALLSTACK_LEN ? TRUE : FALSE;
-}
-
-/**
- * @brief Helper function for reading values from target memory
- *
- * @param a target address to read from
- * @param v destination address to copy data to
- * @param size of the value
- */
-static Boolean __readT(Int32 a, void *v, size_t size)
-{
-  return _crash_stack_libelf_read_value(g_dwfl, g_core, g_pid, a, v, size, g_mappings);
-}
-
-/**
- * @brief Callback function for McTernan's unwinder - reading 32 bits
- *
- * @param a target address to read from
- * @param v destination address to copy data to
- */
-static Boolean __readW(Int32 a, Int32 *v)
-{
-	return __readT(a, v, sizeof(*v));
-}
-
-/**
- * @brief Callback function for McTernan's unwinder - reading 16 bits
- *
- * @param a target address to read from
- * @param v destination address to copy data to
- */
-static Boolean __readH(Int32 a, Int16 *v)
-{
-	return __readT(a, v, sizeof(*v));
-}
-
-/**
- * @brief Callback function for McTernan's unwinder - reading 8 bits
- *
- * @param a target address to read from
- * @param v destination address to copy data to
- */
-static Boolean __readB(Int32 a, Int8 *v)
-{
-	return __readT(a, v, sizeof(*v));
-}
-
-/**
- * @brief Callback function for McTernan's unwinder - trying to find function prologue
- *
- * @param current_pc address from inside of some function from target memory
- */
-static Int32 __getProloguePC(Int32 current_pc)
-{
-    return _crash_stack_libelf_get_prologue_pc(g_dwfl, current_pc, g_mappings);
-}
-
 void _create_crash_stack(Dwfl *dwfl, Elf *core, pid_t pid, Mappings *mappings, Callstack *callstack)
 {
-	UnwindCallbacks callbacks = {
-		__report,
-		__readW,
-		__readH,
-		__readB,
-		__getProloguePC
-#ifdef UNW_DEBUG
-			,
-		printf
-#endif
-	};
-	UnwState state;
-
-	g_dwfl = dwfl;
-	g_core = core;
-	g_mappings = mappings;
-	g_pid = pid;
-
-	callstack->tab[0] = g_regs.pc;
-	callstack->elems = 1;
-
-	UnwInitState(&state, &callbacks, callstack, g_regs.pc, g_regs.sp);
-	int i;
-	for (i = 0; i < REGS_REGULAR_NUM; i++) {
-		state.regData[i].v = g_regs.regs[i];
-		state.regData[i].o = REG_VAL_FROM_CONST;
+	// reimplemented based on libunwind tests/test-ptrace.c file
+	callstack->elems = 0;
+	unw_addr_space_t as = unw_create_addr_space(&_UPT_accessors, 0);
+	if (as) {
+		void *uptInfo = _UPT_create(pid);
+		if (uptInfo) {
+			unw_cursor_t cursor;
+			if (unw_init_remote(&cursor, as, uptInfo) >= 0) {
+				// MaxDeep as proposed in libunwind tests/test-ptrace.c file
+				// guard against bad unwind info in old libraries
+				static const int MaxDeep = 64;
+				int n;
+				for (n = 0; n < MaxDeep; ++n) {
+					unw_word_t ip;
+					if (unw_get_reg(&cursor, UNW_REG_IP, &ip) >= 0) {
+						callstack->tab[callstack->elems++] = ip;
+					}
+					int step = unw_step(&cursor);
+					if (step <= 0)
+						break;
+				}
+			}
+			_UPT_destroy(uptInfo);
+		}
+		unw_destroy_addr_space(as);
 	}
-	state.regData[REG_LR].v = g_regs.lr;
-	state.regData[REG_LR].o = REG_VAL_FROM_STACK;
-	state.regData[REG_SPSR].v = g_regs.spsr;
-	state.regData[REG_SPSR].o = REG_VAL_FROM_CONST;
-
-	if (UnwIsAddrThumb(g_regs.pc, g_regs.spsr))
-		UnwStartThumb(&state);
-	else
-		UnwStartArm(&state);
 }
 
 void _crash_stack_print_regs(FILE* outputfile)
diff --git a/src/crash-stack/wind/LICENCE b/src/crash-stack/wind/LICENCE
deleted file mode 100644
index 50c14f2..0000000
--- a/src/crash-stack/wind/LICENCE
+++ /dev/null
@@ -1,11 +0,0 @@
-The source code for the stack unwinder is released as public domain. 
-This means that there is no copyright and anyone is able to take a 
-copy for free and use it as they wish, with or without modifications,
-and in any context they like, commercially or otherwise. 
-
-The only limitation is that I don't guarantee that the software is fit
-for any purpose or accept any liability for it's use or misuse - 
-the software is without warranty.
-
-Michael McTernan
-Michael.McTernan.2001@cs.bris.ac.uk
diff --git a/src/crash-stack/wind/Makefile b/src/crash-stack/wind/Makefile
deleted file mode 120000
index 14a7604..0000000
--- a/src/crash-stack/wind/Makefile
+++ /dev/null
@@ -1 +0,0 @@
-Makefile.make
\ No newline at end of file
diff --git a/src/crash-stack/wind/Makefile.make b/src/crash-stack/wind/Makefile.make
deleted file mode 100644
index a324966..0000000
--- a/src/crash-stack/wind/Makefile.make
+++ /dev/null
@@ -1,50 +0,0 @@
-
-# Select the compiler to use
-CC=ARMCC
-#CC=TCC
-
-# Optimisation options
-OPT?=-O1
-
-# General flags
-CFLAGS=-I. -DON_PC $(OPT) -DUNW_DEBUG -DUPGRADE_ARM_STACK_UNWIND
-
-MAINFILES=unwarminder.o unwarm.o unwarm_thumb.o unwarm_arm.o unwarmmem.o 
-
-all: simplefunc.s unwind.axf unwind.sym 
-
-unwind.axf: CC+=--apcs=/interwork
-unwind.axf: $(MAINFILES) simplefunc.o client.o
-	$(CC) -o $@ $^
-
-unwind.sym: unwind.axf
-	fromElf -o $@ --text -s $^ 
-
-unwind: CC=gcc
-unwind: CFLAGS+=-DSIM_CLIENT
-unwind: CFLAGS+=-Wall -Wextra -Wshadow -Wpointer-arith -Wcast-align \
-				-Wunreachable-code -Wpointer-arith -Waggregate-return \
-				-Wpadded -ansi -pedantic
-unwind: $(MAINFILES) simclient.o
-	$(CC) -o $@ $^
-	
-%.s: %.c
-	$(CC) -S $(CFLAGS) $^
-
-run: all
-	armsd unwind.axf
-	
-lint: OPT=
-lint: $(MAINFILES:.o=.c) client.c
-	splint -booltype Boolean -boolfalse FALSE -booltrue TRUE -retvalint +charindex -type -predboolint $(CFLAGS) $^	
-	
-clean: 
-	rm -f *.s *.o unwind.axf unwind unwind.exe
-
-copy:
-	cp unw*.c /cygdrive/C/tplgsm/kicode
-	cp unw*.h /cygdrive/C/tplgsm/kiinc
-
-.PHONY: clean copy
-
-# DO NOT DELETE
diff --git a/src/crash-stack/wind/README b/src/crash-stack/wind/README
deleted file mode 100644
index 142a0d2..0000000
--- a/src/crash-stack/wind/README
+++ /dev/null
@@ -1,131 +0,0 @@
-Getting Started
-===============
-
-The simplest demonstration of the unwinder is to use the simulation client
-and supplied memory image.  Building and running this can be done on the PC
-in the following way:
-
-    $ make unwind
-
-This will use GCC to build the unwinder and the simulation client that is
-already configured to read the memory image provided in memhigh.dat
-and memlow.dat.  The simulation can be ran under a debugger, Valgrind etc...
-and can be ran as follows:
-
-    $ ./unwind
-    [ Lots of ouput removed ] 
-    Read 0x680ae800 H
-    fread() failed: : No error
-    A: 0x0000a904
-    A: 0x0000a97c
-    A: 0x0000a9e8
-    A: 0x0000a9d8
-    A: 0x0000a9d8
-    A: 0x0000a9d8
-    A: 0x0000a9d8
-    T: 0x0000ab0e
-    T: 0x0000ab28
-    A: 0x0000aabc
-    A: 0x0000aad8
-    A: 0x0000b4bc
-    A: 0xe800e800
-
-    Result: 8
-    
-This shows the unwound stack addresses and processor mode (A = ARM, T = Thumb).
-The supplied sym file gives the addresses of the functions, making it possible
-to lookup the function names on the stack.
-
-NOTE: If you have ran make without the 'unwind' target specified, it will have
-defaulted to building the ARM target, and depending on the environment may 
-have produced some object files that are incompatible with GCC.  Executing
-'make clean' will remove these objects.
-
-
-Building an ARM Image
-=====================
-
-You will need ARM tools installed as well as an emulator.  I use RVCT with the
-ARMSD emulator from the SDT version of the tool chain (RVD, the newer debugger
-is very expensive, and the older debugger is fine for this purpose).
-
-To build an executable ARM image, do the following:
-
-    $ make clean
-    $ make 
-    
-This will delete any old PC format objects, and then compile a version of the
-code that can be executed in ARMSD in the following manner:
-
-    $ armsd unwind.axf
-    ARM Source-level Debugger vsn 4.60 (ARM Ltd SDT2.51) [Build number 128]
-    RDI 1.5->1.0 Protocol converter vsn 0.1 [Feb 12 2000]
-    ARMulator SDT2.51 [Build number 128]
-    ARM7TDMI, Tracer, 4GB, Dummy MMU, Soft Angel 1.4 [Angel SWIs], FPE,
-      Profiler, Pagetables, Little endian.
-    Object program file unwind.axf
-    armsd: go
-    [ Lots of ouput removed ] 
-    A: 0x0000ac4c
-    A: 0x0000acc4
-    A: 0x0000ad20
-    A: 0x0000ad20
-    A: 0x0000ad20
-    A: 0x0000ad20
-    T: 0x0000ae56
-    T: 0x0000ae70
-    A: 0x0000ae04
-    A: 0x0000ae20
-    A: 0x0000b420
-    
-    Result: 1
-    2525 9Program terminated normally at PC = 0x0000bd50 (_sys_exit + 0x8)
-    +0008 0x0000bd50: 0xef123456  V4.. :    swi      0x123456
-    armsd:
-    
-Since a target image is available, the resulting addresses can be converted 
-into function names by using the binutils 'addr2line' tool.  Looking up the
-addresses in the symbol file, produced via fromElf, is also possible, as is
-using a debugger or any other tool you may have to hand.  For example, I made 
-a small program callled addr2sym which serves a similar purpose to addr2line, 
-but formats output in a similar manner to the stack result.  Processing the
-above stack trace gives the following output:
-
-$ addr2sym unwind.axf 0x0000ac4c 0x0000acc4 0x0000ad20 0x0000ad20 0x0000ad2
-0 0x0000ad20  0x0000ae56 0x0000ae70 0x0000ae04 0x0000ae20 0x0000b420 0xe800e800
-0: 0x0000ac4c: tailCall() + 0xc
-1: 0x0000acc4: testStackResize() + 0x48
-2: 0x0000ad20: testRecurse() + 0x18
-3: 0x0000ad20: testRecurse() + 0x18
-4: 0x0000ad20: testRecurse() + 0x18
-5: 0x0000ad20: testRecurse() + 0x18
-6: 0x0000ae56: testThumb1() + 0x11
-7: 0x0000ae70: testThumb() + 0x13
-8: 0x0000ae04: testPrintf() + 0x1c
-9: 0x0000ae20: main() + 0x8
-a: 0x0000b420: __rt_entry() + 0x3c
-
-
-Moving to a Target
-==================
-
-If you have a target and wish to use the unwinder on it, you will probably 
-need to modify the client code to display the unwind information in a way
-more suitable to an embedded target; for example to a display or via a
-serial port.  Building without UNW_DEBUG is advised, as the debug strings
-will consume a lot of ROM and are only really of interest if unwinding does
-not correctly handle some situation that needs investigating.
-
-
-Changelog
-=========
-
-12/07/2007: Correct instruction decoding error.
-            Add new stop cause to catch jump through zero.
-21/01/2006: Initial revision.
-
-
-Michael McTernan
-Michael.McTernan.2001@cs.bris.ac.uk
-
-END OF FILE
\ No newline at end of file
diff --git a/src/crash-stack/wind/client.c b/src/crash-stack/wind/client.c
deleted file mode 100644
index 49d5fc7..0000000
--- a/src/crash-stack/wind/client.c
+++ /dev/null
@@ -1,118 +0,0 @@
-/***************************************************************************
- * ARM Stack Unwinder, Michael.McTernan.2001@cs.bris.ac.uk
- *
- * This program is PUBLIC DOMAIN.
- * This means that there is no copyright and anyone is able to take a copy
- * for free and use it as they wish, with or without modifications, and in
- * any context, commercially or otherwise. The only limitation is that I
- * don't guarantee that the software is fit for any purpose or accept any
- * liability for it's use or misuse - this software is without warranty.
- ***************************************************************************
- * File Description: Unwinder client that reads local memory.
- *   This client reads from local memory and is designed to run on target
- *   along with the unwinder.  Memory read requests are implemented by
- *   casting a point to read the memory directly, although checks for
- *   alignment should probably also be made if this is to be used in
- *   production code, as otherwise the ARM may return the memory in a
- *   rotated/rolled format, or the MMU may generate an alignment exception
- *   if present and so configured.
- **************************************************************************/
-
-/***************************************************************************
- * Includes
- ***************************************************************************/
-
-#include "client.h"
-
-/***************************************************************************
- * Prototypes
- ***************************************************************************/
-
-static Boolean CliReport(void *data, Int32 address);
-static Boolean CliReadW(Int32 a, Int32 *v);
-static Boolean CliReadH(Int32 a, Int16 *v);
-static Boolean CliReadB(Int32 a, Int8  *v);
-
-/***************************************************************************
- * Variables
- ***************************************************************************/
-
-/* Table of function pointers for passing to the unwinder */
-const UnwindCallbacks cliCallbacks =
-    {
-        CliReport,
-        CliReadW,
-        CliReadH,
-        CliReadB
-#if defined(UNW_DEBUG)
-       ,printf
-#endif
-    };
-
-
-/***************************************************************************
- * Callbacks
- ***************************************************************************/
-
-/***************************************************************************
- *
- * Function:     CliReport
- *
- * Parameters:   data    - Pointer to data passed to UnwindStart()
- *               address - The return address of a stack frame.
- *
- * Returns:      TRUE if unwinding should continue, otherwise FALSE to
- *                 indicate that unwinding should stop.
- *
- * Description:  This function is called from the unwinder each time a stack
- *                 frame has been unwound.  The LSB of address indicates if
- *                 the processor is in ARM mode (LSB clear) or Thumb (LSB
- *                 set).
- *
- ***************************************************************************/
-static Boolean CliReport(void *data, Int32 address)
-{
-    CliStack *s = (CliStack *)data;
-
-#if defined(UNW_DEBUG)
-    printf("\nCliReport: 0x%08x\n", address);
-#endif
-
-    s->address[s->frameCount] = address;
-    s->frameCount++;
-
-    if(s->frameCount >= (sizeof(s->address) / sizeof(s->address[0])))
-    {
-        return FALSE;
-    }
-    else
-    {
-        return TRUE;
-    }
-}
-
-static Boolean CliReadW(const Int32 a, Int32 *v)
-{
-    *v = *(Int32 *)a;
-    return TRUE;
-}
-
-static Boolean CliReadH(const Int32 a, Int16 *v)
-{
-    *v = *(Int16 *)a;
-    return TRUE;
-}
-
-static Boolean CliReadB(const Int32 a, Int8 *v)
-{
-    *v = *(Int8 *)a;
-    return TRUE;
-}
-
-Boolean CliInvalidateW(const Int32 a)
-{
-    *(Int32 *)a = 0xdeadbeef;
-    return TRUE;
-}
-
-/* END OF FILE */
diff --git a/src/crash-stack/wind/client.h b/src/crash-stack/wind/client.h
deleted file mode 100644
index b7c2d84..0000000
--- a/src/crash-stack/wind/client.h
+++ /dev/null
@@ -1,74 +0,0 @@
-/***************************************************************************
- * ARM Stack Unwinder, Michael.McTernan.2001@cs.bris.ac.uk
- *
- * This program is PUBLIC DOMAIN.
- * This means that there is no copyright and anyone is able to take a copy
- * for free and use it as they wish, with or without modifications, and in
- * any context, commercially or otherwise. The only limitation is that I
- * don't guarantee that the software is fit for any purpose or accept any
- * liability for it's use or misuse - this software is without warranty.
- ***************************************************************************
- * File Description:  Unwinder client that reads local memory.
- **************************************************************************/
-
-#ifndef CLIENT_H
-#define CLIENT_H
-
-/***************************************************************************
- * Nested Includes
- ***************************************************************************/
-
-#include <stdio.h>
-#include "unwarminder.h"
-
-#if defined(SIM_CLIENT)
-#error This file is not for the simulated unwinder client
-#endif
-
-/***************************************************************************
- * Typedefs
- ***************************************************************************/
-
-/** Example structure for holding unwind results.
- */
-typedef struct
-{
-    Int16 frameCount;
-    Int32 address[32];
-}
-CliStack;
-
-/***************************************************************************
- * Variables
- ***************************************************************************/
-
-extern const UnwindCallbacks cliCallbacks;
-
-/***************************************************************************
- * Macros
- ***************************************************************************/
-
-#define UNWIND()                                                \
-{                                                               \
-    CliStack  results;                                          \
-    Int8      t;                                                \
-    UnwResult r;                                                \
-                                                                \
-    (results).frameCount = 0;                                   \
-    r = UnwindStart(__current_sp(), &cliCallbacks, &results);   \
-                                                                \
-    for(t = 0; t < (results).frameCount; t++)                   \
-    {                                                           \
-        printf("%c: 0x%08x\n",                                  \
-               (results.address[t] & 0x1) ? 'T' : 'A',          \
-               results.address[t] & (~0x1));                    \
-    }                                                           \
-                                                                \
-    printf("\nResult: %d\n", r);                                \
-}
-
-
-#endif
-
-
-/* END OF FILE */
diff --git a/src/crash-stack/wind/memhigh.dat b/src/crash-stack/wind/memhigh.dat
deleted file mode 100644
index 8a5f0fe..0000000
--- a/src/crash-stack/wind/memhigh.dat
+++ /dev/null
diff --git a/src/crash-stack/wind/memlow.dat b/src/crash-stack/wind/memlow.dat
deleted file mode 100644
index 19b5687..0000000
--- a/src/crash-stack/wind/memlow.dat
+++ /dev/null
diff --git a/src/crash-stack/wind/simclient.c b/src/crash-stack/wind/simclient.c
deleted file mode 100644
index 21290de..0000000
--- a/src/crash-stack/wind/simclient.c
+++ /dev/null
@@ -1,245 +0,0 @@
-/***************************************************************************
- * ARM Stack Unwinder, Michael.McTernan.2001@cs.bris.ac.uk
- *
- * This program is PUBLIC DOMAIN.
- * This means that there is no copyright and anyone is able to take a copy
- * for free and use it as they wish, with or without modifications, and in
- * any context, commercially or otherwise. The only limitation is that I
- * don't guarantee that the software is fit for any purpose or accept any
- * liability for it's use or misuse - this software is without warranty.
- ***************************************************************************
- * File Description: Unwinding client that runs on PC with a target memory
- *   image to allow debugging.  The target memory image must be present
- *   in two files, memlow.dat and memhigh.dat.  These can be created by
- *   loading a target image into a debugger such as ARMSD, and then dumping
- *   the memory with a command such as the following:
- *
- *       PU memlow.dat 0,0xfffff
- *       PU memhigh.dat 0x7ff60000,+0xffffff
- *
- *   The SP and PC values at which unwinding should start also need to
- *   recorded and copied to UnwindStart() in unwarminder.c to then allow
- *   unwinding to start with the saved data.
- *
- *   Conventionally the code will be in the low area of memory, with the
- *   stack data in the high area.  If this is not the case for the system
- *   being inspected, the address ranges may need to be changed to
- *   accommodate the memory map being emulated, in which case SimClientInit()
- *   will also need changing such that memLowOffset and memHighOffset are
- *   set to values that match the image dump.
- **************************************************************************/
-
-/***************************************************************************
- * Includes
- ***************************************************************************/
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include "system.h"
-#include "simclient.h"
-
-/***************************************************************************
- * Prototypes
- ***************************************************************************/
-
-Boolean CliReport(void *data, Int32 address);
-Boolean CliReadW(Int32 a, Int32 *v);
-Boolean CliReadH(Int32 a, Int16 *v);
-Boolean CliReadB(Int32 a, Int8  *v);
-Boolean CliWriteW(Int32 a, Int32 v);
-Boolean CliInvalidateW(Int32 a);
-
-/***************************************************************************
- * Variables
- ***************************************************************************/
-
-/* Variables for simulating the memory system of the target */
-static FILE          *memLow, *memHigh;
-static unsigned long  memLowOffset, memHighOffset;
-static Boolean        memInit = FALSE;
-
-/* Call back functions to be used by the unwinder */
-const UnwindCallbacks cliCallbacks =
-    {
-        CliReport,
-        CliReadW,
-        CliReadH,
-        CliReadB
-#if defined(UNW_DEBUG)
-       ,printf
-#endif
-    };
-
-/***************************************************************************
- * Functions
- ***************************************************************************/
-
-/***************************************************************************
- *
- * Function:     SimClientRead
- *
- * Parameters:   address  - The memory address to read.
- *               len      - The number of bytes to read.
- *               dest     - Pointer to the address to populate with read
- *                           value.
- *
- * Returns:      TRUE if the read succeeded, otherwise FALSE.
- *
- * Description:  Reads from the simulated memory by fseek()ing to the
- *                required place in the file that contains the memory image
- *                for the sought address, and then reads the required number
- *                of bytes.  This function performs no alignment checks or
- *                endian swapping, and assumes that the target ARM is
- *                little endian, and that the PC is x86 architecture.
- ***************************************************************************/
-Boolean SimClientRead(Int32 address, Int8 len, void *dest)
-{
-    FILE * f;
-
-    if(address >= memHighOffset)
-    {
-        address -= memHighOffset;
-        f       = memHigh;
-    }
-    else
-    {
-        address -= memLowOffset;
-        f       = memLow;
-    }
-
-    if(fseek(f, address, SEEK_SET))
-    {
-        perror("fseek() failed: ");
-    }
-
-    printf("Read 0x%lx %s\n", ftell(f), f == memHigh ? "H" : "L");
-
-    memset(dest, 0, len);
-    if(fread(dest, len, 1, f) != 1)
-    {
-        perror("fread() failed: ");
-        return FALSE;
-    }
-
-    return TRUE;
-}
-
-
-/***************************************************************************
- *
- * Function:     SimClientInit
- *
- * Parameters:   none
- *
- * Returns:      nothing
- *
- * Description:  Initialises the emulated memory image if not already
- *                 initialised.  This involves opening the two input files
- *                 and setting the offset values as appropriate.
- ***************************************************************************/
-void SimClientInit()
-{
-    if(memInit) return;
-
-    memLow  = fopen("memlow.dat", "rb");
-    if(!memLow)
-    {
-        perror("Failed to open memlow.dat: ");
-        exit(EXIT_FAILURE);
-    }
-    memLowOffset = 0;   /* Value may need changing depending */
-
-    memHigh = fopen("memhigh.dat", "rb");
-    if(!memHigh)
-    {
-        perror("Failed to open memhigh.dat: ");
-        exit(EXIT_FAILURE);
-    }
-    memHighOffset = 0x7ff60000;
-
-    memInit = TRUE;
-}
-
-/***************************************************************************
- * Callback functions
- ***************************************************************************/
-
-/***************************************************************************
- *
- * Function:     CliReport
- *
- * Parameters:   data    - Pointer to data passed to UnwindStart()
- *               address - The return address of a stack frame.
- *
- * Returns:      TRUE if unwinding should continue, otherwise FALSE to
- *                 indicate that unwinding should stop.
- *
- * Description:  This function is called from the unwinder each time a stack
- *                 frame has been unwound.  The LSB of address indicates if
- *                 the processor is in ARM mode (LSB clear) or Thumb (LSB
- *                 set).
- *
- ***************************************************************************/
-Boolean CliReport(void *data, Int32 address)
-{
-    CliStack *s = (CliStack *)data;
-
-    printf("\nCliReport: 0x%08x\n", address);
-
-    s->address[s->frameCount] = address;
-    s->frameCount++;
-
-    if(s->frameCount >= (sizeof(s->address) / sizeof(s->address[0])))
-    {
-        return FALSE;
-    }
-    else
-    {
-        return TRUE;
-    }
-}
-
-Boolean CliReadW(const Int32 a, Int32 *v)
-{
-    SimClientInit();
-    return SimClientRead(a, 4, v);
-}
-
-Boolean CliReadH(const Int32 a, Int16 *v)
-{
-    SimClientInit();
-    return SimClientRead(a, 2, v);
-}
-
-Boolean CliReadB(const Int32 a, Int8 *v)
-{
-    SimClientInit();
-    return SimClientRead(a, 1, v);
-}
-
-
-int main()
-{
-    CliStack  results;
-    Int8      t;
-    UnwResult r;
-
-    (results).frameCount = 0;
-    /* SP value is filled by UnwindStart for the sim client */
-    r = UnwindStart(0, &cliCallbacks, &results);
-
-    for(t = 0; t < (results).frameCount; t++)
-    {
-        printf("%c: 0x%08x\n",
-               (results.address[t] & 0x1) ? 'T' : 'A',
-               results.address[t] & (~0x1));
-    }
-
-    printf("\nResult: %d\n", r);
-
-    exit(EXIT_SUCCESS);
-}
-
-
-/* END OF FILE */
diff --git a/src/crash-stack/wind/simclient.h b/src/crash-stack/wind/simclient.h
deleted file mode 100644
index f5d7d13..0000000
--- a/src/crash-stack/wind/simclient.h
+++ /dev/null
@@ -1,52 +0,0 @@
-/***************************************************************************
- * ARM Stack Unwinder, Michael.McTernan.2001@cs.bris.ac.uk
- *
- * This program is PUBLIC DOMAIN.
- * This means that there is no copyright and anyone is able to take a copy
- * for free and use it as they wish, with or without modifications, and in
- * any context, commercially or otherwise. The only limitation is that I
- * don't guarantee that the software is fit for any purpose or accept any
- * liability for it's use or misuse - this software is without warranty.
- ***************************************************************************
- * File Description:  Unwinding client that runs on PC with a target memory
- *                      image to allow debugging.
- **************************************************************************/
-
-#ifndef CLIENT_H
-#define CLIENT_H
-
-/***************************************************************************
- * Nested Includes
- ***************************************************************************/
-
-#include <stdio.h>
-#include "unwarminder.h"
-
-/***************************************************************************
- * Types
- ***************************************************************************/
-
-/** Example structure for holding unwind results.
- */
-typedef struct
-{
-    /** Count of frames unwound. */
-    Int16 frameCount;
-
-    /** Storage for the return address from each stack frame.
-     * Upto 32 frames will be unwound before unwinding is stopped.
-     */
-    Int32 address[32];
-}
-CliStack;
-
-
-/***************************************************************************
- * Global Variables
- ***************************************************************************/
-
-extern const UnwindCallbacks cliCallbacks;
-
-#endif
-
-/* END OF FILE */
diff --git a/src/crash-stack/wind/simplefunc.c b/src/crash-stack/wind/simplefunc.c
deleted file mode 100644
index 6350c32..0000000
--- a/src/crash-stack/wind/simplefunc.c
+++ /dev/null
@@ -1,176 +0,0 @@
-/***************************************************************************
- * ARM Stack Unwinder, Michael.McTernan.2001@cs.bris.ac.uk
- *
- * This program is PUBLIC DOMAIN.
- * This means that there is no copyright and anyone is able to take a copy
- * for free and use it as they wish, with or without modifications, and in
- * any context, commercially or otherwise. The only limitation is that I
- * don't guarantee that the software is fit for any purpose or accept any
- * liability for it's use or misuse - this software is without warranty.
- ***************************************************************************
- * File Description:  Specially constructed functions to test the unwinder.
- *   This file contains a mishmash of functions that compile in interesting
- *   ways at various levels of optimisation.  The functions call each
- *   other to nest in order to produce a stack that can then be unwound.
- **************************************************************************/
-
-#include <stdio.h>
-#include "client.h"
-
-void testShellSort(void *,int a, int b);
-void tailCall(int v);
-
-void viaFuncPointer(void)
-{
-    printf("Func pointer func");
-    tailCall(5);
-}
-
-
-typedef void (*fPoint)(void);
-
-static fPoint runFunc = viaFuncPointer;
-
-
-
-void wind()
-{
-  UNWIND();
-}
-
-void tailFunc(int v)
-{
-    int t[10], u;
-
-    for(u = 0; u < 10; u++)
-    {
-        t[u] = u;
-    }
-
-    printf("%d %d", v, t[9]);
-
-    t[u] += v;
-}
-
-void tailCall(int v)
-{
-    v *= v;
-
-    wind();
-
-    printf("%d", v);
-    tailFunc(v);
-}
-
-
-int testStackResize(void)
-{
-    char biggie[0x81111];
-    char *c = biggie;
-    int  t;
-
-    sprintf(biggie, "Hello");
-
-    t = 0;
-
-    while(*c)
-    {
-        t += *c;
-        c++;
-    }
-
-    runFunc();
-    return t;
-}
-
-
-int testConst()
-{
-    const int t = 5;
-    int vals[5] = { 1, 2, 3, 4, 5 };
-
-    printf("vals = %x\n %d", *vals, t);
-
-
-    return testStackResize();
-}
-
-int testRecurse(int t)
-{
-    if(t > 0)
-        return t + testRecurse(t - 1);
-    else
-    {
-        return testConst();
-    }
-}
-
-#pragma push
-#pragma thumb
-void testThumb1(int v)
-{
-    v += 1;
-    v *=  2;
-
-    printf("v1 = %d\n",v);
-
-    testRecurse(4);
-}
-
-
-#pragma arm
-void testArm1(int v)
-{
-    v += 4;
-    v /=  2;
-
-    printf("v = %d\n",v);
-
-    testThumb1(v);
-}
-
-
-#pragma thumb
-void testThumb(int v)
-{
-    v += 15;
-    v *=  2;
-
-    printf("v = %d\n",v);
-
-    testArm1(v);
-}
-
-
-#pragma arm
-
-void testArm(int v)
-{
-    v += 1;
-    v *=  2;
-
-    printf("v = %d\n",v);
-
-    testThumb(v);
-}
-
-#pragma pop
-
-int testPrintf(int t)
-{
-    printf("hello world %d\n", t);
-    testArm(1);
-
-    return t + 1;
-}
-
-
-void testVoid(void)
-{
-    testPrintf(5);
-}
-
-main()
-{
-    testVoid();
-}
diff --git a/src/crash-stack/wind/system.h b/src/crash-stack/wind/system.h
deleted file mode 100644
index 54a1b05..0000000
--- a/src/crash-stack/wind/system.h
+++ /dev/null
@@ -1,36 +0,0 @@
-/***************************************************************************
- * ARM Stack Unwinder, Michael.McTernan.2001@cs.bris.ac.uk
- *
- * This program is PUBLIC DOMAIN.
- * This means that there is no copyright and anyone is able to take a copy
- * for free and use it as they wish, with or without modifications, and in
- * any context, commercially or otherwise. The only limitation is that I
- * don't guarantee that the software is fit for any purpose or accept any
- * liability for it's use or misuse - this software is without warranty.
- **************************************************************************/
-/** \file
- * Types common across the whole system.
- **************************************************************************/
-
-#ifndef SYSTEM_H
-#define SYSTEM_H
-
-typedef unsigned char   Int8;
-typedef unsigned short  Int16;
-typedef unsigned int    Int32;
-
-
-typedef signed char     SignedInt8;
-typedef signed short    SignedInt16;
-typedef signed int      SignedInt32;
-
-
-typedef enum
-{
-    FALSE,
-    TRUE
-} Boolean;
-
-#endif
-
-/* END OF FILE */
diff --git a/src/crash-stack/wind/unwarm.c b/src/crash-stack/wind/unwarm.c
deleted file mode 100644
index cdfc882..0000000
--- a/src/crash-stack/wind/unwarm.c
+++ /dev/null
@@ -1,195 +0,0 @@
-/***************************************************************************
- * ARM Stack Unwinder, Michael.McTernan.2001@cs.bris.ac.uk
- *
- * This program is PUBLIC DOMAIN.
- * This means that there is no copyright and anyone is able to take a copy
- * for free and use it as they wish, with or without modifications, and in
- * any context, commercially or otherwise. The only limitation is that I
- * don't guarantee that the software is fit for any purpose or accept any
- * liability for it's use or misuse - this software is without warranty.
- ***************************************************************************
- * File Description: Utility functions and glue for ARM unwinding sub-modules.
- **************************************************************************/
-
-#define MODULE_NAME "UNWARM"
-
-/***************************************************************************
- * Include Files
- **************************************************************************/
-
-#include "system.h"
-#if defined(UPGRADE_ARM_STACK_UNWIND)
-#include <stdio.h>
-#include <stdarg.h>
-#include <string.h>
-#include "unwarm.h"
-#include "unwarmmem.h"
-
-/***************************************************************************
- * Manifest Constants
- **************************************************************************/
-
-
-/***************************************************************************
- * Type Definitions
- **************************************************************************/
-
-
-/***************************************************************************
- * Variables
- **************************************************************************/
-
-
-/***************************************************************************
- * Macros
- **************************************************************************/
-
-
-/***************************************************************************
- * Local Functions
- **************************************************************************/
-
-
-/***************************************************************************
- * Global Functions
- **************************************************************************/
-
-#if defined(UNW_DEBUG)
-/** Printf wrapper.
- * This is used such that alternative outputs for any output can be selected
- * by modification of this wrapper function.
- */
-void UnwPrintf(const char *format, ...)
-{
-    va_list args;
-
-    va_start( args, format );
-    vprintf(format, args );
-}
-#endif
-
-Boolean UnwIsAddrThumb (Int32 pc, Int32 spsr)
-{
-  return (pc & 0x1) != 0 || (spsr & 0x20) != 0;
-}
-
-/** Invalidate all general purpose registers.
- */
-void UnwInvalidateRegisterFile(RegData *regFile)
-{
-    Int8 t = 0;
-
-    do
-    {
-        regFile[t].o = REG_VAL_INVALID;
-        t++;
-    }
-    while(t < 13);
-
-}
-
-
-/** Initialise the data used for unwinding.
- */
-void UnwInitState(UnwState * const       state,   /**< Pointer to structure to fill. */
-                  const UnwindCallbacks *cb,      /**< Callbacks. */
-                  void                  *rptData, /**< Data to pass to report function. */
-                  Int32                  pcValue, /**< PC at which to start unwinding. */
-                  Int32                  spValue) /**< SP at which to start unwinding. */
-{
-    UnwInvalidateRegisterFile(state->regData);
-
-    /* Store the pointer to the callbacks */
-    state->cb = cb;
-    state->reportData = rptData;
-
-    /* Setup the SP and PC */
-    state->regData[13].v = spValue;
-    state->regData[13].o = REG_VAL_FROM_CONST;
-    state->regData[15].v = pcValue;
-    state->regData[15].o = REG_VAL_FROM_CONST;
-
-    UnwPrintd3("\nInitial: PC=0x%08x SP=0x%08x\n", pcValue, spValue);
-
-    /* Invalidate all memory addresses */
-    memset(state->memData.used, 0, sizeof(state->memData.used));
-    memset(state->branchData.used, 0, sizeof(state->branchData.used));
-
-    state->lastReported = 0;
-}
-
-
-/** Call the report function to indicate some return address.
- * This returns the value of the report function, which if TRUE
- * indicates that unwinding may continue.
- */
-Boolean UnwReportRetAddr(UnwState * const state, Int32 addr)
-{
-    state->lastReported = addr;
-    /* Cast away const from reportData.
-     *  The const is only to prevent the unw module modifying the data.
-     */
-    return state->cb->report((void *)state->reportData, addr);
-}
-
-
-/** Write some register to memory.
- * This will store some register and meta data onto the virtual stack.
- * The address for the write
- * \param state [in/out]  The unwinding state.
- * \param wAddr [in]  The address at which to write the data.
- * \param reg   [in]  The register to store.
- * \return TRUE if the write was successful, FALSE otherwise.
- */
-Boolean UnwMemWriteRegister(UnwState * const      state,
-                            const Int32           addr,
-                            const RegData * const reg)
-{
-    return UnwMemHashWrite(&state->memData,
-                           addr,
-                           reg->v,
-                           M_IsOriginValid(reg->o));
-}
-
-/** Read a register from memory.
- * This will read a register from memory, and setup the meta data.
- * If the register has been previously written to memory using
- * UnwMemWriteRegister, the local hash will be used to return the
- * value while respecting whether the data was valid or not.  If the
- * register was previously written and was invalid at that point,
- * REG_VAL_INVALID will be returned in *reg.
- * \param state [in]  The unwinding state.
- * \param addr  [in]  The address to read.
- * \param reg   [out] The result, containing the data value and the origin
- *                     which will be REG_VAL_FROM_MEMORY, or REG_VAL_INVALID.
- * \return TRUE if the address could be read and *reg has been filled in.
- *         FALSE is the data could not be read.
- */
-Boolean UnwMemReadRegister(UnwState * const      state,
-                           const Int32           addr,
-                           RegData * const       reg)
-{
-    Boolean tracked;
-
-    /* Check if the value can be found in the hash */
-    if(UnwMemHashRead(&state->memData, addr, &reg->v, &tracked))
-    {
-        reg->o = tracked ? REG_VAL_FROM_MEMORY : REG_VAL_INVALID;
-        return TRUE;
-    }
-    /* Not in the hash, so read from real memory */
-    else if(state->cb->readW(addr, &reg->v))
-    {
-        reg->o = REG_VAL_FROM_MEMORY;
-        return TRUE;
-    }
-    /* Not in the hash, and failed to read from memory */
-    else
-    {
-        return FALSE;
-    }
-}
-
-#endif /* UPGRADE_ARM_STACK_UNWIND */
-
-/* END OF FILE */
diff --git a/src/crash-stack/wind/unwarm.h b/src/crash-stack/wind/unwarm.h
deleted file mode 100644
index 5cff863..0000000
--- a/src/crash-stack/wind/unwarm.h
+++ /dev/null
@@ -1,196 +0,0 @@
-/***************************************************************************
- * ARM Stack Unwinder, Michael.McTernan.2001@cs.bris.ac.uk
- *
- * This program is PUBLIC DOMAIN.
- * This means that there is no copyright and anyone is able to take a copy
- * for free and use it as they wish, with or without modifications, and in
- * any context, commerically or otherwise. The only limitation is that I
- * don't guarantee that the software is fit for any purpose or accept any
- * liablity for it's use or misuse - this software is without warranty.
- ***************************************************************************
- * File Description: Internal interface between the ARM unwinding sub-modules.
- **************************************************************************/
-
-#ifndef UNWARM_H
-#define UNWARM_H
-
-/***************************************************************************
- * Nested Include Files
- **************************************************************************/
-
-#include "system.h"
-#if defined(UPGRADE_ARM_STACK_UNWIND)
-#include "unwarminder.h"
-
-/***************************************************************************
- * Manifest Constants
- **************************************************************************/
-
-/** The maximum number of instructions to interpet in a function.
- * Unwinding will be unconditionally stopped and UNWIND_EXHAUSTED returned
- * if more than this number of instructions are interpreted in a single
- * function without unwinding a stack frame.  This prevents infinite loops
- * or corrupted program memory from preventing unwinding from progressing.
- */
-#define UNW_MAX_INSTR_COUNT 200
-
-/** The size of the hash used to track reads and writes to memory.
- * This should be a prime value for efficiency.
- */
-#define MEM_HASH_SIZE        31
-
-/***************************************************************************
- * Type Definitions
- **************************************************************************/
-
-typedef enum
-{
-    /** Invalid value. */
-    REG_VAL_INVALID      = 0x00,
-    REG_VAL_FROM_STACK   = 0x01,
-    REG_VAL_FROM_MEMORY  = 0x02,
-    REG_VAL_FROM_CONST   = 0x04,
-    REG_VAL_ARITHMETIC   = 0x80
-}
-RegValOrigin;
-
-
-/** Type for tracking information about a register.
- * This stores the register value, as well as other data that helps unwinding.
- */
-typedef struct
-{
-    /** The value held in the register. */
-    Int32              v;
-
-    /** The origin of the register value.
-     * This is used to track how the value in the register was loaded.
-     */
-    RegValOrigin       o;
-}
-RegData;
-
-
-/** Structure used to track reads and writes to memory.
- * This structure is used as a hash to store a small number of writes
- * to memory.
- */
-typedef struct
-{
-    /** Memory contents. */
-    Int32              v[MEM_HASH_SIZE];
-
-    /** Address at which v[n] represents. */
-    Int32              a[MEM_HASH_SIZE];
-
-    /** Indicates whether the data in v[n] and a[n] is occupied.
-     * Each bit represents one hash value.
-     */
-    Int8               used[(MEM_HASH_SIZE + 7) / 8];
-
-    /** Indicates whether the data in v[n] is valid.
-     * This allows a[n] to be set, but for v[n] to be marked as invalid.
-     * Specifically this is needed for when an untracked register value
-     * is written to memory.
-     */
-    Int8               tracked[(MEM_HASH_SIZE + 7) / 8];
-}
-MemData;
-
-#define REGS_REGULAR_NUM 13
-#define REG_FP 11
-#define REG_IP 12
-#define REG_SP 13
-#define REG_LR 14
-#define REG_PC 15
-#define REG_SPSR 16
-
-/** Structure that is used to keep track of unwinding meta-data.
- * This data is passed between all the unwinding functions.
- */
-typedef struct
-{
-    /** The register values and meta-data. */
-    RegData regData[17];
-
-    /** Memory tracking data. */
-    MemData memData;
-
-    /** Branches tracking data. */
-    MemData branchData;
-
-    /** Pointer to the callback functions */
-    const UnwindCallbacks *cb;
-
-    /** Pointer to pass to the report function. */
-    const void *reportData;
-
-    /** Pointer to last reported function. */
-    Int32 lastReported;
-}
-UnwState;
-
-/***************************************************************************
- *  Macros
- **************************************************************************/
-
-#define M_IsOriginValid(v) (((v) & 0x7f) ? TRUE : FALSE)
-#define M_Origin2Str(v)    ((v) ? "VALID" : "INVALID")
-
-#if defined(UNW_DEBUG)
-#define UnwPrintd1(a)               state->cb->printf(a)
-#define UnwPrintd2(a,b)             state->cb->printf(a,b)
-#define UnwPrintd3(a,b,c)           state->cb->printf(a,b,c)
-#define UnwPrintd4(a,b,c,d)         state->cb->printf(a,b,c,d)
-#define UnwPrintd5(a,b,c,d,e)       state->cb->printf(a,b,c,d,e)
-#define UnwPrintd6(a,b,c,d,e,f)     state->cb->printf(a,b,c,d,e,f)
-#define UnwPrintd7(a,b,c,d,e,f,g)   state->cb->printf(a,b,c,d,e,f,g)
-#define UnwPrintd8(a,b,c,d,e,f,g,h) state->cb->printf(a,b,c,d,e,f,g,h)
-#else
-#define UnwPrintd1(a)
-#define UnwPrintd2(a,b)
-#define UnwPrintd3(a,b,c)
-#define UnwPrintd4(a,b,c,d)
-#define UnwPrintd5(a,b,c,d,e)
-#define UnwPrintd6(a,b,c,d,e,f)
-#define UnwPrintd7(a,b,c,d,e,f,g)
-#define UnwPrintd8(a,b,c,d,e,f,g,h)
-#endif
-
-/***************************************************************************
- *  Function Prototypes
- **************************************************************************/
-
-Boolean UnwIsAddrThumb (Int32 pc, Int32 spsr);
-
-UnwResult UnwStartArm       (UnwState * const state);
-
-UnwResult UnwStartThumb     (UnwState * const state);
-
-void UnwInvalidateRegisterFile(RegData *regFile);
-
-void UnwInitState           (UnwState * const       state,
-                             const UnwindCallbacks *cb,
-                             void                  *rptData,
-                             Int32                  pcValue,
-                             Int32                  spValue);
-
-Boolean UnwReportRetAddr    (UnwState * const state, Int32 addr);
-
-Boolean UnwMemWriteRegister (UnwState * const      state,
-                             const Int32           addr,
-                             const RegData * const reg);
-
-Boolean UnwMemReadRegister  (UnwState * const      state,
-                             const Int32           addr,
-                             RegData * const       reg);
-
-void    UnwMemHashGC        (UnwState * const state);
-
-#endif /* UPGRADE_ARM_STACK_UNWIND */
-
-#endif /* UNWARM_H */
-
-/* END OF FILE */
-
-
diff --git a/src/crash-stack/wind/unwarm_arm.c b/src/crash-stack/wind/unwarm_arm.c
deleted file mode 100644
index f1eab59..0000000
--- a/src/crash-stack/wind/unwarm_arm.c
+++ /dev/null
@@ -1,701 +0,0 @@
-/***************************************************************************
- * ARM Stack Unwinder, Michael.McTernan.2001@cs.bris.ac.uk
- *
- * This program is PUBLIC DOMAIN.
- * This means that there is no copyright and anyone is able to take a copy
- * for free and use it as they wish, with or without modifications, and in
- * any context, commercially or otherwise. The only limitation is that I
- * don't guarantee that the software is fit for any purpose or accept any
- * liability for it's use or misuse - this software is without warranty.
- ***************************************************************************
- * File Description: Abstract interpreter for ARM mode.
- **************************************************************************/
-
-#define MODULE_NAME "UNWARM_ARM"
-
-/***************************************************************************
- * Include Files
- **************************************************************************/
-
-#include "system.h"
-#if defined(UPGRADE_ARM_STACK_UNWIND)
-#include <stdio.h>
-#include "unwarm.h"
-
-/***************************************************************************
- * Manifest Constants
- **************************************************************************/
-
-
-/***************************************************************************
- * Type Definitions
- **************************************************************************/
-
-
-/***************************************************************************
- * Variables
- **************************************************************************/
-
-
-/***************************************************************************
- * Macros
- **************************************************************************/
-
-
-/***************************************************************************
- * Local Functions
- **************************************************************************/
-
-/** Check if some instruction is a data-processing instruction.
- * Decodes the passed instruction, checks if it is a data-processing and
- * verifies that the parameters and operation really indicate a data-
- * processing instruction.  This is needed because some parts of the
- * instruction space under this instruction can be extended or represent
- * other operations such as MRS, MSR.
- *
- * \param[in] inst  The instruction word.
- * \retval TRUE  Further decoding of the instruction indicates that this is
- *                a valid data-processing instruction.
- * \retval FALSE This is not a data-processing instruction,
- */
-static Boolean isDataProc(Int32 instr)
-{
-    Int8         opcode = (instr & 0x01e00000) >> 21;
-    Boolean      S      = (instr & 0x00100000) ? TRUE : FALSE;
-
-    if((instr & 0xfc000000) != 0xe0000000)
-    {
-        return FALSE;
-    }
-    else if(!S && opcode >= 8 && opcode <= 11)
-    {
-        /* TST, TEQ, CMP and CMN all require S to be set */
-        return FALSE;
-    }
-    else
-    {
-        return TRUE;
-    }
-}
-
-/***************************************************************************
- * Global Functions
- **************************************************************************/
-
-
-UnwResult UnwStartArm(UnwState * const state)
-{
-    Boolean found = FALSE;
-    Int16   t = UNW_MAX_INSTR_COUNT;
-
-    do
-    {
-        Int32 instr;
-
-        /* Attempt to read the instruction */
-        if(!state->cb->readW(state->regData[15].v, &instr))
-        {
-            return UNWIND_IREAD_W_FAIL;
-        }
-
-        UnwPrintd4("A %x %x %08x:",
-                   state->regData[13].v, state->regData[15].v, instr);
-
-        /* Check that the PC is still on Arm alignment */
-        if(UnwIsAddrThumb(state->regData[REG_PC].v, state->regData[REG_SPSR].v))
-        {
-            UnwPrintd1("\nError: PC misalignment\n");
-            return UNWIND_INCONSISTENT;
-        }
-
-        /* Check that the SP and PC have not been invalidated */
-        if(!M_IsOriginValid(state->regData[13].o) || !M_IsOriginValid(state->regData[15].o))
-        {
-            UnwPrintd1("\nError: PC or SP invalidated\n");
-            return UNWIND_INCONSISTENT;
-        }
-
-        /* Branch and Exchange (BX)
-         *  This is tested prior to data processing to prevent
-         *  mis-interpretation as an invalid TEQ instruction.
-         */
-        if((instr & 0xfffffff0) == 0xe12fff10)
-        {
-            Int8 rn = instr & 0xf;
-
-            UnwPrintd4("BX r%d\t ; r%d %s\n", rn, rn, M_Origin2Str(state->regData[rn].o));
-
-            if(!M_IsOriginValid(state->regData[rn].o))
-            {
-                UnwPrintd1("\nUnwind failure: BX to untracked register\n");
-                return UNWIND_FAILURE;
-            }
-
-            /* Set the new PC value */
-            state->regData[15].v = state->regData[rn].v;
-
-            /* Check if the return value is from the stack */
-            if(state->regData[rn].o == REG_VAL_FROM_STACK)
-            {
-                /* Now have the return address */
-                UnwPrintd2(" Return PC=%x\n", state->regData[15].v & (~0x1));
-
-                /* Report the return address */
-                if(!UnwReportRetAddr(state, state->regData[rn].v))
-                {
-                    return UNWIND_TRUNCATED;
-                }
-            }
-
-            /* Determine the return mode */
-            if(UnwIsAddrThumb(state->regData[rn].v, state->regData[REG_SPSR].v))
-            {
-                /* Branching to THUMB */
-                return UnwStartThumb(state);
-            }
-            else
-            {
-                /* Branch to ARM */
-
-                /* Account for the auto-increment which isn't needed */
-                state->regData[15].v -= 4;
-            }
-        }
-        /* Branch */
-        else if((instr & 0xff000000) == 0xea000000)
-        {
-            SignedInt32 offset = (instr & 0x00ffffff);
-
-            /* Shift value */
-            offset = offset << 2;
-
-            /* Sign extend if needed */
-            if(offset & 0x02000000)
-            {
-                offset |= 0xfc000000;
-            }
-
-            UnwPrintd2("B %d\n", offset);
-
-            /* Adjust PC */
-            state->regData[15].v += offset;
-
-            /* Account for pre-fetch, where normally the PC is 8 bytes
-             *  ahead of the instruction just executed.
-             */
-            state->regData[15].v += 4;
-
-        }
-        /* MRS */
-        else if((instr & 0xffbf0fff) == 0xe10f0000)
-        {
-#if defined(UNW_DEBUG)
-            Boolean      R        = (instr & 0x00400000) ? TRUE : FALSE;
-#endif
-            Int8         rd       = (instr & 0x0000f000) >> 12;
-
-            UnwPrintd4("MRS r%d,%s\t; r%d invalidated", rd, R ? "SPSR" : "CPSR", rd);
-
-            /* Status registers untracked */
-            state->regData[rd].o = REG_VAL_INVALID;
-        }
-        /* MSR */
-        else if((instr & 0xffb0f000) == 0xe120f000)
-        {
-#if defined(UNW_DEBUG)
-            Boolean      R        = (instr & 0x00400000) ? TRUE : FALSE;
-
-            UnwPrintd2("MSR %s_?, ???", R ? "SPSR" : "CPSR");
-#endif
-            /* Status registers untracked.
-             *  Potentially this could change processor mode and switch
-             *  banked registers r8-r14.  Most likely is that r13 (sp) will
-             *  be banked.  However, invalidating r13 will stop unwinding
-             *  when potentially this write is being used to disable/enable
-             *  interrupts (a common case).  Therefore no invalidation is
-             *  performed.
-             */
-        }
-        /* Data processing */
-        else if(isDataProc(instr))
-        {
-            Boolean      I        = (instr & 0x02000000) ? TRUE : FALSE;
-            Int8         opcode   = (instr & 0x01e00000) >> 21;
-#if defined(UNW_DEBUG)
-            Boolean      S        = (instr & 0x00100000) ? TRUE : FALSE;
-#endif
-            Int8         rn       = (instr & 0x000f0000) >> 16;
-            Int8         rd       = (instr & 0x0000f000) >> 12;
-            Int16        operand2 = (instr & 0x00000fff);
-            Int32        op2val;
-            RegValOrigin op2origin;
-
-            switch(opcode)
-            {
-                case  0: UnwPrintd4("AND%s r%d,r%d,", S ? "S" : "", rd, rn); break;
-                case  1: UnwPrintd4("EOR%s r%d,r%d,", S ? "S" : "", rd, rn); break;
-                case  2: UnwPrintd4("SUB%s r%d,r%d,", S ? "S" : "", rd, rn); break;
-                case  3: UnwPrintd4("RSB%s r%d,r%d,", S ? "S" : "", rd, rn); break;
-                case  4: UnwPrintd4("ADD%s r%d,r%d,", S ? "S" : "", rd, rn); break;
-                case  5: UnwPrintd4("ADC%s r%d,r%d,", S ? "S" : "", rd, rn); break;
-                case  6: UnwPrintd4("SBC%s r%d,r%d,", S ? "S" : "", rd, rn); break;
-                case  7: UnwPrintd4("RSC%s r%d,r%d,", S ? "S" : "", rd, rn); break;
-                case  8: UnwPrintd3("TST%s r%d,", S ? "S" : "", rn); break;
-                case  9: UnwPrintd3("TEQ%s r%d,", S ? "S" : "", rn); break;
-                case 10: UnwPrintd3("CMP%s r%d,", S ? "S" : "", rn); break;
-                case 11: UnwPrintd3("CMN%s r%d,", S ? "S" : "", rn); break;
-                case 12: UnwPrintd3("ORR%s r%d,", S ? "S" : "", rn); break;
-                case 13: UnwPrintd3("MOV%s r%d,", S ? "S" : "", rd); break;
-                case 14: UnwPrintd4("BIC%s r%d,r%d", S ? "S" : "", rd, rn); break;
-                case 15: UnwPrintd3("MVN%s r%d,", S ? "S" : "", rd); break;
-            }
-
-            /* Decode operand 2 */
-            if(I)
-            {
-                Int8 shiftDist  = (operand2 & 0x0f00) >> 8;
-                Int8 shiftConst = (operand2 & 0x00ff);
-
-                /* rotate const right by 2 * shiftDist */
-                shiftDist *= 2;
-                op2val    = (shiftConst >> shiftDist) |
-                            (shiftConst << (32 - shiftDist));
-                op2origin = REG_VAL_FROM_CONST;
-
-                UnwPrintd2("#0x%x", op2val);
-            }
-            else
-            {
-                /* Register and shift */
-                Int8  rm        = (operand2 & 0x000f);
-                Int8  regShift  = (operand2 & 0x0010) ? TRUE : FALSE;
-                Int8  shiftType = (operand2 & 0x0060) >> 5;
-                Int32 shiftDist;
-#if defined(UNW_DEBUG)
-                const char * const shiftMnu[4] = { "LSL", "LSR", "ASR", "ROR" };
-#endif
-                UnwPrintd2("r%d ", rm);
-
-                /* Get the shift distance */
-                if(regShift)
-                {
-                    Int8 rs = (operand2 & 0x0f00) >> 8;
-
-                    if(operand2 & 0x00800)
-                    {
-                        UnwPrintd1("\nError: Bit should be zero\n");
-                        return UNWIND_ILLEGAL_INSTR;
-                    }
-                    else if(rs == 15)
-                    {
-                        UnwPrintd1("\nError: Cannot use R15 with register shift\n");
-                        return UNWIND_ILLEGAL_INSTR;
-                    }
-
-                    /* Get shift distance */
-                    shiftDist = state->regData[rs].v;
-                    op2origin = state->regData[rs].o;
-
-                    UnwPrintd7("%s r%d\t; r%d %s r%d %s",
-                          shiftMnu[shiftType], rs,
-                          rm, M_Origin2Str(state->regData[rm].o),
-                          rs, M_Origin2Str(state->regData[rs].o));
-                }
-                else
-                {
-                    shiftDist  = (operand2 & 0x0f80) >> 7;
-                    op2origin = REG_VAL_FROM_CONST;
-
-                    if(shiftDist)
-                    {
-                        UnwPrintd3("%s #%d",
-                                   shiftMnu[shiftType], shiftDist);
-                    }
-                    UnwPrintd3("\t; r%d %s", rm, M_Origin2Str(state->regData[rm].o));
-
-                }
-
-                /* Apply the shift type to the source register */
-                switch(shiftType)
-                {
-                    case 0: /* logical left */
-                        op2val = state->regData[rm].v << shiftDist;
-                        break;
-                    case 1: /* logical right */
-
-                        if(!regShift && shiftDist == 0)
-                        {
-                            shiftDist = 32;
-                        }
-
-                        op2val = state->regData[rm].v >> shiftDist;
-                        break;
-                    case 2: /* arithmetic right */
-
-                        if(!regShift && shiftDist == 0)
-                        {
-                            shiftDist = 32;
-                        }
-
-                        if(state->regData[rm].v & 0x80000000)
-                        {
-                            /* Register shifts maybe greater than 32 */
-                            if(shiftDist >= 32)
-                            {
-                                op2val = 0xffffffff;
-                            }
-                            else
-                            {
-                                op2val = state->regData[rm].v >> shiftDist;
-                                op2val |= 0xffffffff << (32 - shiftDist);
-                            }
-                        }
-                        else
-                        {
-                            op2val = state->regData[rm].v >> shiftDist;
-                        }
-                        break;
-                    case 3: /* rotate right */
-
-                        if(!regShift && shiftDist == 0)
-                        {
-                            /* Rotate right with extend.
-                             *  This uses the carry bit and so always has an
-                             *  untracked result.
-                             */
-                            op2origin = REG_VAL_INVALID;
-                            op2val    = 0;
-                        }
-                        else
-                        {
-                            /* Limit shift distance to 0-31 incase of register shift */
-                            shiftDist &= 0x1f;
-
-                            op2val = (state->regData[rm].v >> shiftDist) |
-                                     (state->regData[rm].v << (32 - shiftDist));
-                        }
-                        break;
-
-                    default:
-                        UnwPrintd2("\nError: Invalid shift type: %d\n", shiftType);
-                        return UNWIND_FAILURE;
-                }
-
-                /* Decide the data origin */
-                if(M_IsOriginValid(op2origin) &&
-                   M_IsOriginValid(state->regData[rm].o))
-                {
-                    op2origin = state->regData[rm].o;
-                    op2origin |= REG_VAL_ARITHMETIC;
-                }
-                else
-                {
-                    op2origin = REG_VAL_INVALID;
-                }
-
-            }
-
-            /* Propagate register validity */
-            switch(opcode)
-            {
-                case  0: /* AND: Rd := Op1 AND Op2 */
-                case  1: /* EOR: Rd := Op1 EOR Op2 */
-                case  2: /* SUB: Rd:= Op1 - Op2 */
-                case  3: /* RSB: Rd:= Op2 - Op1 */
-                case  4: /* ADD: Rd:= Op1 + Op2 */
-                case 12: /* ORR: Rd:= Op1 OR Op2 */
-                case 14: /* BIC: Rd:= Op1 AND NOT Op2 */
-                    if(!M_IsOriginValid(state->regData[rn].o) ||
-                       !M_IsOriginValid(op2origin))
-                    {
-                        state->regData[rd].o = REG_VAL_INVALID;
-                    }
-                    else
-                    {
-                        state->regData[rd].o = state->regData[rn].o;
-                        state->regData[rd].o |= op2origin;
-                    }
-                    break;
-                case  5: /* ADC: Rd:= Op1 + Op2 + C */
-                case  6: /* SBC: Rd:= Op1 - Op2 + C */
-                case  7: /* RSC: Rd:= Op2 - Op1 + C */
-                    /* CPSR is not tracked */
-                    state->regData[rd].o = REG_VAL_INVALID;
-                    break;
-
-                case  8: /* TST: set condition codes on Op1 AND Op2 */
-                case  9: /* TEQ: set condition codes on Op1 EOR Op2 */
-                case 10: /* CMP: set condition codes on Op1 - Op2 */
-                case 11: /* CMN: set condition codes on Op1 + Op2 */
-                    break;
-
-
-                case 13: /* MOV: Rd:= Op2 */
-                case 15: /* MVN: Rd:= NOT Op2 */
-                    state->regData[rd].o = op2origin;
-                    break;
-            }
-
-            /* Account for pre-fetch by temporarily adjusting PC */
-            if(rn == 15)
-            {
-                /* If the shift amount is specified in the instruction,
-                 *  the PC will be 8 bytes ahead. If a register is used
-                 *  to specify the shift amount the PC will be 12 bytes
-                 *  ahead.
-                 */
-                if(!I && (operand2 & 0x0010))
-                    state->regData[rn].v += 12;
-                else
-                    state->regData[rn].v += 8;
-            }
-
-            /* Compute values */
-            switch(opcode)
-            {
-                case  0: /* AND: Rd := Op1 AND Op2 */
-                    state->regData[rd].v = state->regData[rn].v & op2val;
-                    break;
-
-                case  1: /* EOR: Rd := Op1 EOR Op2 */
-                    state->regData[rd].v = state->regData[rn].v ^ op2val;
-                    break;
-
-                case  2: /* SUB: Rd:= Op1 - Op2 */
-                    state->regData[rd].v = state->regData[rn].v - op2val;
-                    break;
-                case  3: /* RSB: Rd:= Op2 - Op1 */
-                    state->regData[rd].v = op2val - state->regData[rn].v;
-                    break;
-
-                case  4: /* ADD: Rd:= Op1 + Op2 */
-                    state->regData[rd].v = state->regData[rn].v + op2val;
-                    break;
-
-                case  5: /* ADC: Rd:= Op1 + Op2 + C */
-                case  6: /* SBC: Rd:= Op1 - Op2 + C */
-                case  7: /* RSC: Rd:= Op2 - Op1 + C */
-                case  8: /* TST: set condition codes on Op1 AND Op2 */
-                case  9: /* TEQ: set condition codes on Op1 EOR Op2 */
-                case 10: /* CMP: set condition codes on Op1 - Op2 */
-                case 11: /* CMN: set condition codes on Op1 + Op2 */
-                    UnwPrintd1("\t; ????");
-                    break;
-
-                case 12: /* ORR: Rd:= Op1 OR Op2 */
-                    state->regData[rd].v = state->regData[rn].v | op2val;
-                    break;
-
-                case 13: /* MOV: Rd:= Op2 */
-                    state->regData[rd].v = op2val;
-                    break;
-
-                case 14: /* BIC: Rd:= Op1 AND NOT Op2 */
-                    state->regData[rd].v = state->regData[rn].v & (~op2val);
-                    break;
-
-                case 15: /* MVN: Rd:= NOT Op2 */
-                    state->regData[rd].v = ~op2val;
-                    break;
-            }
-
-            /* Remove the prefetch offset from the PC */
-            if(rd != 15 && rn == 15)
-            {
-                if(!I && (operand2 & 0x0010))
-                    state->regData[rn].v -= 12;
-                else
-                    state->regData[rn].v -= 8;
-            }
-
-        }
-        /* Block Data Transfer
-         *  LDM, STM
-         */
-        else if((instr & 0xfe000000) == 0xe8000000)
-        {
-            Boolean    P         = (instr & 0x01000000) ? TRUE : FALSE;
-            Boolean    U         = (instr & 0x00800000) ? TRUE : FALSE;
-            Boolean    S         = (instr & 0x00400000) ? TRUE : FALSE;
-            Boolean    W         = (instr & 0x00200000) ? TRUE : FALSE;
-            Boolean    L         = (instr & 0x00100000) ? TRUE : FALSE;
-            Int16      baseReg   = (instr & 0x000f0000) >> 16;
-            Int16      regList   = (instr & 0x0000ffff);
-            Int32      addr      = state->regData[baseReg].v;
-            Boolean    addrValid = M_IsOriginValid(state->regData[baseReg].o);
-            SignedInt8 r;
-
-#if defined(UNW_DEBUG)
-            /* Display the instruction */
-            if(L)
-            {
-                UnwPrintd6("LDM%c%c r%d%s, {reglist}%s\n",
-                           P ? 'E' : 'F',
-                           U ? 'D' : 'A',
-                           baseReg,
-                           W ? "!" : "",
-                           S ? "^" : "");
-            }
-            else
-            {
-                UnwPrintd6("STM%c%c r%d%s, {reglist}%s\n",
-                           !P ? 'E' : 'F',
-                           !U ? 'D' : 'A',
-                           baseReg,
-                           W ? "!" : "",
-                           S ? "^" : "");
-            }
-#endif
-            /* S indicates that banked registers (untracked) are used, unless
-             *  this is a load including the PC when the S-bit indicates that
-             *  that CPSR is loaded from SPSR (also untracked, but ignored).
-             */
-            if(S && (!L || (regList & (0x01 << 15)) == 0))
-            {
-                UnwPrintd1("\nError:S-bit set requiring banked registers\n");
-                return UNWIND_FAILURE;
-            }
-            else if(baseReg == 15)
-            {
-                UnwPrintd1("\nError: r15 used as base register\n");
-                return UNWIND_FAILURE;
-            }
-            else if(regList == 0)
-            {
-                UnwPrintd1("\nError: Register list empty\n");
-                return UNWIND_FAILURE;
-            }
-
-            /* Check if ascending or descending.
-             *  Registers are loaded/stored in order of address.
-             *  i.e. r0 is at the lowest address, r15 at the highest.
-             */
-            r = U ? 0 : 15;
-
-            do
-            {
-                /* Check if the register is to be transferred */
-                if(regList & (0x01 << r))
-                {
-                    if(P) addr += U ? 4 : -4;
-
-                    if(L)
-                    {
-                        if(addrValid)
-                        {
-                            if(!UnwMemReadRegister(state, addr, &state->regData[r]))
-                            {
-                                return UNWIND_DREAD_W_FAIL;
-                            }
-
-                            /* Update the origin if read via the stack pointer */
-                            if(M_IsOriginValid(state->regData[r].o) && baseReg == 13)
-                            {
-                                state->regData[r].o = REG_VAL_FROM_STACK;
-                            }
-
-                            UnwPrintd5(" R%d = 0x%08x\t; r%d %s\n",
-                                       r,
-                                       state->regData[r].v,
-                                       r,
-                                       M_Origin2Str(state->regData[r].o));
-                        }
-                        else
-                        {
-                            /* Invalidate the register as the base reg was invalid */
-                            state->regData[r].o = REG_VAL_INVALID;
-
-                            UnwPrintd2(" R%d = ???\n", r);
-                        }
-                    }
-                    else
-                    {
-                        if(addrValid)
-                        {
-                            if(!UnwMemWriteRegister(state, state->regData[13].v, &state->regData[r]))
-                            {
-                                return UNWIND_DWRITE_W_FAIL;
-                            }
-                        }
-
-                        UnwPrintd2(" R%d = 0x%08x\n", r);
-                    }
-
-                    if(!P) addr += U ? 4 : -4;
-                }
-
-                /* Check the next register */
-                r += U ? 1 : -1;
-            }
-            while(r >= 0 && r <= 15);
-
-            /* Check the writeback bit */
-            if(W) state->regData[baseReg].v = addr;
-
-            /* Check if the PC was loaded */
-            if(L && (regList & (0x01 << 15)))
-            {
-                if(!M_IsOriginValid(state->regData[15].o))
-                {
-                    /* Return address is not valid */
-                    UnwPrintd1("PC popped with invalid address\n");
-                    return UNWIND_FAILURE;
-                }
-                else
-                {
-                    /* Store the return address */
-                    if(!UnwReportRetAddr(state, state->regData[15].v))
-                    {
-                        return UNWIND_TRUNCATED;
-                    }
-
-                    UnwPrintd2("  Return PC=0x%x", state->regData[15].v);
-
-                    /* Determine the return mode */
-                    if(UnwIsAddrThumb(state->regData[REG_PC].v, state->regData[REG_SPSR].v))
-                    {
-                        /* Branching to THUMB */
-                        return UnwStartThumb(state);
-                    }
-                    else
-                    {
-                        /* Branch to ARM */
-
-                        /* Account for the auto-increment which isn't needed */
-                        state->regData[15].v -= 4;
-                    }
-                }
-            }
-        }
-        else
-        {
-            UnwPrintd1("????");
-
-            /* Unknown/undecoded.  May alter some register, so invalidate file */
-            UnwInvalidateRegisterFile(state->regData);
-        }
-
-        UnwPrintd1("\n");
-
-        /* Should never hit the reset vector */
-        if(state->regData[15].v == 0) return UNWIND_RESET;
-
-        /* Check next address */
-        state->regData[15].v += 4;
-
-        /* Garbage collect the memory hash (used only for the stack) */
-        UnwMemHashGC(state);
-
-        t--;
-        if(t == 0) return UNWIND_EXHAUSTED;
-
-    }
-    while(!found);
-
-    return UNWIND_UNSUPPORTED;
-}
-
-#endif /* UPGRADE_ARM_STACK_UNWIND */
-
-/* END OF FILE */
-
diff --git a/src/crash-stack/wind/unwarm_thumb.c b/src/crash-stack/wind/unwarm_thumb.c
deleted file mode 100644
index 6a26349..0000000
--- a/src/crash-stack/wind/unwarm_thumb.c
+++ /dev/null
@@ -1,1542 +0,0 @@
-/***************************************************************************
- * ARM Stack Unwinder, Michael.McTernan.2001@cs.bris.ac.uk
- *
- * This program is PUBLIC DOMAIN.
- * This means that there is no copyright and anyone is able to take a copy
- * for free and use it as they wish, with or without modifications, and in
- * any context, commercially or otherwise. The only limitation is that I
- * don't guarantee that the software is fit for any purpose or accept any
- * liability for it's use or misuse - this software is without warranty.
- ***************************************************************************
- * File Description: Abstract interpretation for Thumb mode.
- **************************************************************************/
-
-#define MODULE_NAME "UNWARM_THUMB"
-
-/***************************************************************************
- * Include Files
- **************************************************************************/
-
-#include "system.h"
-#if defined(UPGRADE_ARM_STACK_UNWIND)
-#include <stdio.h>
-#include "unwarm.h"
-#include "unwarmmem.h"
-
-/***************************************************************************
- * Manifest Constants
- **************************************************************************/
-
-
-/***************************************************************************
- * Type Definitions
- **************************************************************************/
-
-
-/***************************************************************************
- * Variables
- **************************************************************************/
-
-
-/***************************************************************************
- * Macros
- **************************************************************************/
-
-
-/***************************************************************************
- * Local Functions
- **************************************************************************/
-
-/** Sign extend an 11 bit value.
- * This function simply inspects bit 11 of the input \a value, and if
- * set, the top 5 bits are set to give a 2's compliment signed value.
- * \param value   The value to sign extend.
- * \return The signed-11 bit value stored in a 16bit data type.
- */
-static SignedInt16 signExtend11(Int16 value)
-{
-    if(value & 0x400)
-    {
-        value |= 0xf800;
-    }
-
-    return value;
-}
-
-static SignedInt16 signExtend8(Int16 value)
-{
-    if(value & 0x80)
-    {
-        value |= 0xff00;
-    }
-
-    return value;
-}
-
-/***************************************************************************
- * Global Functions
- **************************************************************************/
-
-static Int32 ThumbExpandImm (Int32 imm32)
-{
-    Int8 ab = (imm32 & (3 << 10)) >> 10;
-    Int8 cd = (imm32 & (3 << 8)) >> 8;
-    Int8 ror = (imm32 & (0x1F << 7)) >> 7;
-    Int32 nn = imm32 & 0xFF;
-    if (0 == ab)
-    {
-        switch (cd)
-        {
-            case 0: return nn;
-            case 1: return (nn << 16) | nn;
-            case 2: return (nn << 24) | (nn << 8);
-            case 3: return (nn << 24) | (nn << 16) | (nn << 8) | nn;
-        }
-    }
-    else
-    {
-        nn = nn | 0x80;
-        ror = 32 - ror;
-        return nn << ror;
-    }
-    return 0;
-}
-
-static UnwResult Unw32DataProcessingModifiedImmediate (UnwState * const state, Int16 instr, Int16 instr2)
-{
-    Int8 op = (instr & (0xF << 5)) >> 5;
-    Int8 Rn = instr & 0xF;
-    Int8 S = (instr & (1 << 4)) >> 4;
-    Int8 Rd = (instr2 & (0xF << 8)) >> 8;
-
-    switch (op)
-    {
-      case 0:
-          if (0xF==Rd)
-          {
-              if (0==S) return UNWIND_ILLEGAL_INSTR;
-
-              UnwPrintd1("TST ...\n");
-          }
-          else
-          {
-              state->regData[Rd].o = REG_VAL_INVALID;
-              UnwPrintd1("AND ...\n");
-          }
-          break;
-      case 1:
-          state->regData[Rd].o = REG_VAL_INVALID;
-          UnwPrintd1("BIC ...\n");
-          break;
-      case 2:
-          state->regData[Rd].o = REG_VAL_INVALID;
-          if (0xF != Rn)
-              UnwPrintd1("ORR ...\n");
-          else
-              UnwPrintd1("MOV ...\n");
-          break;
-      case 3:
-          if (0xF != Rn)
-          {
-              state->regData[Rd].o = REG_VAL_INVALID;
-              UnwPrintd1("ORN ...\n");
-          }
-          else
-              UnwPrintd1("MVN ...\n");
-          break;
-      case 4:
-          if (0xF != Rd)
-          {
-              UnwPrintd1("EOR ...\n");
-              state->regData[Rd].o = REG_VAL_INVALID;
-          }
-          else
-          {
-              if (0==S) return UNWIND_ILLEGAL_INSTR;
-
-              UnwPrintd1("TEQ ...\n");
-          }
-          break;
-      case 8:
-          if (0xF != Rd)
-          {
-              Int16 i = (instr & (1 << 10)) >> 10;
-              Int16 imm3 = (instr2 & (0x7 << 12)) >> 12;
-              Int16 imm8 = instr2 & 0xFF;
-              Int32 imm32 = imm8 | (imm3 << 8) | (i << 11);
-
-              imm32 = ThumbExpandImm (imm32);
-
-              UnwPrintd4("ADD r%d, r%d, #0x%x", Rd, Rn, imm32);
-              state->regData[Rd].v = state->regData[Rn].v + imm32;
-              state->regData[Rd].o = state->regData[Rn].o;
-          }
-          else
-          {
-              if (0==S) return UNWIND_ILLEGAL_INSTR;
-
-              UnwPrintd1("CMN ...\n");
-          }
-          break;
-      case 10:
-          state->regData[Rd].o = REG_VAL_INVALID;
-          UnwPrintd1("ADC ...\n");
-          break;
-      case 11:
-          state->regData[Rd].o = REG_VAL_INVALID;
-          UnwPrintd1("SBC ...\n");
-          break;
-      case 13:
-          if (0xF != Rd)
-          {
-              state->regData[Rd].o = REG_VAL_INVALID;
-              UnwPrintd1("SUB ...\n");
-          }
-          else
-          {
-              if (0==S) return UNWIND_ILLEGAL_INSTR;
-
-              UnwPrintd1("CMP ...\n");
-          }
-          break;
-      case 14:
-          state->regData[Rd].o = REG_VAL_INVALID;
-          UnwPrintd1("RSB ...\n");
-          break;
-      default:
-          return UNWIND_ILLEGAL_INSTR;
-    }
-    return UNWIND_SUCCESS;
-}
-
-static UnwResult Unw32LoadWord (UnwState * const state, Int16 instr, Int16 instr2)
-{
-    Int8 op1 = (instr & (0x3 << 7)) >> 7;
-    Int8 Rn = instr & 0xF;
-//    Int8 op2 = (instr2 & (0x3F << 6)) >> 6;
-
-    if (1 == op1 && 0xF != Rn)
-    {
-        /* LDR imm */
-        Int8 Rt = (instr2 & (0xF << 12)) >> 12;
-        Int32 imm12 = instr2 & 0xFFF;
-
-        UnwPrintd4("LDR r%d, [r%d, #0x%08x]", Rt, Rn, imm12);
-
-        imm12 += state->regData[Rn].v;
-
-        if (state->regData[Rn].o == REG_VAL_INVALID)
-        {
-            state->regData[Rt].o = REG_VAL_INVALID;
-        }
-        else
-        {
-          if(!UnwMemReadRegister(state, imm12, &state->regData[Rt]))
-          {
-              return UNWIND_DREAD_W_FAIL;
-          }
-        }
-    }
-    else if (0 == op1 && 0xF != Rn)
-    {
-        Int8 Rt = (instr2 & (0xF << 12)) >> 12;
-        Int32 imm8 = instr2 & 0xFF;
-        Int8 U = (instr2 & (1 << 9)) >> 9;
-        Int8 P = (instr2 & (1 << 10)) >> 10;
-        Int8 W = (instr2 & (1 << 8)) >> 8;
-        Int32 offset_addr;
-        Int32 addr;
-
-        UnwPrintd8("LDR r%d, [r%d%c,#%c0x%08x%c%c\n",
-            Rt, Rn,
-            P ? ' ' : ']',
-            U ? '+' : '-',
-            imm8,
-            P ? ']' : ' ',
-            W ? '!' : ' ');
-
-        if (state->regData[Rn].o == REG_VAL_INVALID)
-        {
-            state->regData[Rt].o = REG_VAL_INVALID;
-        }
-        else
-        {
-            offset_addr = state->regData[Rn].v + (U ? 1 : -1) * imm8;
-            addr = P ? offset_addr : state->regData[Rn].v;
-
-            if(!UnwMemReadRegister(state, addr, &state->regData[Rt]))
-            {
-                return UNWIND_DREAD_W_FAIL;
-            }
-
-            if (REG_SP == Rn)
-                state->regData[Rt].o = REG_VAL_FROM_STACK;
-
-            if (W)
-                state->regData[Rn].v = offset_addr;
-        }
-    }
-//            else if (op1 < 2 && 0xF == Rn)
-//            {
-      /* LDR literal */
-//            }
-    else
-    {
-      /* UNDEFINED */
-        UnwPrintd1("????");
-        UnwInvalidateRegisterFile(state->regData);
-    }
-    return UNWIND_SUCCESS;
-}
-static UnwResult Unw32LoadStoreMultiple (UnwState * const state, Int16 instr, Int16 instr2)
-{
-    Int8 op = (instr & (0x3 << 7)) >> 7;
-    Int8 L = (instr & (0x1 << 4)) >> 4;
-    Int8 Rn = instr & 0xF;
-
-    UnwResult res = UNWIND_SUCCESS;
-
-    switch (op)
-    {
-        case 0:
-            if (0 == L) UnwPrintd1("SRS ...");
-            else
-            {
-                state->regData[REG_PC].o = REG_VAL_INVALID;
-                UnwPrintd1("LRE ...");
-            }
-            break;
-        case 1:
-            {
-                Int8 bitCount = 0;
-                Int16 register_list = (instr2 & 0x7FFF);
-                int i;
-
-                for (i = 0; i < 15; i++)
-                {
-                    if ((register_list & (0x1 << i)) != 0) bitCount++;
-                }
-
-                if (0 == L)
-                {
-                    Int8 W = (instr & (0x1 << 5)) >> 5;
-                    if (W) state->regData[Rn].v += 4*bitCount;
-                    UnwPrintd1("STM ...");
-                }
-                else
-                {
-                    if (13 != Rn)
-                    {
-                        Int8 W = (instr & (0x1 << 5)) >> 5;
-                        for (i = 0; i < 15; i++)
-                        {
-                            if ((register_list & (0x1 << i)) != 0)
-                                state->regData[i].o = REG_VAL_INVALID;
-                        }
-                        if (W)
-                        {
-                            if ((register_list & (1 << Rn)) == 0)
-                                state->regData[Rn].v += 4*bitCount;
-                            else
-                                state->regData[Rn].o = REG_VAL_INVALID;
-                        }
-                        UnwPrintd1("LDM ...");
-                    }
-                    else
-                    {
-                        Boolean new_pc = FALSE;
-                        Boolean got_lr = FALSE;
-
-                        register_list = register_list | (instr2 & 0x8000);
-                        UnwPrintd1("POP {");
-                        for (i = 0; i < 16; i++)
-                        {
-                            if ((register_list & (0x1 << i)) != 0)
-                            {
-                                if (!UnwMemReadRegister(state,
-                                      state->regData[REG_SP].v,
-                                      &state->regData[i]))
-                                {
-                                  return UNWIND_DREAD_W_FAIL;
-                                }
-                                state->regData[i].o = REG_VAL_FROM_STACK;
-                                state->regData[REG_SP].v += 4;
-                                if (i < 13)
-                                    UnwPrintd2 ("r%d,", i);
-                                else if (REG_LR==i)
-                                {
-                                    UnwPrintd1 ("lr,");
-                                    got_lr = TRUE;
-                                }
-                                else if (REG_PC==i)
-                                {
-                                    UnwPrintd1 ("pc");
-                                    new_pc = TRUE;
-                                }
-                            }
-                        }
-                        UnwPrintd1("}");
-                        if (new_pc)
-                        {
-                            UnwPrintd2("\n New PC=%x\n", state->regData[REG_PC].v);
-
-                            /* Report the return address, including mode bit */
-                            if(!UnwReportRetAddr(state, state->regData[REG_PC].v))
-                            {
-                                return UNWIND_TRUNCATED;
-                            }
-                        }
-                        else if (got_lr)
-                        {
-                            UnwPrintd2("\n New PC=%x\n", state->regData[REG_LR].v);
-
-                            /* Report the return address, including mode bit */
-                            if(!UnwReportRetAddr(state, state->regData[REG_LR].v))
-                            {
-                                return UNWIND_TRUNCATED;
-                            }
-
-                            state->regData[REG_PC].v = state->regData[REG_LR].v;
-
-                            if(UnwIsAddrThumb(state->regData[REG_PC].v, state->regData[REG_SPSR].v))
-                            {
-                                /* Branching to THUMB */
-
-                                /* Account for the auto-increment which isn't needed */
-                                state->regData[REG_PC].v -= 2;
-                            }
-                            else
-                            {
-                                return UnwStartArm(state);
-                            }
-                        }
-                    }
-                }
-            }
-            break;
-        case 2:
-            if (0 == L)
-            {
-              /* STMDB / PUSH if Rn == 13 */
-                if (13 != Rn)
-                {
-                    UnwPrintd1("STMDB ...");
-                }
-                else
-                {
-                    Int16 register_list = (instr2 & 0x7FFF);
-                    Int8 bitCount = 0;
-                    Int32 address;
-                    Int8 i;
-
-                    for (i = 0; i < 15; i++)
-                    {
-                        if ((register_list & (0x1 << i)) != 0) bitCount++;
-                    }
-                    address = state->regData[REG_SP].v - 4*bitCount;
-                    UnwPrintd1("PUSH {");
-                    for (i = 0; i < 15; i++)
-                    {
-                        if ((register_list & (0x1 << i)) != 0)
-                        {
-                            if (!UnwMemWriteRegister (state,
-                                  address,
-                                  &state->regData[i]))
-                            {
-                                return UNWIND_DREAD_W_FAIL;
-                            }
-                            address += 4;
-                            UnwPrintd2("r%d,", i);
-                        }
-                    }
-                    state->regData[REG_SP].v = address;
-                    UnwPrintd1("}");
-                }
-            }
-            else
-            {
-              /* LDMDB */
-              UnwPrintd1("LDMDB ...");
-            }
-            break;
-        case 3:
-            if (0 == L)
-            {
-              /* SRS */
-              UnwPrintd1("SRS ...");
-            }
-            else
-            {
-              /* RFE */
-              UnwPrintd1("RFE ...");
-            }
-            break;
-    }
-
-    return res;
-}
-
-static UnwResult UnwLoadStoreSingleDataItemOpA0101(UnwState * const state, Int32 instr)
-{
-    Int8 opB = (instr & (0x7 << 9)) >> 9;
-    Int8 Rt;
-    switch (opB)
-    {
-        case 0:
-        case 1:
-        case 2:
-            /* stores - ignore */
-            UnwPrintd1("STR(H/B) ...");
-            break;
-        case 3:
-        case 4:
-        case 5:
-        case 6:
-        case 7:
-            Rt = instr & 0x7;
-            state->regData[Rt].o = REG_VAL_INVALID;
-            UnwPrintd2("LDR(SB/H/B/SH) r%d", Rt);
-            break;
-    }
-    return UNWIND_SUCCESS;
-}
-
-static void doBranchOffset(UnwState * const state, SignedInt16 branchValue)
-{
-    /* Update PC */
-    state->regData[REG_PC].v += branchValue;
-
-    /* Need to advance by a word to account for pre-fetch.
-     *  Advance by a half word here, allowing the normal address
-     *  advance to account for the other half word.
-     */
-    state->regData[REG_PC].v += 2;
-
-    /* Display PC of next instruction */
-    UnwPrintd2("\n New PC=%x", state->regData[REG_PC].v + 2);
-}
-
-static UnwResult doBranch (UnwState * const state, SignedInt16 branchValue,
-    const char *opname)
-{
-    Int32 data;
-    Boolean tracked;
-
-    Boolean used = UnwMemHashRead (&state->branchData,
-        state->regData[REG_PC].v, &data, &tracked);
-
-    UnwPrintd4 ("%s %d ; %s", opname, branchValue, used ? "FOLLOW" : "SKIPPING");
-
-    if (!used)
-    {
-        UnwMemHashWrite (&state->branchData,
-            state->regData[REG_PC].v, 0, TRUE);
-    }
-    else
-    {
-        UnwMemHashWrite (&state->branchData,
-            state->regData[REG_PC].v, 0, FALSE);
-        doBranchOffset (state, branchValue);
-    }
-    return UNWIND_SUCCESS;
-}
-
-UnwResult UnwStartThumb(UnwState * const state)
-{
-    Boolean  found = FALSE;
-    Int16    t = UNW_MAX_INSTR_COUNT;
-    UnwResult result = UNWIND_SUCCESS;
-
-    do
-    {
-        Int16 instr;
-
-        result = UNWIND_SUCCESS;
-
-        /* Attempt to read the instruction */
-        if(!state->cb->readH(state->regData[15].v & (~0x1), &instr))
-        {
-            return UNWIND_IREAD_H_FAIL;
-        }
-
-        UnwPrintd4("T %x %x %04x:",
-                   state->regData[13].v, state->regData[15].v, instr);
-
-        /* Check that the PC is still on Thumb alignment */
-        if(!UnwIsAddrThumb(state->regData[REG_PC].v, state->regData[REG_SPSR].v))
-        {
-            UnwPrintd1("\nError: PC misalignment\n");
-            return UNWIND_INCONSISTENT;
-        }
-
-        /* Check that the SP and PC have not been invalidated */
-        if(!M_IsOriginValid(state->regData[13].o) || !M_IsOriginValid(state->regData[15].o))
-        {
-            UnwPrintd1("\nError: PC or SP invalidated\n");
-            return UNWIND_INCONSISTENT;
-        }
-
-        /* Format 1: Move shifted register
-         *  LSL Rd, Rs, #Offset5
-         *  LSR Rd, Rs, #Offset5
-         *  ASR Rd, Rs, #Offset5
-         */
-        if((instr & 0xe000) == 0x0000 && (instr & 0x1800) != 0x1800)
-        {
-            Boolean signExtend;
-            Int8    op      = (instr & 0x1800) >> 11;
-            Int8    offset5 = (instr & 0x07c0) >>  6;
-            Int8    rs      = (instr & 0x0038) >>  3;
-            Int8    rd      = (instr & 0x0007);
-
-            switch(op)
-            {
-                case 0: /* LSL */
-                    UnwPrintd6("LSL r%d, r%d, #%d\t; r%d %s", rd, rs, offset5, rs, M_Origin2Str(state->regData[rs].o));
-                    state->regData[rd].v = state->regData[rs].v << offset5;
-                    state->regData[rd].o = state->regData[rs].o;
-                    state->regData[rd].o |= REG_VAL_ARITHMETIC;
-                    break;
-
-                case 1: /* LSR */
-                    UnwPrintd6("LSR r%d, r%d, #%d\t; r%d %s", rd, rs, offset5, rs, M_Origin2Str(state->regData[rs].o));
-                    state->regData[rd].v = state->regData[rs].v >> offset5;
-                    state->regData[rd].o = state->regData[rs].o;
-                    state->regData[rd].o |= REG_VAL_ARITHMETIC;
-                    break;
-
-                case 2: /* ASR */
-                    UnwPrintd6("ASL r%d, r%d, #%d\t; r%d %s", rd, rs, offset5, rs, M_Origin2Str(state->regData[rs].o));
-
-                    signExtend = (state->regData[rs].v & 0x8000) ? TRUE : FALSE;
-                    state->regData[rd].v = state->regData[rs].v >> offset5;
-                    if(signExtend)
-                    {
-                        state->regData[rd].v |= 0xffffffff << (32 - offset5);
-                    }
-                    state->regData[rd].o = state->regData[rs].o;
-                    state->regData[rd].o |= REG_VAL_ARITHMETIC;
-                    break;
-            }
-        }
-        /* Format 2: add/subtract
-         *  ADD Rd, Rs, Rn
-         *  ADD Rd, Rs, #Offset3
-         *  SUB Rd, Rs, Rn
-         *  SUB Rd, Rs, #Offset3
-         */
-        else if((instr & 0xf800) == 0x1800)
-        {
-            Boolean I  = (instr & 0x0400) ? TRUE : FALSE;
-            Boolean op = (instr & 0x0200) ? TRUE : FALSE;
-            Int8    rn = (instr & 0x01c0) >> 6;
-            Int8    rs = (instr & 0x0038) >> 3;
-            Int8    rd = (instr & 0x0007);
-
-            /* Print decoding */
-            UnwPrintd6("%s r%d, r%d, %c%d\t;",
-                       op ? "SUB" : "ADD",
-                       rd, rs,
-                       I ? '#' : 'r',
-                       rn);
-            UnwPrintd5("r%d %s, r%d %s",
-                       rd, M_Origin2Str(state->regData[rd].o),
-                       rs, M_Origin2Str(state->regData[rs].o));
-            if(!I)
-            {
-                UnwPrintd3(", r%d %s", rn, M_Origin2Str(state->regData[rn].o));
-
-                /* Perform calculation */
-                if(op)
-                {
-                    state->regData[rd].v = state->regData[rs].v - state->regData[rn].v;
-                }
-                else
-                {
-                    state->regData[rd].v = state->regData[rs].v + state->regData[rn].v;
-                }
-
-                /* Propagate the origin */
-                if(M_IsOriginValid(state->regData[rs].v) &&
-                   M_IsOriginValid(state->regData[rn].v))
-                {
-                    state->regData[rd].o = state->regData[rs].o;
-                    state->regData[rd].o |= REG_VAL_ARITHMETIC;
-                }
-                else
-                {
-                    state->regData[rd].o = REG_VAL_INVALID;
-                }
-            }
-            else
-            {
-                /* Perform calculation */
-                if(op)
-                {
-                    state->regData[rd].v = state->regData[rs].v - rn;
-                }
-                else
-                {
-                    state->regData[rd].v = state->regData[rs].v + rn;
-                }
-
-                /* Propagate the origin */
-                state->regData[rd].o = state->regData[rs].o;
-                state->regData[rd].o |= REG_VAL_ARITHMETIC;
-            }
-        }
-        /* Format 3: move/compare/add/subtract immediate
-         *  MOV Rd, #Offset8
-         *  CMP Rd, #Offset8
-         *  ADD Rd, #Offset8
-         *  SUB Rd, #Offset8
-         */
-        else if((instr & 0xe000) == 0x2000)
-        {
-            Int8    op      = (instr & 0x1800) >> 11;
-            Int8    rd      = (instr & 0x0700) >>  8;
-            Int8    offset8 = (instr & 0x00ff);
-
-            switch(op)
-            {
-                case 0: /* MOV */
-                    UnwPrintd3("MOV r%d, #0x%x", rd, offset8);
-                    state->regData[rd].v = offset8;
-                    state->regData[rd].o = REG_VAL_FROM_CONST;
-                    break;
-
-                case 1: /* CMP */
-                    /* Irrelevant to unwinding */
-                    UnwPrintd1("CMP ???");
-                    break;
-
-                case 2: /* ADD */
-                    UnwPrintd5("ADD r%d, #0x%x\t; r%d %s",
-                               rd, offset8, rd, M_Origin2Str(state->regData[rd].o));
-                    state->regData[rd].v += offset8;
-                    state->regData[rd].o |= REG_VAL_ARITHMETIC;
-                    break;
-
-                case 3: /* SUB */
-                    UnwPrintd5("SUB r%d, #0x%d\t; r%d %s",
-                               rd, offset8, rd, M_Origin2Str(state->regData[rd].o));
-                    state->regData[rd].v += offset8;
-                    state->regData[rd].o |= REG_VAL_ARITHMETIC;
-                    break;
-            }
-        }
-        /* Format 4: ALU operations
-         *  AND Rd, Rs
-         *  EOR Rd, Rs
-         *  LSL Rd, Rs
-         *  LSR Rd, Rs
-         *  ASR Rd, Rs
-         *  ADC Rd, Rs
-         *  SBC Rd, Rs
-         *  ROR Rd, Rs
-         *  TST Rd, Rs
-         *  NEG Rd, Rs
-         *  CMP Rd, Rs
-         *  CMN Rd, Rs
-         *  ORR Rd, Rs
-         *  MUL Rd, Rs
-         *  BIC Rd, Rs
-         *  MVN Rd, Rs
-         */
-        else if((instr & 0xfc00) == 0x4000)
-        {
-            Int8 op = (instr & 0x03c0) >> 6;
-            Int8 rs = (instr & 0x0038) >> 3;
-            Int8 rd = (instr & 0x0007);
-#if defined(UNW_DEBUG)
-            static const char * const mnu[16] =
-            { "AND", "EOR", "LSL", "LSR",
-              "ASR", "ADC", "SBC", "ROR",
-              "TST", "NEG", "CMP", "CMN",
-              "ORR", "MUL", "BIC", "MVN" };
-#endif
-            /* Print the mnemonic and registers */
-            switch(op)
-            {
-                case 0: /* AND */
-                case 1: /* EOR */
-                case 2: /* LSL */
-                case 3: /* LSR */
-                case 4: /* ASR */
-                case 7: /* ROR */
-                case 9: /* NEG */
-                case 12: /* ORR */
-                case 13: /* MUL */
-                case 15: /* MVN */
-                    UnwPrintd8("%s r%d ,r%d\t; r%d %s, r%d %s",
-                               mnu[op],
-                               rd, rs,
-                               rd, M_Origin2Str(state->regData[rd].o),
-                               rs, M_Origin2Str(state->regData[rs].o));
-                    break;
-
-                case 5: /* ADC */
-                case 6: /* SBC */
-                    UnwPrintd4("%s r%d, r%d", mnu[op], rd, rs);
-                    break;
-
-                case 8: /* TST */
-                case 10: /* CMP */
-                case 11: /* CMN */
-                    /* Irrelevant to unwinding */
-                    UnwPrintd2("%s ???", mnu[op]);
-                    break;
-
-                case 14: /* BIC */
-                    UnwPrintd5("r%d ,r%d\t; r%d %s",
-                                rd, rs,
-                                rs, M_Origin2Str(state->regData[rs].o));
-                    state->regData[rd].v &= !state->regData[rs].v;
-                    break;
-            }
-
-
-            /* Perform operation */
-            switch(op)
-            {
-                case 0: /* AND */
-                    state->regData[rd].v &= state->regData[rs].v;
-                    break;
-
-                case 1: /* EOR */
-                    state->regData[rd].v ^= state->regData[rs].v;
-                    break;
-
-                case 2: /* LSL */
-                    state->regData[rd].v <<= state->regData[rs].v;
-                    break;
-
-                case 3: /* LSR */
-                    state->regData[rd].v >>= state->regData[rs].v;
-                    break;
-
-                case 4: /* ASR */
-                    if(state->regData[rd].v & 0x80000000)
-                    {
-                        state->regData[rd].v >>= state->regData[rs].v;
-                        state->regData[rd].v |= 0xffffffff << (32 - state->regData[rs].v);
-                    }
-                    else
-                    {
-                        state->regData[rd].v >>= state->regData[rs].v;
-                    }
-
-                    break;
-
-                case 5: /* ADC */
-                case 6: /* SBC */
-                case 8: /* TST */
-                case 10: /* CMP */
-                case 11: /* CMN */
-                    break;
-                case 7: /* ROR */
-                    state->regData[rd].v = (state->regData[rd].v >> state->regData[rs].v) |
-                                    (state->regData[rd].v << (32 - state->regData[rs].v));
-                    break;
-
-                case 9: /* NEG */
-                    state->regData[rd].v = -state->regData[rs].v;
-                    break;
-
-                case 12: /* ORR */
-                    state->regData[rd].v |= state->regData[rs].v;
-                    break;
-
-                case 13: /* MUL */
-                    state->regData[rd].v *= state->regData[rs].v;
-                    break;
-
-                case 14: /* BIC */
-                    state->regData[rd].v &= !state->regData[rs].v;
-                    break;
-
-                case 15: /* MVN */
-                    state->regData[rd].v = !state->regData[rs].v;
-                    break;
-            }
-
-            /* Propagate data origins */
-            switch(op)
-            {
-                case 0: /* AND */
-                case 1: /* EOR */
-                case 2: /* LSL */
-                case 3: /* LSR */
-                case 4: /* ASR */
-                case 7: /* ROR */
-                case 12: /* ORR */
-                case 13: /* MUL */
-                case 14: /* BIC */
-                    if(M_IsOriginValid(state->regData[rs].o) && M_IsOriginValid(state->regData[rs].o))
-                    {
-                        state->regData[rd].o = state->regData[rs].o;
-                        state->regData[rd].o |= REG_VAL_ARITHMETIC;
-                    }
-                    else
-                    {
-                        state->regData[rd].o = REG_VAL_INVALID;
-                    }
-                    break;
-
-                case 5: /* ADC */
-                case 6: /* SBC */
-                    /* C-bit not tracked */
-                    state->regData[rd].o = REG_VAL_INVALID;
-                    break;
-
-                case 8: /* TST */
-                case 10: /* CMP */
-                case 11: /* CMN */
-                    /* Nothing propagated */
-                    break;
-
-                case 9: /* NEG */
-                case 15: /* MVN */
-                    state->regData[rd].o = state->regData[rs].o;
-                    state->regData[rd].o |= REG_VAL_ARITHMETIC;
-                    break;
-
-            }
-
-        }
-        /* Format 5: Hi register operations/branch exchange
-         *  ADD Rd, Hs
-         *  ADD Hd, Rs
-         *  ADD Hd, Hs
-         *  CMP Hd
-         *  MOV Rd
-         *  MOV Hd
-         *  BX
-         *  BLX
-         */
-        else if((instr & 0xfc00) == 0x4400)
-        {
-            Int8    op  = (instr & 0x0300) >> 8;
-            Boolean h1  = (instr & 0x0080) ? TRUE: FALSE;
-            Boolean h2  = (instr & 0x0040) ? TRUE: FALSE;
-            Int8    rhs = (instr & 0x0038) >> 3;
-            Int8    rhd = (instr & 0x0007);
-
-            /* Adjust the register numbers */
-            if(h2) rhs += 8;
-            if(h1) rhd += 8;
-
-            if(op == 1 && !h1 && !h2)
-            {
-                UnwPrintd1("\nError: h1 or h2 must be set for ADD, CMP or MOV\n");
-                return UNWIND_ILLEGAL_INSTR;
-            }
-
-            switch(op)
-            {
-                case 0: /* ADD */
-                    UnwPrintd5("ADD r%d, r%d\t; r%d %s",
-                               rhd, rhs, rhs, M_Origin2Str(state->regData[rhs].o));
-                    state->regData[rhd].v += state->regData[rhs].v;
-                    state->regData[rhd].o =  state->regData[rhs].o;
-                    state->regData[rhd].o |= REG_VAL_ARITHMETIC;
-                    break;
-
-                case 1: /* CMP */
-                    /* Irrelevant to unwinding */
-                    UnwPrintd1("CMP ???");
-                    break;
-
-                case 2: /* MOV */
-                    UnwPrintd5("MOV r%d, r%d\t; r%d %s",
-                               rhd, rhs, rhd, M_Origin2Str(state->regData[rhs].o));
-                    state->regData[rhd].v  = state->regData[rhs].v;
-                    state->regData[rhd].o  = state->regData[rhd].o;
-                    break;
-
-                case 3: /* BX */
-                    UnwPrintd4("BX r%d\t; r%d %s\n",
-                               rhs, rhs, M_Origin2Str(state->regData[rhs].o));
-
-                    /* Only follow BX if the data was from the stack */
-                    if(state->regData[rhs].o == REG_VAL_FROM_STACK)
-                    {
-                        UnwPrintd2(" Return PC=0x%x\n", state->regData[rhs].v & (~0x1));
-
-                        /* Report the return address, including mode bit */
-                        if(!UnwReportRetAddr(state, state->regData[rhs].v))
-                        {
-                            return UNWIND_TRUNCATED;
-                        }
-                        t = UNW_MAX_INSTR_COUNT;
-
-                        /* Update the PC */
-                        state->regData[15].v = state->regData[rhs].v;
-
-                        /* Determine the new mode */
-                        if(UnwIsAddrThumb(state->regData[rhs].v, state->regData[REG_SPSR].v))
-                        {
-                            /* Branching to THUMB */
-
-                            /* Account for the auto-increment which isn't needed */
-                            state->regData[15].v -= 2;
-                        }
-                        else
-                        {
-                            /* Branch to ARM */
-                            return UnwStartArm(state);
-                        }
-                    }
-                    else
-                    {
-                        UnwPrintd4("\nError: BX to invalid register: r%d = 0x%x (%s)\n",
-                                   rhs, state->regData[rhs].o, M_Origin2Str(state->regData[rhs].o));
-                        result = UNWIND_FAILURE;
-                    }
-            }
-        }
-        /* Format 9: load/store with immediate offset
-         *  LDR/STR Rd, [Rb, #imm]
-         */
-        else if ((instr & 0xe000) == 0x6000)
-        {
-            Int8 rd = instr & 0x7;
-            Int8 rb = (instr & (0x7 << 3)) >> 3;
-            Int32 offset5 = (instr & (0x1f << 6)) >> 6;
-
-            offset5 += state->regData[rb].v;
-
-            if ((instr & 0x0400) != 0)
-            {
-              /* This is LDR */
-
-              UnwPrintd3("LDR r%d, 0x%08x", rd, offset5);
-
-              if (!UnwMemReadRegister (state, offset5, &state->regData[rd]))
-              {
-                state->regData[rd].o = REG_VAL_INVALID;
-              }
-            }
-            else
-            {
-            /* in STR case, ignore it (for now) */
-              UnwPrintd3("STR r%d, 0x%08x", rd, offset5);
-            }
-        }
-        /* Format 9: PC-relative load
-         *  LDR Rd,[PC, #imm]
-         */
-        else if((instr & 0xf800) == 0x4800)
-        {
-            Int8  rd    = (instr & 0x0700) >> 8;
-            Int8  word8 = (instr & 0x00ff);
-            Int32 address;
-
-            /* Compute load address, adding a word to account for prefetch */
-            address = (state->regData[15].v & (~0x3)) + 4 + (word8 << 2);
-
-            UnwPrintd3("LDR r%d, 0x%08x", rd, address);
-
-            if(!UnwMemReadRegister(state, address, &state->regData[rd]))
-            {
-                state->regData[rd].o = REG_VAL_INVALID;
-            }
-        }
-        else if((instr & 0xf800) == 0x4000)
-        {
-            /* in STR case, ignore it (for now) */
-            UnwPrintd1("STR ???");
-        }
-        /* Format 13: add offset to Stack Pointer
-         *  ADD sp,#+imm
-         *  ADD sp,#-imm
-         */
-        else if((instr & 0xff00) == 0xB000)
-        {
-            Int8 value = (instr & 0x7f) * 4;
-
-            /* Check the negative bit */
-            if((instr & 0x80) != 0)
-            {
-                UnwPrintd2("SUB sp,#0x%x", value);
-                state->regData[13].v -= value;
-            }
-            else
-            {
-                UnwPrintd2("ADD sp,#0x%x", value);
-                state->regData[13].v += value;
-            }
-        }
-        /* Format 14: push/pop registers
-         *  PUSH {Rlist}
-         *  PUSH {Rlist, LR}
-         *  POP {Rlist}
-         *  POP {Rlist, PC}
-         */
-        else if((instr & 0xf600) == 0xb400)
-        {
-            Boolean  L     = (instr & 0x0800) ? TRUE : FALSE;
-            Boolean  R     = (instr & 0x0100) ? TRUE : FALSE;
-            Int8     rList = (instr & 0x00ff);
-
-            if(L)
-            {
-                Int8 r;
-
-                /* Load from memory: POP */
-                UnwPrintd2("POP {Rlist%s}\n", R ? ", PC" : "");
-
-                for(r = 0; r < 8; r++)
-                {
-                    if(rList & (0x1 << r))
-                    {
-                        /* Read the word */
-                        if(!UnwMemReadRegister(state, state->regData[13].v, &state->regData[r]))
-                        {
-                            return UNWIND_DREAD_W_FAIL;
-                        }
-
-                        /* Alter the origin to be from the stack if it was valid */
-                        if(M_IsOriginValid(state->regData[r].o))
-                        {
-                            state->regData[r].o = REG_VAL_FROM_STACK;
-                        }
-
-                        state->regData[13].v += 4;
-
-                        UnwPrintd3("  r%d = 0x%08x\n", r, state->regData[r].v);
-                    }
-                }
-
-                /* Check if the PC is to be popped */
-                if(R)
-                {
-                    /* Get the return address */
-                    if(!UnwMemReadRegister(state, state->regData[13].v, &state->regData[15]))
-                    {
-                        return UNWIND_DREAD_W_FAIL;
-                    }
-
-                    /* Alter the origin to be from the stack if it was valid */
-                    if(!M_IsOriginValid(state->regData[15].o))
-                    {
-                        /* Return address is not valid */
-                        UnwPrintd1("PC popped with invalid address\n");
-                        return UNWIND_FAILURE;
-                    }
-                    else
-                    {
-                        /* The bottom bit should have been set to indicate that
-                         *  the caller was from Thumb.  This would allow return
-                         *  by BX for interworking APCS.
-                         */
-                        if(!UnwIsAddrThumb(state->regData[REG_PC].v, state->regData[REG_SPSR].v))
-                        {
-                            UnwPrintd2("Warning: Return address not to Thumb: 0x%08x\n",
-                                       state->regData[15].v);
-
-                            /* Pop into the PC will not switch mode */
-                            return UNWIND_INCONSISTENT;
-                        }
-
-                        /* Store the return address */
-                        if(!UnwReportRetAddr(state, state->regData[15].v))
-                        {
-                            return UNWIND_TRUNCATED;
-                        }
-                        t = UNW_MAX_INSTR_COUNT;
-
-                        /* Now have the return address */
-                        UnwPrintd2(" Return PC=%x\n", state->regData[15].v);
-
-                        /* Update the pc */
-                        state->regData[13].v += 4;
-
-                        /* Compensate for the auto-increment, which isn't needed here */
-                        state->regData[15].v -= 2;
-                    }
-                }
-
-            }
-            else
-            {
-                SignedInt8 r;
-
-                /* Store to memory: PUSH */
-                UnwPrintd2("PUSH {Rlist%s}", R ? ", LR" : "");
-
-                /* Check if the LR is to be pushed */
-                if(R)
-                {
-                    UnwPrintd3("\n  lr = 0x%08x\t; %s",
-                               state->regData[14].v, M_Origin2Str(state->regData[14].o));
-
-                    state->regData[13].v -= 4;
-
-                    /* Write the register value to memory */
-                    if(!UnwMemWriteRegister(state, state->regData[13].v, &state->regData[14]))
-                    {
-                        return UNWIND_DWRITE_W_FAIL;
-                    }
-                }
-
-                for(r = 7; r >= 0; r--)
-                {
-                    if(rList & (0x1 << r))
-                    {
-                        UnwPrintd4("\n  r%d = 0x%08x\t; %s",
-                                   r, state->regData[r].v, M_Origin2Str(state->regData[r].o));
-
-                        state->regData[13].v -= 4;
-
-                        if(!UnwMemWriteRegister(state, state->regData[13].v, &state->regData[r]))
-                        {
-                            return UNWIND_DWRITE_W_FAIL;
-                        }
-                    }
-                }
-            }
-        }
-        /* Format 18: unconditional branch
-         *  B label
-         */
-        else if((instr & 0xf800) == 0xe000)
-        {
-            SignedInt16 branchValue = signExtend11(instr & 0x07ff);
-
-            /* Branch distance is twice that specified in the instruction. */
-            branchValue *= 2;
-
-            UnwPrintd2("B %d \n", branchValue);
-
-            doBranchOffset (state, branchValue);
-        }
-        /* Load/store single data item
-         * STR/STRH/STRB/LDRSB/LDR/LDRH/LDRB/LDRSH (register)
-         */
-        else if ((instr & 0xf000) == 0x5000)
-        {
-            result = UnwLoadStoreSingleDataItemOpA0101(state, instr);
-        }
-        /* Load/store single data item
-         * Store/Load Register SP relative
-         */
-        else if ((instr & 0xf000) == 0x9000)
-        {
-            Int8 opB = (instr & (0x1 << 11)) >> 11;
-            Int16 Rt = (instr & (0x7 << 8)) >> 8;
-            Int16 imm8 = instr &0xFF;
-
-            imm8 <<= 2;
-
-            if (0 == opB)
-            {
-                UnwPrintd3("STR r%d, [sp, #0x%08x]", Rt, imm8);
-                if (!UnwMemWriteRegister(state, state->regData[REG_SP].v+imm8, &state->regData[Rt]))
-                {
-                    return UNWIND_DREAD_W_FAIL;
-                }
-            }
-            else
-            {
-                UnwPrintd3("LDR r%d, [sp, #0x%08x]", Rt, imm8);
-                if (!UnwMemReadRegister(state, state->regData[REG_SP].v+imm8, &state->regData[Rt]))
-                {
-                    return UNWIND_DREAD_W_FAIL;
-                }
-                state->regData[Rt].v = REG_VAL_FROM_STACK;
-            }
-        }
-        /* Conditional branch, and Supervisor Call */
-        else if ((instr & 0xf000) == 0xd000)
-        {
-            Int8 cond = (instr & (0xF << 8)) >> 8;
-            switch (cond)
-            {
-                case 0xF:
-                    UnwPrintd2("SVC ... (lr=%x)", state->regData[REG_LR].v);
-                    break;
-                case 0xE:
-                    result = UNWIND_FAILURE;
-                    UnwPrintd1("ILLEGAL   ; breaking");
-                    break;
-                default:
-                    {
-                        SignedInt16 branchValue = (signExtend8 (instr & 0xFF)) * 2;
-
-                        result = doBranch(state, branchValue, "B(cond)");
-                    }
-                    break;
-            }
-        }
-        /* Compare and Branch on Zero */
-        else if ((instr & 0xff00) == 0xb100)
-        {
-            SignedInt16 imm32 = (instr & (0x1F << 3)) >> 3;
-            SignedInt16 i = (instr & (1 << 9)) >> 9;
-            imm32 = (imm32 | (i << 5)) << 1;
-
-            result = doBranch(state, imm32, "CB{N}Z");
-        }
-        else if ((instr & 0xff00) == 0xbf00)
-        {
-            UnwPrintd1("IT/NOP/YIELD/WFE/WFI/SEV ...");
-        }
-        /* 32-bit instructions */
-        else if (((instr & 0xe000) == 0xe000) && ((instr & 0xf800) != 0xe00))
-        {
-            Int8 op1 = (instr & (0x3 << 11)) >> 11;
-            Int8 op2 = (instr & (0x7F << 4)) >> 4;
-            Int8 op;
-            UnwResult res = UNWIND_SUCCESS;
-
-            Int16 instr2;
-            /* read second part of this 32-bit instruction */
-            if(!state->cb->readH((state->regData[15].v + 2) & (~0x1), &instr2))
-            {
-                return UNWIND_IREAD_H_FAIL;
-            }
-
-            op = (instr2 & (1 << 15)) >> 15;
-
-            switch (op1)
-            {
-                case 1:
-                    if ((op2 & 0x64) == 0)
-                    {
-                      /* Load/store multiple */
-                      res = Unw32LoadStoreMultiple(state, instr, instr2);
-                    }
-                    else if ((op2 & 0x64) == 4)
-                    {
-                      /* Load/store dual, load/store exclusive, table branch */
-                        UnwPrintd1("32-bit load/store dual, load/store exclusive, table branch...");
-                    }
-                    else if ((op2 & 0x60) == 0x20)
-                    {
-                      /* Data-processing (shifted register) */
-                        UnwPrintd1("32-bit data processing (shifted register)...");
-                    }
-                    else /* if (op2 & 0x40 == 0x40) */
-                    {
-                      /* Coprocessor instructions */
-                        UnwPrintd1("32-bit coprocessor...");
-                    }
-                    break;
-                case 2:
-                    if (0 == op)
-                    {
-                        if ((op2 & 0x20) == 0)
-                        {
-                            /* Data processing (modified immediate) */
-                            res = Unw32DataProcessingModifiedImmediate(state, instr, instr2);
-                        }
-                        else
-                        {
-                            /* Data-processing (plain binary immediate) */
-                            UnwPrintd1("32-bit data processing (plain binary immediate)...");
-                        }
-                    }
-                    else
-                    {
-                        /* Branches and miscellaneous control */
-                        UnwPrintd1("32-bit branches and miscellaneous control...");
-                    }
-                    break;
-                case 3:
-                    if ((op2 & 0x71) == 0)
-                    {
-                        /* Store single data item */
-                        UnwPrintd1("32-bit store single data item...");
-                    }
-                    else if ((op2 & 0x71) == 0x10)
-                    {
-                        /* Advanced SIMD element or structure load/store instructions */
-                        UnwPrintd1("32-bit advanced SIMD element or structure load/store...");
-                    }
-                    else if ((op2 & 0x67) == 1)
-                    {
-                        /* Load byte, memory hints */
-                        UnwPrintd1("32-bit load byte, memory hints...");
-                    }
-                    else if ((op2 & 0x67) == 3)
-                    {
-                        /* Load halfword, memory hints */
-                        UnwPrintd1("32-bit load halfword, memory hints...");
-                    }
-                    else if ((op2 & 0x67) == 5)
-                    {
-                        /* Load word */
-                        res = Unw32LoadWord (state, instr, instr2);
-                    }
-                    else if ((op2 & 0x67) == 7)
-                    {
-                        res = UNWIND_ILLEGAL_INSTR;
-                    }
-                    else if ((op2 & 0x70) == 0x20)
-                    {
-                        /* Data-processing (register) */
-                        UnwPrintd1("32-bit data processing...");
-                    }
-                    else if ((op2 & 0x78) == 0x30)
-                    {
-                        /* Multiply, multiply accumulate, and absolute difference */
-                        UnwPrintd1("32-bit multiply...");
-                    }
-                    else if ((op2 & 0x78) == 0x38)
-                    {
-                        /* Long multiply, long multiply accumulate, and divide */
-                        UnwPrintd1("32-bit long multiply...");
-                    }
-                    else if ((op2 & 0x80) == 0x80)
-                    {
-                        /* Coprocessor instructions */
-                        UnwPrintd1("32-bit coprocessor (2) ...");
-                    }
-                    else
-                        res = UNWIND_ILLEGAL_INSTR;
-            }
-
-            state->regData[REG_PC].v += 2;
-
-            if (UNWIND_SUCCESS != res)
-                return res;
-        }
-        else
-        {
-            UnwPrintd1("????");
-
-            /* Unknown/undecoded.  May alter some register, so invalidate file */
-            UnwInvalidateRegisterFile(state->regData);
-        }
-
-        UnwPrintd1("\n");
-
-        /* Should never hit the reset vector */
-        if(state->regData[15].v == 0) return UNWIND_RESET;
-
-        /* Check next address */
-        state->regData[15].v += 2;
-
-        /* Garbage collect the memory hash (used only for the stack) */
-        UnwMemHashGC(state);
-
-        t--;
-        if(t == 0 || result == UNWIND_FAILURE)
-        {
-            /* TODO: try scanning prologue - here */
-            /* call callback to get address of current function */
-            Int32 prologue_pc = state->cb->getProloguePC (state->lastReported);
-            /* Prologue fits within 32 16-bit instructions */
-            Int32 prologue_pc_end = prologue_pc + 31*2;
-            Boolean changed = FALSE;
-
-            if (0 == t) result = UNWIND_EXHAUSTED;
-
-            UnwPrintd3("Unwind exhausted (result=%d), prologue at: %x\n", result, prologue_pc);
-
-            if (0 == prologue_pc) return UNWIND_FAILURE;
-
-            UnwInvalidateRegisterFile (state->regData);
-
-            while (prologue_pc_end > prologue_pc)
-            {
-                Int16 instr;
-                Int16 prev_instr = 0;
-
-                if(!state->cb->readH(prologue_pc_end & (~0x1), &instr))
-                {
-                    return UNWIND_IREAD_H_FAIL;
-                }
-                if (prologue_pc_end - 2 >= prologue_pc)
-                {
-                    if(!state->cb->readH((prologue_pc_end-2) & (~0x1), &prev_instr))
-                    {
-                        return UNWIND_IREAD_H_FAIL;
-                    }
-                }
-                /* Check if this is not a part of previous 32-bit instruction */
-                if ((prev_instr & 0xf800) != 0xe000)
-                {
-                    /* Now, let's look for all the interesting stuff we want:
-                     *  push {rlist, lr}
-                     *  sub  sp, #imm
-                     */
-                    if ((instr & 0xff80) == 0xb080)
-                    {
-                        /* sub sp, #imm */
-                        Int16 imm7 = instr & 0x7F;
-                        imm7 = imm7 << 2;
-                        state->regData[REG_SP].v += imm7;
-                        changed = TRUE;
-                    }
-                    else if ((instr & 0xfe00) == 0xb400)
-                    {
-                        /* push {rlist, lr} */
-                        Int16 M = (instr & (0x1 << 8)) >> 8;
-                        Int16 register_list = (instr & 0xFF) | (M << 14);
-                        int i;
-
-                        for (i = 0; i < 15; i++)
-                        {
-                            if ((register_list & (0x1 << i)) != 0)
-                            {
-                                if (!UnwMemReadRegister(state, state->regData[REG_SP].v,
-                                      &state->regData[i]))
-                                {
-                                    return UNWIND_DREAD_W_FAIL;
-                                }
-                                state->regData[i].o = REG_VAL_FROM_STACK;
-                                state->regData[REG_SP].v += 4;
-                                changed = TRUE;
-                            }
-                        }
-                    }
-                }
-                prologue_pc_end -= 2;
-            }
-
-            if (changed)
-            {
-                /* Report the return address, including mode bit */
-                if(!UnwReportRetAddr(state, state->regData[REG_LR].v))
-                {
-                    return UNWIND_TRUNCATED;
-                }
-
-                if (state->regData[REG_PC].v-2 == state->regData[REG_LR].v)
-                {
-                    return UNWIND_FAILURE;
-                }
-
-                /* Update the PC */
-                state->regData[REG_PC].v = state->regData[REG_LR].v;
-
-                UnwPrintd2(" New PC=%x\n", state->regData[REG_PC].v);
-
-                /* Determine the new mode */
-                if(UnwIsAddrThumb(state->regData[REG_PC].v, state->regData[REG_SPSR].v))
-                {
-                    /* Branching to THUMB - PC already set - restore count */
-                    t = UNW_MAX_INSTR_COUNT;
-                }
-                else
-                {
-                    /* Branch to ARM */
-                    return UnwStartArm(state);
-                }
-            }
-            else
-                return result;
-        }
-
-    }
-    while(!found);
-
-    return result;
-}
-
-#endif /* UPGRADE_ARM_STACK_UNWIND */
-
-/* END OF FILE */
-
diff --git a/src/crash-stack/wind/unwarminder.c b/src/crash-stack/wind/unwarminder.c
deleted file mode 100644
index 750ee3f..0000000
--- a/src/crash-stack/wind/unwarminder.c
+++ /dev/null
@@ -1,88 +0,0 @@
-/***************************************************************************
- * ARM Stack Unwinder, Michael.McTernan.2001@cs.bris.ac.uk
- *
- * This program is PUBLIC DOMAIN.
- * This means that there is no copyright and anyone is able to take a copy
- * for free and use it as they wish, with or without modifications, and in
- * any context, commercially or otherwise. The only limitation is that I
- * don't guarantee that the software is fit for any purpose or accept any
- * liability for it's use or misuse - this software is without warranty.
- ***************************************************************************
- * File Description: Implementation of the interface into the ARM unwinder.
- **************************************************************************/
-
-#define MODULE_NAME "UNWARMINDER"
-
-/***************************************************************************
- * Include Files
- **************************************************************************/
-
-#include "system.h"
-#if defined(UPGRADE_ARM_STACK_UNWIND)
-#include <stdio.h>
-#include <string.h>
-#include "unwarminder.h"
-#include "unwarm.h"
-
-
-/***************************************************************************
- * Manifest Constants
- **************************************************************************/
-
-
-/***************************************************************************
- * Type Definitions
- **************************************************************************/
-
-
-/***************************************************************************
- * Variables
- **************************************************************************/
-
-
-/***************************************************************************
- * Macros
- **************************************************************************/
-
-
-/***************************************************************************
- * Local Functions
- **************************************************************************/
-
-
-/***************************************************************************
- * Global Functions
- **************************************************************************/
-
-UnwResult UnwindStart(Int32                  spValue,
-                      const UnwindCallbacks *cb,
-                      void                  *data)
-{
-    Int32    retAddr;
-    UnwState state;
-
-#if !defined(SIM_CLIENT)
-    retAddr = __return_address();
-#else
-    retAddr = 0x0000a894;
-    spValue = 0x7ff7edf8;
-#endif
-
-    /* Initialise the unwinding state */
-    UnwInitState(&state, cb, data, retAddr, spValue);
-
-    /* Check the Thumb bit */
-    if(retAddr & 0x1)
-    {
-        return UnwStartThumb(&state);
-    }
-    else
-    {
-        return UnwStartArm(&state);
-    }
-}
-
-#endif /* UPGRADE_ARM_STACK_UNWIND */
-
-/* END OF FILE */
-
diff --git a/src/crash-stack/wind/unwarminder.h b/src/crash-stack/wind/unwarminder.h
deleted file mode 100644
index 1d078bb..0000000
--- a/src/crash-stack/wind/unwarminder.h
+++ /dev/null
@@ -1,165 +0,0 @@
-/***************************************************************************
- * ARM Stack Unwinder, Michael.McTernan.2001@cs.bris.ac.uk
- *
- * This program is PUBLIC DOMAIN.
- * This means that there is no copyright and anyone is able to take a copy
- * for free and use it as they wish, with or without modifications, and in
- * any context, commerically or otherwise. The only limitation is that I
- * don't guarantee that the software is fit for any purpose or accept any
- * liablity for it's use or misuse - this software is without warranty.
- **************************************************************************/
-/** \file
- * Interface to the ARM stack unwinding module.
- **************************************************************************/
-
-#ifndef UNWARMINDER_H
-#define UNWARMINDER_H
-
-/***************************************************************************
- * Nested Include Files
- **************************************************************************/
-
-#include "system.h"
-#if defined(UPGRADE_ARM_STACK_UNWIND)
-
-/***************************************************************************
- * Manifest Constants
- **************************************************************************/
-
-/** \def UNW_DEBUG
- * If this define is set, additional information will be produced while
- * unwinding the stack to allow debug of the unwind module itself.
- */
-/* #define UNW_DEBUG 1 */
-
-/***************************************************************************
- * Type Definitions
- **************************************************************************/
-
-/** Possible results for UnwindStart to return.
- */
-typedef enum UnwResultTag
-{
-    /** Unwinding was successful and complete. */
-    UNWIND_SUCCESS = 0,
-
-    /** More than UNW_MAX_INSTR_COUNT instructions were interpreted. */
-    UNWIND_EXHAUSTED,
-
-    /** Unwinding stopped because the reporting func returned FALSE. */
-    UNWIND_TRUNCATED,
-
-    /** Read data was found to be inconsistent. */
-    UNWIND_INCONSISTENT,
-
-    /** Unsupported instruction or data found. */
-    UNWIND_UNSUPPORTED,
-
-    /** General failure. */
-    UNWIND_FAILURE,
-
-    /** Illegal instruction. */
-    UNWIND_ILLEGAL_INSTR,
-
-    /** Unwinding hit the reset vector. */
-    UNWIND_RESET,
-
-    /** Failed read for an instruction word. */
-    UNWIND_IREAD_W_FAIL,
-
-    /** Failed read for an instruction half-word. */
-    UNWIND_IREAD_H_FAIL,
-
-    /** Failed read for an instruction byte. */
-    UNWIND_IREAD_B_FAIL,
-
-    /** Failed read for a data word. */
-    UNWIND_DREAD_W_FAIL,
-
-    /** Failed read for a data half-word. */
-    UNWIND_DREAD_H_FAIL,
-
-    /** Failed read for a data byte. */
-    UNWIND_DREAD_B_FAIL,
-
-    /** Failed write for a data word. */
-    UNWIND_DWRITE_W_FAIL
-}
-UnwResult;
-
-/** Type for function pointer for result callback.
- * The function is passed two parameters, the first is a void * pointer,
- * and the second is the return address of the function.  The bottom bit
- * of the passed address indicates the execution mode; if it is set,
- * the execution mode at the return address is Thumb, otherwise it is
- * ARM.
- *
- * The return value of this function determines whether unwinding should
- * continue or not.  If TRUE is returned, unwinding will continue and the
- * report function maybe called again in future.  If FALSE is returned,
- * unwinding will stop with UnwindStart() returning UNWIND_TRUNCATED.
- */
-typedef Boolean (*UnwindReportFunc)(void   *data,
-                                    Int32   address);
-
-/** Structure that holds memory callback function pointers.
- */
-typedef struct UnwindCallbacksTag
-{
-    /** Report an unwind result. */
-    UnwindReportFunc report;
-
-    /** Read a 32 bit word from memory.
-     * The memory address to be read is passed as \a address, and
-     * \a *val is expected to be populated with the read value.
-     * If the address cannot or should not be read, FALSE can be
-     * returned to indicate that unwinding should stop.  If TRUE
-     * is returned, \a *val is assumed to be valid and unwinding
-     * will continue.
-     */
-    Boolean (*readW)(const Int32 address, Int32 *val);
-
-    /** Read a 16 bit half-word from memory.
-     * This function has the same usage as for readW, but is expected
-     * to read only a 16 bit value.
-     */
-    Boolean (*readH)(const Int32 address, Int16 *val);
-
-    /** Read a byte from memory.
-     * This function has the same usage as for readW, but is expected
-     * to read only an 8 bit value.
-     */
-    Boolean (*readB)(const Int32 address, Int8  *val);
-
-    Int32 (*getProloguePC)(const Int32 current_pc);
-
-#if defined(UNW_DEBUG)
-    /** Print a formatted line for debug. */
-    int (*printf)(const char *format, ...);
-#endif
-
-}
-UnwindCallbacks;
-
-/***************************************************************************
- *  Macros
- **************************************************************************/
-
-/***************************************************************************
- *  Function Prototypes
- **************************************************************************/
-
-/** Start unwinding the current stack.
- * This will unwind the stack starting at the PC value supplied to in the
- * link register (i.e. not a normal register) and the stack pointer value
- * supplied.
- */
-UnwResult UnwindStart(Int32                  spValue,
-                      const UnwindCallbacks *cb,
-                      void                  *data);
-
-#endif /* UPGRADE_ARM_STACK_UNWIND */
-
-#endif /* UNWARMINDER_H */
-
-/* END OF FILE */
diff --git a/src/crash-stack/wind/unwarmmem.c b/src/crash-stack/wind/unwarmmem.c
deleted file mode 100644
index 31796ee..0000000
--- a/src/crash-stack/wind/unwarmmem.c
+++ /dev/null
@@ -1,178 +0,0 @@
-/***************************************************************************
- * ARM Stack Unwinder, Michael.McTernan.2001@cs.bris.ac.uk
- *
- * This program is PUBLIC DOMAIN.
- * This means that there is no copyright and anyone is able to take a copy
- * for free and use it as they wish, with or without modifications, and in
- * any context, commerically or otherwise. The only limitation is that I
- * don't guarantee that the software is fit for any purpose or accept any
- * liablity for it's use or misuse - this software is without warranty.
- ***************************************************************************
- * File Description: Implementation of the memory tracking sub-system.
- **************************************************************************/
-
-#define MODULE_NAME "UNWARMMEM"
-
-/***************************************************************************
- * Include Files
- **************************************************************************/
-
-#include "system.h"
-#if defined(UPGRADE_ARM_STACK_UNWIND)
-#include <stdio.h>
-#include "unwarmmem.h"
-#include "unwarm.h"
-
-/***************************************************************************
- * Manifest Constants
- **************************************************************************/
-
-
-/***************************************************************************
- * Type Definitions
- **************************************************************************/
-
-
-/***************************************************************************
- * Variables
- **************************************************************************/
-
-
-/***************************************************************************
- * Macros
- **************************************************************************/
-
-
-#define M_IsIdxUsed(a, v) (((a)[v >> 3] & (1 << (v & 0x7))) ? TRUE : FALSE)
-
-#define M_SetIdxUsed(a, v) ((a)[v >> 3] |= (1 << (v & 0x7)))
-
-#define M_ClrIdxUsed(a, v) ((a)[v >> 3] &= ~(1 << (v & 0x7)))
-
-/***************************************************************************
- * Local Functions
- **************************************************************************/
-
-/** Search the memory hash to see if an entry is stored in the hash already.
- * This will search the hash and either return the index where the item is
- * stored, or -1 if the item was not found.
- */
-static SignedInt16 memHashIndex(MemData * const memData,
-                                const Int32     addr)
-{
-    const Int16 v = addr % MEM_HASH_SIZE;
-    Int16       s = v;
-
-    do
-    {
-        /* Check if the element is occupied */
-        if(M_IsIdxUsed(memData->used, s))
-        {
-            /* Check if it is occupied with the sought data */
-            if(memData->a[s] == addr)
-            {
-                return s;
-            }
-        }
-        else
-        {
-            /* Item is free, this is where the item should be stored */
-            return s;
-        }
-
-        /* Search the next entry */
-        s++;
-        if(s > MEM_HASH_SIZE)
-        {
-            s = 0;
-        }
-    }
-    while(s != v);
-
-    /* Search failed, hash is full and the address not stored */
-    return -1;
-}
-
-
-
-/***************************************************************************
- * Global Functions
- **************************************************************************/
-
-Boolean UnwMemHashRead(MemData * const memData,
-                       Int32           addr,
-                       Int32   * const data,
-                       Boolean * const tracked)
-{
-    SignedInt16 i = memHashIndex(memData, addr);
-
-    if(i >= 0 && M_IsIdxUsed(memData->used, i) && memData->a[i] == addr)
-    {
-        *data    = memData->v[i];
-        *tracked = M_IsIdxUsed(memData->tracked, i);
-        return TRUE;
-    }
-    else
-    {
-        /* Address not found in the hash */
-        return FALSE;
-    }
-}
-
-Boolean UnwMemHashWrite(MemData * const memData,
-                        Int32           addr,
-                        Int32           val,
-                        Boolean         valValid)
-{
-    SignedInt16 i = memHashIndex(memData, addr);
-
-    if(i < 0)
-    {
-        /* Hash full */
-        return FALSE;
-    }
-    else
-    {
-        /* Store the item */
-        memData->a[i] = addr;
-        M_SetIdxUsed(memData->used, i);
-
-        if(valValid)
-        {
-            memData->v[i] = val;
-            M_SetIdxUsed(memData->tracked, i);
-        }
-        else
-        {
-#if defined(UNW_DEBUG)
-            memData->v[i] = 0xdeadbeef;
-#endif
-            M_ClrIdxUsed(memData->tracked, i);
-        }
-
-        return TRUE;
-    }
-}
-
-
-void UnwMemHashGC(UnwState * const state)
-{
-    const Int32 minValidAddr = state->regData[13].v;
-    MemData * const memData  = &state->memData;
-    Int16       t;
-
-    for(t = 0; t < MEM_HASH_SIZE; t++)
-    {
-        if(M_IsIdxUsed(memData->used, t) && (memData->a[t] < minValidAddr))
-        {
-            UnwPrintd3("MemHashGC: Free elem %d, addr 0x%08x\n",
-                       t, memData->a[t]);
-
-            M_ClrIdxUsed(memData->used, t);
-        }
-    }
-}
-
-#endif /* UPGRADE_ARM_STACK_UNWIND */
-
-/* END OF FILE */
diff --git a/src/crash-stack/wind/unwarmmem.h b/src/crash-stack/wind/unwarmmem.h
deleted file mode 100644
index 4ba505e..0000000
--- a/src/crash-stack/wind/unwarmmem.h
+++ /dev/null
@@ -1,60 +0,0 @@
-/***************************************************************************
- * ARM Stack Unwinder, Michael.McTernan.2001@cs.bris.ac.uk
- *
- * This program is PUBLIC DOMAIN.
- * This means that there is no copyright and anyone is able to take a copy
- * for free and use it as they wish, with or without modifications, and in
- * any context, commerically or otherwise. The only limitation is that I
- * don't guarantee that the software is fit for any purpose or accept any
- * liablity for it's use or misuse - this software is without warranty.
- ***************************************************************************
- * File Description: Interface to the memory tracking sub-system.
- **************************************************************************/
-
-#ifndef UNWARMMEM_H
-#define UNWARMMEM_H
-
-/***************************************************************************
- * Nested Include Files
- **************************************************************************/
-
-#include "system.h"
-#if defined(UPGRADE_ARM_STACK_UNWIND)
-#include "unwarm.h"
-
-/***************************************************************************
- * Manifest Constants
- **************************************************************************/
-
-
-/***************************************************************************
- * Type Definitions
- **************************************************************************/
-
-
-/***************************************************************************
- *  Macros
- **************************************************************************/
-
-
-/***************************************************************************
- *  Function Prototypes
- **************************************************************************/
-
-Boolean UnwMemHashRead  (MemData * const memData,
-                         Int32           addr,
-                         Int32   * const data,
-                         Boolean * const tracked);
-
-Boolean UnwMemHashWrite (MemData * const memData,
-                         Int32           addr,
-                         Int32           val,
-                         Boolean         valValid);
-
-void    UnwMemHashGC    (UnwState * const state);
-
-#endif /* UPGRADE_ARM_STACK_UNWIND */
-
-#endif
-
-/* END OF FILE */
diff --git a/src/crash-stack/wind/unwind.sym b/src/crash-stack/wind/unwind.sym
deleted file mode 100644
index d6ce9fd..0000000
--- a/src/crash-stack/wind/unwind.sym
+++ /dev/null
@@ -1,1285 +0,0 @@
-
-========================================================================
-
-** ELF Header Information
-
-    File Name: unwind.axf
-
-    Machine class: ELFCLASS32 (32-bit)
-    Data encoding: ELFDATA2LSB (Little endian)
-    Header version: EV_CURRENT (Current version)
-    Operating System ABI: none
-    ABI Version: 0
-    File Type: ET_EXEC (Executable) (2)
-    Machine: EM_ARM (ARM)
-
-    Image Entry point: 0x00008000
-    Flags: EF_ARM_HASENTRY + EF_ARM_SYMSARESORTED + EF_ARM_MAPSYMSFIRST (0x04000016)
-
-    ABI conformance : ABI for the ARM Architecture v1.0
-
-    Built with
-    ARM/Thumb Macro Assembler, RVCT2.2 [Build 503]
-    ARM Linker, RVCT2.2 [Build 503] 
-    ARM/Thumb C/C++ Compiler, RVCT2.2 [Build 559]
-    ARM/Thumb Macro Assembler, RVCT2.2 [Build 503]
-    ARM/Thumb C/C++ Compiler, RVCT2.2 [Build 503]
-    ARM Linker, RVCT2.2 [Build 559] 
-
-    Header size: 52 bytes (0x34)
-    Program header entry size: 32 bytes (0x20)
-    Section header entry size: 40 bytes (0x28)
-
-    Program header entries: 1
-    Section header entries: 10
-
-    Program header offset: 93848 (0x00016e98)
-    Section header offset: 93880 (0x00016eb8)
-
-    Section header string table index: 9
-
-========================================================================
-
-** Program header #0 (PT_LOAD) [PF_X + PF_W + PF_R + PF_ARM_ENTRY]
-    Size : 26020 bytes (25720 bytes in file)
-    Virtual address: 0x00008000
-
-
-========================================================================
-
-** Section #1 'ER_RO' (SHT_PROGBITS) [SHF_ALLOC + SHF_EXECINSTR]
-    Size   : 25712 bytes (alignment 4)
-    Address: 0x00008000
-
-
-** Section #2 'ER_RW' (SHT_PROGBITS) [SHF_ALLOC + SHF_WRITE]
-    Size   : 8 bytes (alignment 4)
-    Address: 0x0000e470
-
-
-** Section #3 'ER_ZI' (SHT_NOBITS) [SHF_ALLOC + SHF_WRITE]
-    Size   : 300 bytes (alignment 4)
-    Address: 0x0000e478
-
-
-** Section #4 '.debug_frame' (SHT_PROGBITS)
-    Size   : 6700 bytes
-
-
-** Section #5 '.symtab' (SHT_SYMTAB)
-    Size   : 18800 bytes (alignment 4)
-    String table '.strtab'
-    Last local symbol no. 921
-
-    Symbol table .symtab (1174 symbols, 921 local)
-
-      #  Symbol Name                Value      Bind  Sec  Type  Vis  Size
-    ========================================================================
-
-      1  $m                         0x00000253   Lc  Abs   --   De 
-      2  $a                         0x00008000   Lc    1   --   De 
-      3  $a                         0x00008008   Lc    1   --   De 
-      4  $d                         0x00008038   Lc    1   --   De 
-      5  $a                         0x00008040   Lc    1   --   De 
-      6  $t                         0x0000806c   Lc    1   --   De 
-      7  $a                         0x00008070   Lc    1   --   De 
-      8  $d                         0x0000807c   Lc    1   --   De 
-      9  $f                         0x0000807c   Lc    1   --   De 
-     10  $a                         0x00008080   Lc    1   --   De 
-     11  $a                         0x000080c4   Lc    1   --   De 
-     12  $p                         0x00008160   Lc    1   --   De 
-     13  $p                         0x00008184   Lc    1   --   De 
-     14  $p                         0x00008214   Lc    1   --   De 
-     15  $d                         0x00008238   Lc    1   --   De 
-     16  $a                         0x00008258   Lc    1   --   De 
-     17  $p                         0x000082a0   Lc    1   --   De 
-     18  $p                         0x000082d8   Lc    1   --   De 
-     19  $p                         0x000082f8   Lc    1   --   De 
-     20  $p                         0x0000832c   Lc    1   --   De 
-     21  $p                         0x000083dc   Lc    1   --   De 
-     22  $p                         0x00008440   Lc    1   --   De 
-     23  $p                         0x0000848c   Lc    1   --   De 
-     24  $p                         0x00008550   Lc    1   --   De 
-     25  $p                         0x000085a8   Lc    1   --   De 
-     26  $d                         0x000085d0   Lc    1   --   De 
-     27  $a                         0x000086ac   Lc    1   --   De 
-     28  $p                         0x000086c4   Lc    1   --   De 
-     29  $p                         0x000087cc   Lc    1   --   De 
-     30  $p                         0x000087f4   Lc    1   --   De 
-     31  $p                         0x00008838   Lc    1   --   De 
-     32  $p                         0x0000887c   Lc    1   --   De 
-     33  $p                         0x0000896c   Lc    1   --   De 
-     34  $p                         0x00008994   Lc    1   --   De 
-     35  $d                         0x0000899c   Lc    1   --   De 
-     36  $a                         0x00008a20   Lc    1   --   De 
-     37  $p                         0x00008a38   Lc    1   --   De 
-     38  $p                         0x00008a7c   Lc    1   --   De 
-     39  $p                         0x00008d30   Lc    1   --   De 
-     40  $d                         0x00008d3c   Lc    1   --   De 
-     41  $a                         0x00008d94   Lc    1   --   De 
-     42  $p                         0x00008e08   Lc    1   --   De 
-     43  $p                         0x00008e40   Lc    1   --   De 
-     44  $p                         0x00008e84   Lc    1   --   De 
-     45  $p                         0x00008eb8   Lc    1   --   De 
-     46  $p                         0x00008ee0   Lc    1   --   De 
-     47  $p                         0x00008f5c   Lc    1   --   De 
-     48  $p                         0x00008fa0   Lc    1   --   De 
-     49  $p                         0x00008ff4   Lc    1   --   De 
-     50  $p                         0x0000901c   Lc    1   --   De 
-     51  $p                         0x0000907c   Lc    1   --   De 
-     52  $p                         0x000090e8   Lc    1   --   De 
-     53  $d                         0x00009124   Lc    1   --   De 
-     54  $a                         0x0000920c   Lc    1   --   De 
-     55  $p                         0x00009228   Lc    1   --   De 
-     56  $p                         0x00009250   Lc    1   --   De 
-     57  $p                         0x00009288   Lc    1   --   De 
-     58  $p                         0x000092cc   Lc    1   --   De 
-     59  $p                         0x00009304   Lc    1   --   De 
-     60  $p                         0x00009374   Lc    1   --   De 
-     61  $p                         0x000093e4   Lc    1   --   De 
-     62  $p                         0x0000940c   Lc    1   --   De 
-     63  $p                         0x00009424   Lc    1   --   De 
-     64  $p                         0x00009440   Lc    1   --   De 
-     65  $d                         0x00009498   Lc    1   --   De 
-     66  $a                         0x00009558   Lc    1   --   De 
-     67  $p                         0x000095d4   Lc    1   --   De 
-     68  $p                         0x0000960c   Lc    1   --   De 
-     69  $p                         0x0000962c   Lc    1   --   De 
-     70  $p                         0x00009660   Lc    1   --   De 
-     71  $p                         0x000096b8   Lc    1   --   De 
-     72  $p                         0x000096d8   Lc    1   --   De 
-     73  $p                         0x0000970c   Lc    1   --   De 
-     74  $p                         0x00009788   Lc    1   --   De 
-     75  $p                         0x000097f0   Lc    1   --   De 
-     76  $p                         0x00009844   Lc    1   --   De 
-     77  $d                         0x0000984c   Lc    1   --   De 
-     78  $a                         0x0000994c   Lc    1   --   De 
-     79  $p                         0x00009a10   Lc    1   --   De 
-     80  $p                         0x00009a44   Lc    1   --   De 
-     81  $p                         0x00009a78   Lc    1   --   De 
-     82  $p                         0x00009aac   Lc    1   --   De 
-     83  $p                         0x00009ae0   Lc    1   --   De 
-     84  $p                         0x00009b14   Lc    1   --   De 
-     85  $p                         0x00009b48   Lc    1   --   De 
-     86  $p                         0x00009b7c   Lc    1   --   De 
-     87  $p                         0x00009bac   Lc    1   --   De 
-     88  $p                         0x00009bdc   Lc    1   --   De 
-     89  $p                         0x00009c0c   Lc    1   --   De 
-     90  $p                         0x00009c3c   Lc    1   --   De 
-     91  $p                         0x00009c6c   Lc    1   --   De 
-     92  $p                         0x00009c9c   Lc    1   --   De 
-     93  $p                         0x00009cd0   Lc    1   --   De 
-     94  $d                         0x00009cd8   Lc    1   --   De 
-     95  $a                         0x00009db4   Lc    1   --   De 
-     96  $p                         0x00009ddc   Lc    1   --   De 
-     97  $p                         0x00009e20   Lc    1   --   De 
-     98  $p                         0x00009e64   Lc    1   --   De 
-     99  $p                         0x00009e90   Lc    1   --   De 
-    100  $p                         0x00009eb4   Lc    1   --   De 
-    101  $p                         0x00009f20   Lc    1   --   De 
-    102  $p                         0x00009f5c   Lc    1   --   De 
-    103  $p                         0x00009f90   Lc    1   --   De 
-    104  $p                         0x0000a07c   Lc    1   --   De 
-    105  $d                         0x0000a104   Lc    1   --   De 
-    106  $a                         0x0000a1c4   Lc    1   --   De 
-    107  $p                         0x0000a2d4   Lc    1   --   De 
-    108  $p                         0x0000a43c   Lc    1   --   De 
-    109  $p                         0x0000a4b0   Lc    1   --   De 
-    110  $p                         0x0000a4e0   Lc    1   --   De 
-    111  $p                         0x0000a504   Lc    1   --   De 
-    112  $p                         0x0000a528   Lc    1   --   De 
-    113  $d                         0x0000a5b0   Lc    1   --   De 
-    114  $a                         0x0000a66c   Lc    1   --   De 
-    115  $p                         0x0000a6c0   Lc    1   --   De 
-    116  $p                         0x0000a6e8   Lc    1   --   De 
-    117  $p                         0x0000a730   Lc    1   --   De 
-    118  $p                         0x0000a7bc   Lc    1   --   De 
-    119  $p                         0x0000a7f8   Lc    1   --   De 
-    120  $p                         0x0000a830   Lc    1   --   De 
-    121  $p                         0x0000a84c   Lc    1   --   De 
-    122  $d                         0x0000a8b0   Lc    1   --   De 
-    123  $a                         0x0000a924   Lc    1   --   De 
-    124  $p                         0x0000ab1c   Lc    1   --   De 
-    125  $d                         0x0000ab44   Lc    1   --   De 
-    126  $a                         0x0000ab70   Lc    1   --   De 
-    127  $p                         0x0000acc0   Lc    1   --   De 
-    128  $d                         0x0000ad80   Lc    1   --   De 
-    129  $a                         0x0000ade8   Lc    1   --   De 
-    130  $d                         0x0000ae2c   Lc    1   --   De 
-    131  $a                         0x0000ae3c   Lc    1   --   De 
-    132  $t                         0x0000ae44   Lc    1   --   De 
-    133  $b                         0x0000ae4c   Lc    1   --   De 
-    134  $b                         0x0000ae52   Lc    1   --   De 
-    135  $b                         0x0000ae66   Lc    1   --   De 
-    136  $b                         0x0000ae6c   Lc    1   --   De 
-    137  $d                         0x0000ae72   Lc    1   --   De 
-    138  $a                         0x0000ae88   Lc    1   --   De 
-    139  $d                         0x0000af18   Lc    1   --   De 
-    140  $t                         0x0000af30   Lc    1   --   De 
-    141  $b                         0x0000af4c   Lc    1   --   De 
-    142  $b                         0x0000af74   Lc    1   --   De 
-    143  $t                         0x0000af84   Lc    1   --   De 
-    144  $b                         0x0000afc0   Lc    1   --   De 
-    145  $b                         0x0000afcc   Lc    1   --   De 
-    146  $b                         0x0000afd8   Lc    1   --   De 
-    147  $t                         0x0000afe4   Lc    1   --   De 
-    148  $b                         0x0000b00a   Lc    1   --   De 
-    149  $b                         0x0000b034   Lc    1   --   De 
-    150  $b                         0x0000b080   Lc    1   --   De 
-    151  $b                         0x0000b092   Lc    1   --   De 
-    152  $d                         0x0000b09e   Lc    1   --   De 
-    153  $t                         0x0000b0b4   Lc    1   --   De 
-    154  $b                         0x0000b0c6   Lc    1   --   De 
-    155  $b                         0x0000b0ec   Lc    1   --   De 
-    156  $b                         0x0000b0f6   Lc    1   --   De 
-    157  $b                         0x0000b110   Lc    1   --   De 
-    158  $d                         0x0000b11c   Lc    1   --   De 
-    159  $t                         0x0000b12c   Lc    1   --   De 
-    160  $b                         0x0000b13a   Lc    1   --   De 
-    161  $b                         0x0000b142   Lc    1   --   De 
-    162  $d                         0x0000b15a   Lc    1   --   De 
-    163  $f                         0x0000b160   Lc    1   --   De 
-    164  $a                         0x0000b164   Lc    1   --   De 
-    165  $t                         0x0000b16c   Lc    1   --   De 
-    166  $b                         0x0000b176   Lc    1   --   De 
-    167  $b                         0x0000b17e   Lc    1   --   De 
-    168  $d                         0x0000b194   Lc    1   --   De 
-    169  $f                         0x0000b198   Lc    1   --   De 
-    170  $a                         0x0000b19c   Lc    1   --   De 
-    171  $t                         0x0000b1a4   Lc    1   --   De 
-    172  $b                         0x0000b1b2   Lc    1   --   De 
-    173  $b                         0x0000b1ba   Lc    1   --   De 
-    174  $d                         0x0000b1d2   Lc    1   --   De 
-    175  $f                         0x0000b1d8   Lc    1   --   De 
-    176  $a                         0x0000b1dc   Lc    1   --   De 
-    177  $t                         0x0000b1e4   Lc    1   --   De 
-    178  $b                         0x0000b1f4   Lc    1   --   De 
-    179  $b                         0x0000b1fe   Lc    1   --   De 
-    180  $d                         0x0000b20c   Lc    1   --   De 
-    181  $f                         0x0000b20c   Lc    1   --   De 
-    182  $a                         0x0000b210   Lc    1   --   De 
-    183  $t                         0x0000b27c   Lc    1   --   De 
-    184  $a                         0x0000b280   Lc    1   --   De 
-    185  $a                         0x0000b3e4   Lc    1   --   De 
-    186  $b                         0x0000b428   Lc    1   --   De 
-    187  $t                         0x0000b428   Lc    1   --   De 
-    188  $d                         0x0000b42c   Lc    1   --   De 
-    189  $f                         0x0000b42c   Lc    1   --   De 
-    190  $a                         0x0000b430   Lc    1   --   De 
-    191  $a                         0x0000b44c   Lc    1   --   De 
-    192  $t                         0x0000b450   Lc    1   --   De 
-    193  $t                         0x0000b47c   Lc    1   --   De 
-    194  $b                         0x0000b49e   Lc    1   --   De 
-    195  $b                         0x0000b4da   Lc    1   --   De 
-    196  $b                         0x0000b4f8   Lc    1   --   De 
-    197  $b                         0x0000b50e   Lc    1   --   De 
-    198  $b                         0x0000b52c   Lc    1   --   De 
-    199  $d                         0x0000b538   Lc    1   --   De 
-    200  $t                         0x0000b53c   Lc    1   --   De 
-    201  $b                         0x0000b574   Lc    1   --   De 
-    202  $b                         0x0000b584   Lc    1   --   De 
-    203  $b                         0x0000b59e   Lc    1   --   De 
-    204  $b                         0x0000b5aa   Lc    1   --   De 
-    205  $b                         0x0000b5c6   Lc    1   --   De 
-    206  $b                         0x0000b5da   Lc    1   --   De 
-    207  $t                         0x0000b5e8   Lc    1   --   De 
-    208  $b                         0x0000b5fe   Lc    1   --   De 
-    209  $b                         0x0000b620   Lc    1   --   De 
-    210  $b                         0x0000b658   Lc    1   --   De 
-    211  $b                         0x0000b66a   Lc    1   --   De 
-    212  $d                         0x0000b676   Lc    1   --   De 
-    213  $t                         0x0000b680   Lc    1   --   De 
-    214  $b                         0x0000b69c   Lc    1   --   De 
-    215  $b                         0x0000b6a6   Lc    1   --   De 
-    216  $b                         0x0000b6d0   Lc    1   --   De 
-    217  $b                         0x0000b6ea   Lc    1   --   De 
-    218  $b                         0x0000b6fc   Lc    1   --   De 
-    219  $d                         0x0000b708   Lc    1   --   De 
-    220  $t                         0x0000b718   Lc    1   --   De 
-    221  $t                         0x0000b73c   Lc    1   --   De 
-    222  $b                         0x0000b75c   Lc    1   --   De 
-    223  $d                         0x0000b766   Lc    1   --   De 
-    224  $f                         0x0000b768   Lc    1   --   De 
-    225  $f                         0x0000b76c   Lc    1   --   De 
-    226  $t                         0x0000b770   Lc    1   --   De 
-    227  $t                         0x0000b77a   Lc    1   --   De 
-    228  $b                         0x0000b784   Lc    1   --   De 
-    229  $b                         0x0000b790   Lc    1   --   De 
-    230  $t                         0x0000b79c   Lc    1   --   De 
-    231  $b                         0x0000b7a6   Lc    1   --   De 
-    232  $t                         0x0000b7c4   Lc    1   --   De 
-    233  $b                         0x0000b7ce   Lc    1   --   De 
-    234  $b                         0x0000b7ea   Lc    1   --   De 
-    235  $b                         0x0000b80a   Lc    1   --   De 
-    236  $b                         0x0000b824   Lc    1   --   De 
-    237  $b                         0x0000b844   Lc    1   --   De 
-    238  $b                         0x0000b862   Lc    1   --   De 
-    239  $b                         0x0000b884   Lc    1   --   De 
-    240  $b                         0x0000b890   Lc    1   --   De 
-    241  $b                         0x0000b8d8   Lc    1   --   De 
-    242  $b                         0x0000b914   Lc    1   --   De 
-    243  $b                         0x0000b962   Lc    1   --   De 
-    244  $b                         0x0000b968   Lc    1   --   De 
-    245  $b                         0x0000b97a   Lc    1   --   De 
-    246  $b                         0x0000b988   Lc    1   --   De 
-    247  $b                         0x0000b992   Lc    1   --   De 
-    248  $b                         0x0000b9ac   Lc    1   --   De 
-    249  $b                         0x0000b9b2   Lc    1   --   De 
-    250  $b                         0x0000b9ba   Lc    1   --   De 
-    251  $b                         0x0000b9d2   Lc    1   --   De 
-    252  $b                         0x0000b9d8   Lc    1   --   De 
-    253  $b                         0x0000ba2c   Lc    1   --   De 
-    254  $b                         0x0000ba5c   Lc    1   --   De 
-    255  $b                         0x0000ba62   Lc    1   --   De 
-    256  $b                         0x0000ba7c   Lc    1   --   De 
-    257  $b                         0x0000ba98   Lc    1   --   De 
-    258  $b                         0x0000baa2   Lc    1   --   De 
-    259  $b                         0x0000bab0   Lc    1   --   De 
-    260  $b                         0x0000bac8   Lc    1   --   De 
-    261  $b                         0x0000bad0   Lc    1   --   De 
-    262  $b                         0x0000bae0   Lc    1   --   De 
-    263  $b                         0x0000baea   Lc    1   --   De 
-    264  $b                         0x0000baf4   Lc    1   --   De 
-    265  $b                         0x0000bb0a   Lc    1   --   De 
-    266  $b                         0x0000bb20   Lc    1   --   De 
-    267  $b                         0x0000bb32   Lc    1   --   De 
-    268  $b                         0x0000bb42   Lc    1   --   De 
-    269  $b                         0x0000bb4e   Lc    1   --   De 
-    270  $b                         0x0000bb5e   Lc    1   --   De 
-    271  $b                         0x0000bb6c   Lc    1   --   De 
-    272  $b                         0x0000bb7c   Lc    1   --   De 
-    273  $b                         0x0000bb8a   Lc    1   --   De 
-    274  $b                         0x0000bb9a   Lc    1   --   De 
-    275  $b                         0x0000bbaa   Lc    1   --   De 
-    276  $b                         0x0000bbba   Lc    1   --   De 
-    277  $b                         0x0000bbc8   Lc    1   --   De 
-    278  $b                         0x0000bbd8   Lc    1   --   De 
-    279  $b                         0x0000bbe6   Lc    1   --   De 
-    280  $d                         0x0000bbf0   Lc    1   --   De 
-    281  $t                         0x0000bc1c   Lc    1   --   De 
-    282  $b                         0x0000bc22   Lc    1   --   De 
-    283  $b                         0x0000bc32   Lc    1   --   De 
-    284  $b                         0x0000bc3a   Lc    1   --   De 
-    285  $b                         0x0000bc42   Lc    1   --   De 
-    286  $b                         0x0000bc48   Lc    1   --   De 
-    287  $b                         0x0000bc52   Lc    1   --   De 
-    288  $b                         0x0000bc58   Lc    1   --   De 
-    289  $b                         0x0000bc64   Lc    1   --   De 
-    290  $d                         0x0000bc6a   Lc    1   --   De 
-    291  $t                         0x0000bc78   Lc    1   --   De 
-    292  $a                         0x0000bc7c   Lc    1   --   De 
-    293  $t                         0x0000bca8   Lc    1   --   De 
-    294  $a                         0x0000bcac   Lc    1   --   De 
-    295  $t                         0x0000bcb8   Lc    1   --   De 
-    296  $t                         0x0000bcc8   Lc    1   --   De 
-    297  $b                         0x0000bcce   Lc    1   --   De 
-    298  $t                         0x0000bd44   Lc    1   --   De 
-    299  $a                         0x0000bd48   Lc    1   --   De 
-    300  $d                         0x0000bd58   Lc    1   --   De 
-    301  $f                         0x0000bd58   Lc    1   --   De 
-    302  $t                         0x0000bd60   Lc    1   --   De 
-    303  $a                         0x0000bd64   Lc    1   --   De 
-    304  $a                         0x0000bd6c   Lc    1   --   De 
-    305  $t                         0x0000bd78   Lc    1   --   De 
-    306  $a                         0x0000bd7c   Lc    1   --   De 
-    307  $t                         0x0000bd98   Lc    1   --   De 
-    308  $b                         0x0000bda4   Lc    1   --   De 
-    309  $b                         0x0000bdb2   Lc    1   --   De 
-    310  $b                         0x0000bdcc   Lc    1   --   De 
-    311  $b                         0x0000bde0   Lc    1   --   De 
-    312  $b                         0x0000bdf0   Lc    1   --   De 
-    313  $b                         0x0000bdfc   Lc    1   --   De 
-    314  $b                         0x0000be0a   Lc    1   --   De 
-    315  $b                         0x0000be1c   Lc    1   --   De 
-    316  $b                         0x0000be2a   Lc    1   --   De 
-    317  $b                         0x0000be38   Lc    1   --   De 
-    318  $b                         0x0000be40   Lc    1   --   De 
-    319  $t                         0x0000be4a   Lc    1   --   De 
-    320  $b                         0x0000be52   Lc    1   --   De 
-    321  $b                         0x0000be5a   Lc    1   --   De 
-    322  $t                         0x0000be68   Lc    1   --   De 
-    323  $a                         0x0000be6c   Lc    1   --   De 
-    324  $t                         0x0000bf0c   Lc    1   --   De 
-    325  $b                         0x0000bf2c   Lc    1   --   De 
-    326  $b                         0x0000bf46   Lc    1   --   De 
-    327  $b                         0x0000bf58   Lc    1   --   De 
-    328  $b                         0x0000bf8a   Lc    1   --   De 
-    329  $b                         0x0000bfc4   Lc    1   --   De 
-    330  $b                         0x0000bfdc   Lc    1   --   De 
-    331  $b                         0x0000c016   Lc    1   --   De 
-    332  $b                         0x0000c05c   Lc    1   --   De 
-    333  $b                         0x0000c0be   Lc    1   --   De 
-    334  $b                         0x0000c100   Lc    1   --   De 
-    335  $b                         0x0000c108   Lc    1   --   De 
-    336  $b                         0x0000c118   Lc    1   --   De 
-    337  $b                         0x0000c120   Lc    1   --   De 
-    338  $b                         0x0000c138   Lc    1   --   De 
-    339  $b                         0x0000c164   Lc    1   --   De 
-    340  $b                         0x0000c182   Lc    1   --   De 
-    341  $b                         0x0000c19c   Lc    1   --   De 
-    342  $b                         0x0000c1a8   Lc    1   --   De 
-    343  $b                         0x0000c1c6   Lc    1   --   De 
-    344  $b                         0x0000c1e4   Lc    1   --   De 
-    345  $d                         0x0000c1f4   Lc    1   --   De 
-    346  $t                         0x0000c1f8   Lc    1   --   De 
-    347  $b                         0x0000c20a   Lc    1   --   De 
-    348  $b                         0x0000c214   Lc    1   --   De 
-    349  $b                         0x0000c2b6   Lc    1   --   De 
-    350  $b                         0x0000c2be   Lc    1   --   De 
-    351  $b                         0x0000c2de   Lc    1   --   De 
-    352  $b                         0x0000c2ee   Lc    1   --   De 
-    353  $b                         0x0000c316   Lc    1   --   De 
-    354  $b                         0x0000c334   Lc    1   --   De 
-    355  $b                         0x0000c37e   Lc    1   --   De 
-    356  $b                         0x0000c394   Lc    1   --   De 
-    357  $b                         0x0000c3a2   Lc    1   --   De 
-    358  $b                         0x0000c3fa   Lc    1   --   De 
-    359  $b                         0x0000c40a   Lc    1   --   De 
-    360  $b                         0x0000c432   Lc    1   --   De 
-    361  $b                         0x0000c440   Lc    1   --   De 
-    362  $b                         0x0000c4be   Lc    1   --   De 
-    363  $b                         0x0000c5ec   Lc    1   --   De 
-    364  $d                         0x0000c66a   Lc    1   --   De 
-    365  $t                         0x0000c698   Lc    1   --   De 
-    366  $b                         0x0000c70c   Lc    1   --   De 
-    367  $b                         0x0000c73e   Lc    1   --   De 
-    368  $b                         0x0000c762   Lc    1   --   De 
-    369  $b                         0x0000c79a   Lc    1   --   De 
-    370  $b                         0x0000c7aa   Lc    1   --   De 
-    371  $b                         0x0000c7bc   Lc    1   --   De 
-    372  $b                         0x0000c7de   Lc    1   --   De 
-    373  $b                         0x0000c7f6   Lc    1   --   De 
-    374  $b                         0x0000c810   Lc    1   --   De 
-    375  $b                         0x0000c822   Lc    1   --   De 
-    376  $t                         0x0000c82a   Lc    1   --   De 
-    377  $b                         0x0000c83c   Lc    1   --   De 
-    378  $t                         0x0000c84a   Lc    1   --   De 
-    379  $t                         0x0000c854   Lc    1   --   De 
-    380  $b                         0x0000c864   Lc    1   --   De 
-    381  $b                         0x0000c886   Lc    1   --   De 
-    382  $b                         0x0000c896   Lc    1   --   De 
-    383  $b                         0x0000c8a2   Lc    1   --   De 
-    384  $b                         0x0000c8b0   Lc    1   --   De 
-    385  $b                         0x0000c8c6   Lc    1   --   De 
-    386  $b                         0x0000c8d0   Lc    1   --   De 
-    387  $b                         0x0000c8e0   Lc    1   --   De 
-    388  $b                         0x0000c8f2   Lc    1   --   De 
-    389  $d                         0x0000c8fe   Lc    1   --   De 
-    390  $t                         0x0000c908   Lc    1   --   De 
-    391  $b                         0x0000c91e   Lc    1   --   De 
-    392  $b                         0x0000c980   Lc    1   --   De 
-    393  $b                         0x0000c9b4   Lc    1   --   De 
-    394  $b                         0x0000c9ce   Lc    1   --   De 
-    395  $b                         0x0000c9da   Lc    1   --   De 
-    396  $b                         0x0000c9fa   Lc    1   --   De 
-    397  $b                         0x0000ca10   Lc    1   --   De 
-    398  $b                         0x0000ca34   Lc    1   --   De 
-    399  $b                         0x0000ca6c   Lc    1   --   De 
-    400  $b                         0x0000cb18   Lc    1   --   De 
-    401  $b                         0x0000cb5e   Lc    1   --   De 
-    402  $d                         0x0000cb6c   Lc    1   --   De 
-    403  $t                         0x0000cb78   Lc    1   --   De 
-    404  $b                         0x0000cb8c   Lc    1   --   De 
-    405  $b                         0x0000cba6   Lc    1   --   De 
-    406  $b                         0x0000cbb8   Lc    1   --   De 
-    407  $b                         0x0000ccc4   Lc    1   --   De 
-    408  $b                         0x0000ccce   Lc    1   --   De 
-    409  $b                         0x0000ccd6   Lc    1   --   De 
-    410  $d                         0x0000ccde   Lc    1   --   De 
-    411  $t                         0x0000cce4   Lc    1   --   De 
-    412  $b                         0x0000ccf6   Lc    1   --   De 
-    413  $b                         0x0000cd44   Lc    1   --   De 
-    414  $d                         0x0000cd62   Lc    1   --   De 
-    415  $t                         0x0000cd68   Lc    1   --   De 
-    416  $b                         0x0000cd70   Lc    1   --   De 
-    417  $b                         0x0000cd92   Lc    1   --   De 
-    418  $t                         0x0000cdb2   Lc    1   --   De 
-    419  $b                         0x0000cdb6   Lc    1   --   De 
-    420  $b                         0x0000cdbc   Lc    1   --   De 
-    421  $t                         0x0000cdc8   Lc    1   --   De 
-    422  $b                         0x0000cdce   Lc    1   --   De 
-    423  $b                         0x0000cdd4   Lc    1   --   De 
-    424  $d                         0x0000cdde   Lc    1   --   De 
-    425  $t                         0x0000cde4   Lc    1   --   De 
-    426  $a                         0x0000cde8   Lc    1   --   De 
-    427  $a                         0x0000ce40   Lc    1   --   De 
-    428  $a                         0x0000cf44   Lc    1   --   De 
-    429  $t                         0x0000cf4c   Lc    1   --   De 
-    430  $b                         0x0000cf54   Lc    1   --   De 
-    431  $b                         0x0000cf5e   Lc    1   --   De 
-    432  $b                         0x0000cf66   Lc    1   --   De 
-    433  $b                         0x0000cf76   Lc    1   --   De 
-    434  $b                         0x0000cf7a   Lc    1   --   De 
-    435  $b                         0x0000cf7e   Lc    1   --   De 
-    436  $b                         0x0000cf86   Lc    1   --   De 
-    437  $b                         0x0000cf8c   Lc    1   --   De 
-    438  $b                         0x0000cf98   Lc    1   --   De 
-    439  $b                         0x0000cfa6   Lc    1   --   De 
-    440  $b                         0x0000cfb4   Lc    1   --   De 
-    441  $b                         0x0000cfc2   Lc    1   --   De 
-    442  $b                         0x0000cfcc   Lc    1   --   De 
-    443  $b                         0x0000cfd0   Lc    1   --   De 
-    444  $b                         0x0000cfd4   Lc    1   --   De 
-    445  $b                         0x0000cfd8   Lc    1   --   De 
-    446  $b                         0x0000cfdc   Lc    1   --   De 
-    447  $b                         0x0000cfe0   Lc    1   --   De 
-    448  $b                         0x0000cfe4   Lc    1   --   De 
-    449  $b                         0x0000cfe8   Lc    1   --   De 
-    450  $b                         0x0000cfec   Lc    1   --   De 
-    451  $b                         0x0000d008   Lc    1   --   De 
-    452  $b                         0x0000d00c   Lc    1   --   De 
-    453  $b                         0x0000d010   Lc    1   --   De 
-    454  $a                         0x0000d01c   Lc    1   --   De 
-    455  $a                         0x0000d020   Lc    1   --   De 
-    456  $a                         0x0000d02c   Lc    1   --   De 
-    457  $a                         0x0000d03c   Lc    1   --   De 
-    458  $t                         0x0000d040   Lc    1   --   De 
-    459  $a                         0x0000d044   Lc    1   --   De 
-    460  $t                         0x0000d050   Lc    1   --   De 
-    461  $a                         0x0000d054   Lc    1   --   De 
-    462  $a                         0x0000d060   Lc    1   --   De 
-    463  $d                         0x0000d0a8   Lc    1   --   De 
-    464  $f                         0x0000d0a8   Lc    1   --   De 
-    465  $t                         0x0000d0b0   Lc    1   --   De 
-    466  $a                         0x0000d0b4   Lc    1   --   De 
-    467  $d                         0x0000d0bc   Lc    1   --   De 
-    468  $a                         0x0000d0c0   Lc    1   --   De 
-    469  $t                         0x0000d0c4   Lc    1   --   De 
-    470  $a                         0x0000d0c8   Lc    1   --   De 
-    471  $d                         0x0000d0dc   Lc    1   --   De 
-    472  $f                         0x0000d0dc   Lc    1   --   De 
-    473  $t                         0x0000d0e0   Lc    1   --   De 
-    474  $t                         0x0000d0e4   Lc    1   --   De 
-    475  $b                         0x0000d14c   Lc    1   --   De 
-    476  $b                         0x0000d15c   Lc    1   --   De 
-    477  $t                         0x0000d160   Lc    1   --   De 
-    478  $b                         0x0000d1a0   Lc    1   --   De 
-    479  $t                         0x0000d1a4   Lc    1   --   De 
-    480  $b                         0x0000d1d0   Lc    1   --   De 
-    481  $t                         0x0000d1dc   Lc    1   --   De 
-    482  $b                         0x0000d200   Lc    1   --   De 
-    483  $b                         0x0000d230   Lc    1   --   De 
-    484  $b                         0x0000d26e   Lc    1   --   De 
-    485  $b                         0x0000d28a   Lc    1   --   De 
-    486  $b                         0x0000d296   Lc    1   --   De 
-    487  $d                         0x0000d2a6   Lc    1   --   De 
-    488  $t                         0x0000d2ac   Lc    1   --   De 
-    489  $b                         0x0000d2b6   Lc    1   --   De 
-    490  $t                         0x0000d2d0   Lc    1   --   De 
-    491  $b                         0x0000d2de   Lc    1   --   De 
-    492  $d                         0x0000d2f4   Lc    1   --   De 
-    493  $a                         0x0000d2fc   Lc    1   --   De 
-    494  $t                         0x0000d304   Lc    1   --   De 
-    495  $b                         0x0000d310   Lc    1   --   De 
-    496  $b                         0x0000d31e   Lc    1   --   De 
-    497  $b                         0x0000d330   Lc    1   --   De 
-    498  $t                         0x0000d338   Lc    1   --   De 
-    499  $d                         0x0000d37c   Lc    1   --   De 
-    500  $t                         0x0000d380   Lc    1   --   De 
-    501  $a                         0x0000d384   Lc    1   --   De 
-    502  $a                         0x0000d394   Lc    1   --   De 
-    503  $t                         0x0000d398   Lc    1   --   De 
-    504  $a                         0x0000d39c   Lc    1   --   De 
-    505  $t                         0x0000d3e0   Lc    1   --   De 
-    506  $a                         0x0000d3e4   Lc    1   --   De 
-    507  $a                         0x0000d45c   Lc    1   --   De 
-    508  $t                         0x0000d470   Lc    1   --   De 
-    509  $b                         0x0000d47e   Lc    1   --   De 
-    510  $d                         0x0000d494   Lc    1   --   De 
-    511  $t                         0x0000d49c   Lc    1   --   De 
-    512  $b                         0x0000d4a2   Lc    1   --   De 
-    513  $b                         0x0000d4a6   Lc    1   --   De 
-    514  $b                         0x0000d4ac   Lc    1   --   De 
-    515  $t                         0x0000d4b8   Lc    1   --   De 
-    516  $b                         0x0000d518   Lc    1   --   De 
-    517  $b                         0x0000d526   Lc    1   --   De 
-    518  $b                         0x0000d532   Lc    1   --   De 
-    519  $d                         0x0000d53e   Lc    1   --   De 
-    520  $t                         0x0000d5c0   Lc    1   --   De 
-    521  $a                         0x0000d5c4   Lc    1   --   De 
-    522  $d                         0x0000d660   Lc    1   --   De 
-    523  $a                         0x0000d664   Lc    1   --   De 
-    524  $d                         0x0000d6a0   Lc    1   --   De 
-    525  $t                         0x0000d6a4   Lc    1   --   De 
-    526  $a                         0x0000d6b4   Lc    1   --   De 
-    527  $t                         0x0000d6d0   Lc    1   --   De 
-    528  $a                         0x0000d6d4   Lc    1   --   De 
-    529  $a                         0x0000d70c   Lc    1   --   De 
-    530  $a                         0x0000d760   Lc    1   --   De 
-    531  $a                         0x0000d7c8   Lc    1   --   De 
-    532  $d                         0x0000da94   Lc    1   --   De 
-    533  $a                         0x0000db14   Lc    1   --   De 
-    534  $t                         0x0000dbf0   Lc    1   --   De 
-    535  $a                         0x0000dbf4   Lc    1   --   De 
-    536  $t                         0x0000dc28   Lc    1   --   De 
-    537  $a                         0x0000dc2c   Lc    1   --   De 
-    538  $a                         0x0000dc60   Lc    1   --   De 
-    539  $a                         0x0000dec8   Lc    1   --   De 
-    540  $d                         0x0000ded0   Lc    1   --   De 
-    541  $f                         0x0000ded0   Lc    1   --   De 
-    542  $t                         0x0000ded4   Lc    1   --   De 
-    543  $a                         0x0000ded8   Lc    1   --   De 
-    544  $t                         0x0000dedc   Lc    1   --   De 
-    545  $a                         0x0000dee0   Lc    1   --   De 
-    546  $a                         0x0000dee4   Lc    1   --   De 
-    547  $d                         0x0000deec   Lc    1   --   De 
-    548  $f                         0x0000deec   Lc    1   --   De 
-    549  $t                         0x0000def0   Lc    1   --   De 
-    550  $a                         0x0000def4   Lc    1   --   De 
-    551  $a                         0x0000def8   Lc    1   --   De 
-    552  $d                         0x0000df00   Lc    1   --   De 
-    553  $f                         0x0000df00   Lc    1   --   De 
-    554  $a                         0x0000df04   Lc    1   --   De 
-    555  $a                         0x0000df08   Lc    1   --   De 
-    556  $d                         0x0000df14   Lc    1   --   De 
-    557  $t                         0x0000df18   Lc    1   --   De 
-    558  $a                         0x0000df1c   Lc    1   --   De 
-    559  $t                         0x0000df34   Lc    1   --   De 
-    560  $a                         0x0000df38   Lc    1   --   De 
-    561  $t                         0x0000df40   Lc    1   --   De 
-    562  $a                         0x0000df44   Lc    1   --   De 
-    563  $t                         0x0000df48   Lc    1   --   De 
-    564  $a                         0x0000df4c   Lc    1   --   De 
-    565  $a                         0x0000df50   Lc    1   --   De 
-    566  $d                         0x0000dfa4   Lc    1   --   De 
-    567  $a                         0x0000dfac   Lc    1   --   De 
-    568  $a                         0x0000e020   Lc    1   --   De 
-    569  $d.realdata                0x0000e05c   Lc    1   --   De 
-    570  $d.realdata                0x0000e09c   Lc    1   --   De 
-    571  $d.realdata                0x0000e0ac   Lc    1   --   De 
-    572  $d.realdata                0x0000e0c0   Lc    1   --   De 
-    573  $f                         0x0000e0c0   Lc    1   --   De 
-    574  $f                         0x0000e0c4   Lc    1   --   De 
-    575  $f                         0x0000e0c8   Lc    1   --   De 
-    576  $f                         0x0000e0cc   Lc    1   --   De 
-    577  $f                         0x0000e0d0   Lc    1   --   De 
-    578  $d.realdata                0x0000e0d4   Lc    1   --   De 
-    579  $d.realdata                0x0000e0f8   Lc    1   --   De 
-    580  $d.realdata                0x0000e0fc   Lc    1   --   De 
-    581  $d.realdata                0x0000e100   Lc    1   --   De 
-    582  $d.realdata                0x0000e104   Lc    1   --   De 
-    583  $d.realdata                0x0000e108   Lc    1   --   De 
-    584  $d.realdata                0x0000e11c   Lc    1   --   De 
-    585  $d.realdata                0x0000e1b0   Lc    1   --   De 
-    586  $d.realdata                0x0000e1b4   Lc    1   --   De 
-    587  $d.realdata                0x0000e1d0   Lc    1   --   De 
-    588  $d.realdata                0x0000e2dd   Lc    1   --   De 
-    589  $d.realdata                0x0000e41f   Lc    1   --   De 
-    590  $d.realdata                0x0000e460   Lc    1   --   De 
-    591  $d.realdata                0x0000e470   Lc    2   --   De 
-    592  $f                         0x0000e470   Lc    2   --   De 
-    593  $d.realdata                0x0000e474   Lc    2   --   De 
-    594  $d.realdata                0x0000e478   Lc    3   --   De 
-    595  $d.realdata                0x0000e544   Lc    3   --   De 
-    596  unwarminder.c              0x00000000   Lc  Abs  File  De 
-    597  .text                      0x00008080   Lc    1  Sect  De   0x44
-    598  unwarm.c                   0x00000000   Lc  Abs  File  De 
-    599  .text                      0x000080c4   Lc    1  Sect  De   0x194
-    600  unwarm_thumb.c             0x00000000   Lc  Abs  File  De 
-    601  .text                      0x00008258   Lc    1  Sect  De   0x1300
-    602  .constdata                 0x0000e05c   Lc    1  Sect  De   0x40
-    603  .conststring               0x0000e41f   Lc    1  Sect  De   0x40
-    604  signExtend11               0x00008258   Lc    1  Code  De   0x18
-    605  |L1.964|                   0x0000861c   Lc    1  Data  De 
-    606  |L1.972|                   0x00008624   Lc    1  Data  De 
-    607  |L1.1888|                  0x000089b8   Lc    1  Data  De 
-    608  .constdata$1               0x0000e05c   Lc    1  Data  De 
-    609  mnu@UnwStartThumb_0        0x0000e05c   Lc    1  Data  De   0x40
-    610  .conststring$3             0x0000e41f   Lc    1  Data  De 
-    611  unwarm_arm.c               0x00000000   Lc  Abs  File  De 
-    612  .text                      0x00009558   Lc    1  Sect  De   0x13cc
-    613  .constdata                 0x0000e09c   Lc    1  Sect  De   0x10
-    614  isDataProc                 0x00009558   Lc    1  Code  De   0x4c
-    615  |L1.836|                   0x0000989c   Lc    1  Data  De 
-    616  |L1.844|                   0x000098a4   Lc    1  Data  De 
-    617  .constdata$1               0x0000e09c   Lc    1  Data  De 
-    618  unwarmmem.c                0x00000000   Lc  Abs  File  De 
-    619  .text                      0x0000a924   Lc    1  Sect  De   0x24c
-    620  memHashIndex               0x0000a924   Lc    1  Code  De   0x88
-    621  simplefunc.c               0x00000000   Lc  Abs  File  De 
-    622  .text                      0x0000ae44   Lc    1  Sect  De   0x44
-    623  .constdata                 0x0000e0ac   Lc    1  Sect  De   0x14
-    624  .text                      0x0000ab70   Lc    1  Sect  De   0x2cc
-    625  .data                      0x0000e470   Lc    2  Sect  De   0x4
-    626  i.__ARM_get_argv           0x0000df04   Lc    1  Sect  De   0x4
-    627  .constdata$1               0x0000e0ac   Lc    1  Data  De 
-    628  .data$0                    0x0000e470   Lc    2  Data  De 
-    629  runFunc                    0x0000e470   Lc    2  Data  De   0x4
-    630  client.c                   0x00000000   Lc  Abs  File  De 
-    631  .text                      0x0000ae88   Lc    1  Sect  De   0xa8
-    632  .constdata                 0x0000e0c0   Lc    1  Sect  De   0x14
-    633  CliReport                  0x0000ae88   Lc    1  Code  De   0x50
-    634  CliReadW                   0x0000aed8   Lc    1  Code  De   0x10
-    635  CliReadH                   0x0000aee8   Lc    1  Code  De   0x10
-    636  CliReadB                   0x0000aef8   Lc    1  Code  De   0x10
-    637  .constdata$7               0x0000e0c0   Lc    1  Data  De 
-    638  dc.s                       0x00000000   Lc  Abs  File  De 
-    639  ../../printf.c             0x00000000   Lc  Abs  File  De 
-    640  .text                      0x0000af30   Lc    1  Sect  De   0x54
-    641  ../../printf.c             0x00000000   Lc  Abs  File  De 
-    642  .text                      0x0000af84   Lc    1  Sect  De   0x5e
-    643  ../../printf.c             0x00000000   Lc  Abs  File  De 
-    644  .text                      0x0000afe4   Lc    1  Sect  De   0xd0
-    645  .constdata                 0x0000e0d4   Lc    1  Sect  De   0x22
-    646  .constdata$1               0x0000e0d4   Lc    1  Data  De 
-    647  lc_hextab@_printf_longlong_hex_0
-                                    0x0000e0d4   Lc    1  Data  De   0x11
-    648  uc_hextab@_printf_longlong_hex_1
-                                    0x0000e0e5   Lc    1  Data  De   0x11
-    649  ../../printf.c             0x00000000   Lc  Abs  File  De 
-    650  .text                      0x0000b0b4   Lc    1  Sect  De   0x78
-    651  ../../printf.c             0x00000000   Lc  Abs  File  De 
-    652  .text                      0x0000b12c   Lc    1  Sect  De   0x38
-    653  ../../printf.c             0x00000000   Lc  Abs  File  De 
-    654  .text                      0x0000b16c   Lc    1  Sect  De   0x30
-    655  ../../printf.c             0x00000000   Lc  Abs  File  De 
-    656  .text                      0x0000b1a4   Lc    1  Sect  De   0x38
-    657  ../../printf.c             0x00000000   Lc  Abs  File  De 
-    658  .text                      0x0000b1e4   Lc    1  Sect  De   0x2c
-    659  ../../memcpset.s           0x00000000   Lc  Abs  File  De 
-    660  .text                      0x0000b210   Lc    1  Sect  De   0x6c
-    661  _memcpy_aligned_loop       0x0000b21c   Lc    1  Code  De 
-    662  _memcpy_small              0x0000b234   Lc    1  Code  De 
-    663  ../../division.s           0x00000000   Lc  Abs  File  De 
-    664  .text_udiv                 0x0000d6b4   Lc    1  Sect  De   0x1c
-    665  .text                      0x0000b280   Lc    1  Sect  De   0x164
-    666  __arm_div8                 0x0000b2ac   Lc    1  Code  De 
-    667  __arm_div4                 0x0000b2dc   Lc    1  Code  De 
-    668  __arm_div1                 0x0000b300   Lc    1  Code  De 
-    669  __arm_div_negative         0x0000b310   Lc    1  Code  De 
-    670  __arm_div_large            0x0000b330   Lc    1  Code  De 
-    671  ../../angel/startup.s      0x00000000   Lc  Abs  File  De 
-    672  !!!main                    0x00008000   Lc    1  Sect  De   0x8
-    673  ../../angel/kernel.s       0x00000000   Lc  Abs  File  De 
-    674  .text                      0x0000b3e4   Lc    1  Sect  De   0x68
-    675  mainaddruse                0x0000b40c   Lc    1  Code  De   0x4
-    676  thumbmainreturn            0x0000b429   Lc    1  Code  De 
-    677  mainaddr                   0x0000b42c   Lc    1  Data  De   0x4
-    678  __rt_abort1                0x0000b448   Lc    1  Code  De 
-    679  ../../angel/rt.s           0x00000000   Lc  Abs  File  De 
-    680  .text                      0x0000b44c   Lc    1  Sect  De   0x4
-    681  ../../printf.c             0x00000000   Lc  Abs  File  De 
-    682  .text                      0x0000b450   Lc    1  Sect  De   0x2c
-    683  ../../printf.c             0x00000000   Lc  Abs  File  De 
-    684  .constdata                 0x0000e0f8   Lc    1  Sect  De   0x4
-    685  .text                      0x0000b47c   Lc    1  Sect  De   0xc0
-    686  .constdata$1               0x0000e0f8   Lc    1  Data  De 
-    687  initial_mbstate@_printf_wctomb_0
-                                    0x0000e0f8   Lc    1  Data  De   0x4
-    688  ../../printf.c             0x00000000   Lc  Abs  File  De 
-    689  .text                      0x0000b53c   Lc    1  Sect  De   0xaa
-    690  ../../printf.c             0x00000000   Lc  Abs  File  De 
-    691  .text                      0x0000b5e8   Lc    1  Sect  De   0x98
-    692  ../../printf.c             0x00000000   Lc  Abs  File  De 
-    693  .text                      0x0000b680   Lc    1  Sect  De   0x98
-    694  ../../printf.c             0x00000000   Lc  Abs  File  De 
-    695  .text                      0x0000b718   Lc    1  Sect  De   0x24
-    696  ../../printf.c             0x00000000   Lc  Abs  File  De 
-    697  .text                      0x0000b73c   Lc    1  Sect  De   0x34
-    698  ../../printf.c             0x00000000   Lc  Abs  File  De 
-    699  .text                      0x0000b770   Lc    1  Sect  De   0xa
-    700  ../../stdio.c              0x00000000   Lc  Abs  File  De 
-    701  .text                      0x0000b77a   Lc    1  Sect  De   0x22
-    702  ../../stdio.c              0x00000000   Lc  Abs  File  De 
-    703  .text                      0x0000b79c   Lc    1  Sect  De   0x26
-    704  ../../stdio.c              0x00000000   Lc  Abs  File  De 
-    705  .bss                       0x0000e478   Lc    3  Sect  De   0xcc
-    706  .text                      0x0000b7c4   Lc    1  Sect  De   0x4b4
-    707  _fclose_internal           0x0000b93f   Lc    1  Code  De   0x64
-    708  .bss$5                     0x0000e478   Lc    3  Data  De 
-    709  ../../division.s           0x00000000   Lc  Abs  File  De 
-    710  .text                      0x0000bc7c   Lc    1  Sect  De   0x2c
-    711  ../../printf1.s            0x00000000   Lc  Abs  File  De 
-    712  x$fpl$printf1              0x0000df44   Lc    1  Sect  De   0x4
-    713  ../../printf2.s            0x00000000   Lc  Abs  File  De 
-    714  x$fpl$printf2              0x0000df4c   Lc    1  Sect  De   0x4
-    715  ../../longlong.s           0x00000000   Lc  Abs  File  De 
-    716  .text                      0x0000bcac   Lc    1  Sect  De   0xc
-    717  ../../unhosted.s           0x00000000   Lc  Abs  File  De 
-    718  .text                      0x0000bcb8   Lc    1  Sect  De   0x10
-    719  ../../angel/sysapp.c       0x00000000   Lc  Abs  File  De 
-    720  .constdata                 0x0000e100   Lc    1  Sect  De   0x4
-    721  .text                      0x0000bcc8   Lc    1  Sect  De   0x7a
-    722  .constdata                 0x0000e104   Lc    1  Sect  De   0x4
-    723  .constdata                 0x0000e0fc   Lc    1  Sect  De   0x4
-    724  .constdata$7               0x0000e0fc   Lc    1  Data  De 
-    725  .constdata$13              0x0000e100   Lc    1  Data  De 
-    726  .constdata$19              0x0000e104   Lc    1  Data  De 
-    727  ../../angel/sys.s          0x00000000   Lc  Abs  File  De 
-    728  .text                      0x0000bd48   Lc    1  Sect  De   0x18
-    729  ../../angel/sys.s          0x00000000   Lc  Abs  File  De 
-    730  .text                      0x0000bd64   Lc    1  Sect  De   0x8
-    731  ../../angel/rt.s           0x00000000   Lc  Abs  File  De 
-    732  .text                      0x0000bd6c   Lc    1  Sect  De   0xc
-    733  ../../angel/rt.s           0x00000000   Lc  Abs  File  De 
-    734  .text                      0x0000bd7c   Lc    1  Sect  De   0x1c
-    735  ../../heapalloc.c          0x00000000   Lc  Abs  File  De 
-    736  .text                      0x0000bd98   Lc    1  Sect  De   0xb2
-    737  ../../heapalloc.c          0x00000000   Lc  Abs  File  De 
-    738  .text                      0x0000be4a   Lc    1  Sect  De   0x1c
-    739  ../../longlong.s           0x00000000   Lc  Abs  File  De 
-    740  .text                      0x0000be6c   Lc    1  Sect  De   0xa0
-    741  ../../printf.c             0x00000000   Lc  Abs  File  De 
-    742  .text                      0x0000bf0c   Lc    1  Sect  De   0x2ec
-    743  .constdata                 0x0000e108   Lc    1  Sect  De   0x11
-    744  .constdata$1               0x0000e108   Lc    1  Data  De 
-    745  maptable@__printf_0        0x0000e108   Lc    1  Data  De   0x11
-    746  ../../printf.c             0x00000000   Lc  Abs  File  De 
-    747  .text                      0x0000c1f8   Lc    1  Sect  De   0x632
-    748  _fp_digits                 0x0000c1fb   Lc    1  Code  De   0x1e0
-    749  _fp_addexp                 0x0000c3db   Lc    1  Code  De   0x4a
-    750  ../../printf.c             0x00000000   Lc  Abs  File  De 
-    751  .text                      0x0000c82a   Lc    1  Sect  De   0x20
-    752  ../../printf.c             0x00000000   Lc  Abs  File  De 
-    753  .text                      0x0000c84a   Lc    1  Sect  De   0xa
-    754  ../../stdio.c              0x00000000   Lc  Abs  File  De 
-    755  .text                      0x0000c854   Lc    1  Sect  De   0xb4
-    756  ../../stdio.c              0x00000000   Lc  Abs  File  De 
-    757  .text                      0x0000c908   Lc    1  Sect  De   0x270
-    758  ../../stdio.c              0x00000000   Lc  Abs  File  De 
-    759  .text                      0x0000cb78   Lc    1  Sect  De   0x16c
-    760  ../../stdio.c              0x00000000   Lc  Abs  File  De 
-    761  .text                      0x0000cce4   Lc    1  Sect  De   0x84
-    762  ../../stdio.c              0x00000000   Lc  Abs  File  De 
-    763  .data                      0x0000e474   Lc    2  Sect  De   0x4
-    764  .data$6                    0x0000e474   Lc    2  Data  De 
-    765  ../../locale.c             0x00000000   Lc  Abs  File  De 
-    766  .text                      0x0000cd68   Lc    1  Sect  De   0x4a
-    767  ../../stdlib.c             0x00000000   Lc  Abs  File  De 
-    768  .text                      0x0000cdb2   Lc    1  Sect  De   0x14
-    769  ../../assert.c             0x00000000   Lc  Abs  File  De 
-    770  .text                      0x0000cdc8   Lc    1  Sect  De   0x1c
-    771  ../../memcpset.s           0x00000000   Lc  Abs  File  De 
-    772  .text                      0x0000cde8   Lc    1  Sect  De   0x58
-    773  _loop                      0x0000ce00   Lc    1  Code  De 
-    774  ../../stkheap1.s           0x00000000   Lc  Abs  File  De 
-    775  .text                      0x0000ce40   Lc    1  Sect  De   0x104
-    776  _heap_overflow             0x0000cf30   Lc    1  Code  De 
-    777  ../../armsys.c             0x00000000   Lc  Abs  File  De 
-    778  .emb_text                  0x00008070   Lc    1  Sect  De   0x10
-    779  argv                       0x0000807c   Lc    1  Data  De 
-    780  ../../armsys.c             0x00000000   Lc  Abs  File  De 
-    781  .text                      0x0000cf4c   Lc    1  Sect  De   0xce
-    782  ../../angel/boardlib.s     0x00000000   Lc  Abs  File  De 
-    783  .text                      0x0000d01c   Lc    1  Sect  De   0x4
-    784  ../../angel/boardlib.s     0x00000000   Lc  Abs  File  De 
-    785  .text                      0x0000d020   Lc    1  Sect  De   0xc
-    786  ../../angel/boardlib.s     0x00000000   Lc  Abs  File  De 
-    787  .text                      0x0000d02c   Lc    1  Sect  De   0x10
-    788  ../../angel/boardlib.s     0x00000000   Lc  Abs  File  De 
-    789  .text                      0x0000d03c   Lc    1  Sect  De   0x4
-    790  ../../longlong.s           0x00000000   Lc  Abs  File  De 
-    791  .text                      0x0000d044   Lc    1  Sect  De   0xc
-    792  ../../longlong.s           0x00000000   Lc  Abs  File  De 
-    793  .text                      0x0000d054   Lc    1  Sect  De   0xc
-    794  ../../angel/sys.s          0x00000000   Lc  Abs  File  De 
-    795  .text                      0x0000d060   Lc    1  Sect  De   0x50
-    796  ../../angel/sys.s          0x00000000   Lc  Abs  File  De 
-    797  .bss                       0x0000e544   Lc    3  Sect  De   0x60
-    798  .text                      0x0000d0b4   Lc    1  Sect  De   0xc
-    799  __libspace_start           0x0000e544   Lc    3  Data  De   0x60
-    800  ../../angel/sys.s          0x00000000   Lc  Abs  File  De 
-    801  .text                      0x0000d0c0   Lc    1  Sect  De   0x4
-    802  ../../angel/rt.s           0x00000000   Lc  Abs  File  De 
-    803  .text                      0x0000d0c8   Lc    1  Sect  De   0x18
-    804  ../../heapalloc.c          0x00000000   Lc  Abs  File  De 
-    805  .text                      0x0000d0e0   Lc    1  Sect  De   0x4
-    806  ../../heap1.c              0x00000000   Lc  Abs  File  De 
-    807  .text                      0x0000d0e4   Lc    1  Sect  De   0x7c
-    808  ../../heap1.c              0x00000000   Lc  Abs  File  De 
-    809  .text                      0x0000d160   Lc    1  Sect  De   0x44
-    810  ../../heap1.c              0x00000000   Lc  Abs  File  De 
-    811  .text                      0x0000d1a4   Lc    1  Sect  De   0x36
-    812  ../../bigflt.c             0x00000000   Lc  Abs  File  De 
-    813  .constdata                 0x0000e11c   Lc    1  Sect  De   0x94
-    814  .text                      0x0000d1dc   Lc    1  Sect  De   0xd0
-    815  .constdata$1               0x0000e11c   Lc    1  Data  De 
-    816  tenpwrs_x@_btod_etento_0   0x0000e11c   Lc    1  Data  De   0x3c
-    817  tenpwrs_i@_btod_etento_1   0x0000e158   Lc    1  Data  De   0x40
-    818  ../../btod.s               0x00000000   Lc  Abs  File  De 
-    819  CL$$btod_e2e               0x0000db14   Lc    1  Sect  De   0xdc
-    820  CL$$btod_mult_common       0x0000dc60   Lc    1  Sect  De   0x268
-    821  CL$$btod_div_common        0x0000d7c8   Lc    1  Sect  De   0x34c
-    822  CL$$btod_d2e               0x0000d6d4   Lc    1  Sect  De   0x38
-    823  CL$$btod_d2e_denorm_low    0x0000d70c   Lc    1  Sect  De   0x54
-    824  CL$$btod_d2e_norm_op1      0x0000d760   Lc    1  Sect  De   0x68
-    825  CL$$btod_ediv              0x0000dbf4   Lc    1  Sect  De   0x34
-    826  CL$$btod_emul              0x0000dc2c   Lc    1  Sect  De   0x34
-    827  _Recip_Table               0x0000da94   Lc    1  Data  De 
-    828  _e2e_underflow_dealtwith   0x0000db1c   Lc    1  Code  De 
-    829  _e2e_round_by_C            0x0000db24   Lc    1  Code  De 
-    830  _e2e_return_value          0x0000db60   Lc    1  Code  De 
-    831  _e2e_exact_or_tied         0x0000db6c   Lc    1  Code  De 
-    832  _e2e_underflow             0x0000db78   Lc    1  Code  De 
-    833  _e2e_underflow_huge        0x0000dbc8   Lc    1  Code  De 
-    834  _div_special_case          0x0000dc1c   Lc    1  Code  De 
-    835  _mul_uncommon              0x0000dc54   Lc    1  Code  De 
-    836  _Mult_64x32                0x0000dd88   Lc    1  Code  De 
-    837  _Mult_32xX                 0x0000de00   Lc    1  Code  De 
-    838  _Mult_32x32                0x0000de80   Lc    1  Code  De 
-    839  ../../stdio.c              0x00000000   Lc  Abs  File  De 
-    840  .text                      0x0000d2ac   Lc    1  Sect  De   0x24
-    841  ../../stdio.c              0x00000000   Lc  Abs  File  De 
-    842  .constdata                 0x0000e1b0   Lc    1  Sect  De   0x1
-    843  .constdata$7               0x0000e1b0   Lc    1  Data  De 
-    844  ../../locale.c             0x00000000   Lc  Abs  File  De 
-    845  .text                      0x0000d2d0   Lc    1  Sect  De   0x2c
-    846  .constdata                 0x0000e1b4   Lc    1  Sect  De   0x1c
-    847  .constdata$1               0x0000e1b4   Lc    1  Data  De 
-    848  __lcnum_c_index            0x0000e1b4   Lc    1  Data  De   0x4
-    849  __lcnum_c_lname            0x0000e1b8   Lc    1  Data  De   0x4
-    850  __lcnum_c_pname            0x0000e1bc   Lc    1  Data  De   0x4
-    851  __lcnum_c_start            0x0000e1c0   Lc    1  Data  De   0x4
-    852  __lcnum_c_tsoff            0x0000e1c4   Lc    1  Data  De   0x4
-    853  __lcnum_c_groff            0x0000e1c8   Lc    1  Data  De   0x4
-    854  __lcnum_c_dptxt            0x0000e1cc   Lc    1  Data  De   0x2
-    855  __lcnum_c_tstxt            0x0000e1ce   Lc    1  Data  De   0x1
-    856  __lcnum_c_grtxt            0x0000e1cf   Lc    1  Data  De   0x1
-    857  ../../signal.c             0x00000000   Lc  Abs  File  De 
-    858  .text                      0x0000d304   Lc    1  Sect  De   0x34
-    859  ../../string.c             0x00000000   Lc  Abs  File  De 
-    860  .text                      0x0000d338   Lc    1  Sect  De   0x48
-    861  ../../stkheap.s            0x00000000   Lc  Abs  File  De 
-    862  .text                      0x0000d384   Lc    1  Sect  De   0x10
-    863  ../../angel/boardlib.s     0x00000000   Lc  Abs  File  De 
-    864  .text                      0x0000d394   Lc    1  Sect  De   0x4
-    865  ../../istatus.s            0x00000000   Lc  Abs  File  De 
-    866  x$fpl$ieeestatus           0x0000df38   Lc    1  Sect  De   0x8
-    867  ../../fpinit.s             0x00000000   Lc  Abs  File  De 
-    868  x$fpl$fpinit               0x0000df1c   Lc    1  Sect  De   0x18
-    869  ../../classify.c           0x00000000   Lc  Abs  File  De 
-    870  .text                      0x0000d39c   Lc    1  Sect  De   0x44
-    871  ../../dtoi.c               0x00000000   Lc  Abs  File  De 
-    872  .text                      0x0000d3e4   Lc    1  Sect  De   0x78
-    873  ../../angel/rt.s           0x00000000   Lc  Abs  File  De 
-    874  .text                      0x0000d45c   Lc    1  Sect  De   0x14
-    875  ../../locale.c             0x00000000   Lc  Abs  File  De 
-    876  .constdata                 0x0000e1d0   Lc    1  Sect  De   0x10d
-    877  .text                      0x0000d470   Lc    1  Sect  De   0x2c
-    878  .constdata$1               0x0000e1d0   Lc    1  Data  De 
-    879  __lcctype_c_index          0x0000e1d0   Lc    1  Data  De   0x4
-    880  __lcctype_c_lname          0x0000e1d4   Lc    1  Data  De   0x4
-    881  __lcctype_c_pname          0x0000e1d8   Lc    1  Data  De   0x4
-    882  __lcctype_c_start          0x0000e1dc   Lc    1  Data  De   0x1
-    883  ../../stdlib.c             0x00000000   Lc  Abs  File  De 
-    884  .text                      0x0000d49c   Lc    1  Sect  De   0x1a
-    885  ../../signal.c             0x00000000   Lc  Abs  File  De 
-    886  .constdata                 0x0000e2dd   Lc    1  Sect  De   0x142
-    887  .text                      0x0000d4b8   Lc    1  Sect  De   0x108
-    888  .constdata$1               0x0000e2dd   Lc    1  Data  De 
-    889  messages@__default_signal_handler_0
-                                    0x0000e2dd   Lc    1  Data  De   0x142
-    890  ../../memcpset.s           0x00000000   Lc  Abs  File  De 
-    891  ../../memcpset.s           0x00000000   Lc  Abs  File  De 
-    892  .text                      0x0000d5c4   Lc    1  Sect  De   0xa0
-    893  _strcmp_loop               0x0000d5d8   Lc    1  Code  De 
-    894  _strcmp_return             0x0000d628   Lc    1  Code  De 
-    895  _strcmp_byteloop           0x0000d630   Lc    1  Code  De 
-    896  _strcmp_byteend            0x0000d658   Lc    1  Code  De 
-    897  _ones_word                 0x0000d660   Lc    1  Data  De   0x4
-    898  ../../scalbn.s             0x00000000   Lc  Abs  File  De 
-    899  x$fpl$scalbn               0x0000dfac   Lc    1  Sect  De   0x74
-    900  scanbn_denorm              0x0000dff4   Lc    1  Code  De 
-    901  scalbn_infnan              0x0000e008   Lc    1  Code  De 
-    902  ../../fpclassify.c         0x00000000   Lc  Abs  File  De 
-    903  .text                      0x0000d664   Lc    1  Sect  De   0x40
-    904  ../../angel/sysapp.c       0x00000000   Lc  Abs  File  De 
-    905  .text                      0x0000d6a4   Lc    1  Sect  De   0x10
-    906  ../../dcheck1.s            0x00000000   Lc  Abs  File  De 
-    907  x$fpl$dcheck1              0x0000df08   Lc    1  Sect  De   0x10
-    908  ../../retnan.s             0x00000000   Lc  Abs  File  De 
-    909  x$fpl$retnan               0x0000df50   Lc    1  Sect  De   0x5c
-    910  return_lognan              0x0000df84   Lc    1  Code  De 
-    911  return_fpnan               0x0000df90   Lc    1  Code  De 
-    912  ../../trapv.s              0x00000000   Lc  Abs  File  De 
-    913  x$fpl$trapveneer           0x0000e020   Lc    1  Sect  De   0x3c
-    914  cmp_generic                0x0000e03c   Lc    1  Code  De 
-    915  cmp_boolean                0x0000e054   Lc    1  Code  De 
-    916  ../../angel/scatter.s      0x00000000   Lc  Abs  File  De 
-    917  !!!scatter                 0x00008008   Lc    1  Sect  De   0x38
-    918  _region_table              0x00008038   Lc    1  Data  De 
-    919  ../../angel/handlers.s     0x00000000   Lc  Abs  File  De 
-    920  !!handler_zi               0x00008040   Lc    1  Sect  De   0x2c
-    921  _zero_loop                 0x00008050   Lc    1  Code  De 
-    922  BuildAttributes$$THUMB_ISAv1$ARM_ISAv4$M$PE$A:L22$X:L11$S22$IEEE1$IW$USESV6$~STKCKD$USESV7$~SHL$OSPACE$EBA8$REQ8$PRES8$EABIv2
-                                    0x00000000   Gb  Abs   --   De 
-    923  __main                     0x00008000   Gb    1  Code  Hi   0x8
-    924  __scatterload              0x00008008   Gb    1  Code  Hi 
-    925  __scatterload_rt2          0x00008008   Gb    1  Code  Hi   0x30
-    926  __scatterload_null         0x0000801c   Gb    1  Code  Hi 
-    927  __scatterload_zeroinit     0x00008040   Gb    1  Code  Hi   0x2c
-    928  $Ven$TA$I$$__ARM_argv_veneer
-                                    0x0000806d   Gb    1  Code  De 
-    929  __ARM_argv_veneer          0x00008070   Gb    1  Code  Hi   0x10
-    930  UnwindStart                0x00008080   Gb    1  Code  Hi   0x44
-    931  UnwPrintf                  0x000080c4   Gb    1  Code  Hi   0x28
-    932  UnwInvalidateRegisterFile  0x000080ec   Gb    1  Code  Hi   0x24
-    933  UnwInitState               0x00008110   Gb    1  Code  Hi   0x64
-    934  UnwReportRetAddr           0x00008174   Gb    1  Code  Hi   0x14
-    935  UnwMemWriteRegister        0x00008188   Gb    1  Code  Hi   0x24
-    936  UnwMemReadRegister         0x000081ac   Gb    1  Code  Hi   0x8c
-    937  UnwStartThumb              0x00008270   Gb    1  Code  Hi   0x12e8
-    938  UnwStartArm                0x000095a4   Gb    1  Code  Hi   0x1380
-    939  UnwMemHashRead             0x0000a9ac   Gb    1  Code  Hi   0x8c
-    940  UnwMemHashWrite            0x0000aa38   Gb    1  Code  Hi   0x90
-    941  UnwMemHashGC               0x0000aac8   Gb    1  Code  Hi   0x7c
-    942  tailFunc                   0x0000ab70   Gb    1  Code  Hi   0x4c
-    943  wind                       0x0000abbc   Gb    1  Code  Hi   0x84
-    944  tailCall                   0x0000ac40   Gb    1  Code  Hi   0x24
-    945  viaFuncPointer             0x0000ac64   Gb    1  Code  Hi   0x18
-    946  testStackResize            0x0000ac7c   Gb    1  Code  Hi   0x5c
-    947  testConst                  0x0000acd8   Gb    1  Code  Hi   0x30
-    948  testRecurse                0x0000ad08   Gb    1  Code  Hi   0x2c
-    949  testArm1                   0x0000ad34   Gb    1  Code  Hi   0x28
-    950  testArm                    0x0000ad5c   Gb    1  Code  Hi   0x8c
-    951  testPrintf                 0x0000ade8   Gb    1  Code  Hi   0x28
-    952  testVoid                   0x0000ae10   Gb    1  Code  Hi   0x8
-    953  main                       0x0000ae18   Gb    1  Code  Hi   0x14
-    954  $Ven$AT$I$$testThumb1      0x0000ae3c   Gb    1  Code  De 
-    955  testThumb1                 0x0000ae45   Gb    1  Code  Hi   0x18
-    956  testThumb                  0x0000ae5d   Gb    1  Code  Hi   0x16
-    957  CliInvalidateW             0x0000af08   Gb    1  Code  Hi   0x10
-    958  _printf_pre_padding        0x0000af31   Gb    1  Code  Hi   0x30
-    959  _printf_post_padding       0x0000af61   Gb    1  Code  De   0x24
-    960  _printf_str                0x0000af85   Gb    1  Code  Hi   0x5e
-    961  _printf_longlong_hex       0x0000afe5   Gb    1  Code  Hi   0xba
-    962  _printf_int_dec            0x0000b0b5   Gb    1  Code  Hi   0x68
-    963  printf                     0x0000b12d   Gb    1  Code  Hi   0x2e
-    964  $Ven$AT$I$$vprintf         0x0000b164   Gb    1  Code  De 
-    965  vprintf                    0x0000b16d   Gb    1  Code  Hi   0x28
-    966  $Ven$AT$I$$__0printf       0x0000b19c   Gb    1  Code  De 
-    967  __0printf                  0x0000b1a5   Gb    1  Code  Hi   0x2e
-    968  $Ven$AT$I$$__0sprintf      0x0000b1dc   Gb    1  Code  De 
-    969  __0sprintf                 0x0000b1e5   Gb    1  Code  Hi   0x28
-    970  __aeabi_memcpy4            0x0000b210   Gb    1  Code  Hi 
-    971  __aeabi_memcpy8            0x0000b210   Gb    1  Code  Hi 
-    972  __rt_memcpy_w              0x0000b210   Gb    1  Code  Hi   0x6c
-    973  _memcpy_lastbytes          0x0000b25c   Gb    1  Code  Hi 
-    974  $Ven$TA$I$$__aeabi_idivmod 0x0000b27d   Gb    1  Code  De 
-    975  __aeabi_idiv               0x0000b280   Gb    1  Code  Hi 
-    976  __aeabi_idivmod            0x0000b280   Gb    1  Code  Hi   0x164
-    977  __rt_entry                 0x0000b3e4   Gb    1  Code  Hi   0x4c
-    978  __rt_exit                  0x0000b430   Gb    1  Code  Hi   0x14
-    979  __rt_abort                 0x0000b444   Gb    1  Code  Hi   0x8
-    980  __aeabi_idiv0              0x0000b44c   Gb    1  Code  Hi   0x4
-    981  _printf_truncate_signed    0x0000b451   Gb    1  Code  De   0x16
-    982  _printf_truncate_unsigned  0x0000b467   Gb    1  Code  De   0x16
-    983  _printf_wctomb             0x0000b47d   Gb    1  Code  De   0xbc
-    984  _printf_int_common         0x0000b53d   Gb    1  Code  De   0xaa
-    985  _printf_longlong_oct       0x0000b5e9   Gb    1  Code  De   0x8e
-    986  _printf_longlong_dec       0x0000b681   Gb    1  Code  De   0x88
-    987  _printf_charcount          0x0000b719   Gb    1  Code  De   0x24
-    988  _printf_char_common        0x0000b73d   Gb    1  Code  De   0x2a
-    989  _sputc                     0x0000b771   Gb    1  Code  De   0xa
-    990  ferror                     0x0000b77b   Gb    1  Code  De   0x22
-    991  fputc                      0x0000b79d   Gb    1  Code  De   0x26
-    992  _seterr                    0x0000b7c5   Gb    1  Code  De   0x30
-    993  _writebuf                  0x0000b7f5   Gb    1  Code  De   0x64
-    994  _flushlinebuffered         0x0000b859   Gb    1  Code  De   0x42
-    995  _fflush                    0x0000b89b   Gb    1  Code  De   0x64
-    996  _deferredlazyseek          0x0000b8ff   Gb    1  Code  De   0x40
-    997  fclose                     0x0000b9a3   Gb    1  Code  De   0x20
-    998  freopen                    0x0000b9c3   Gb    1  Code  De   0xae
-    999  fopen                      0x0000ba71   Gb    1  Code  De   0x68
-    1000  _initio                    0x0000bad9   Gb    1  Code  De   0x150
-    1001  _terminateio               0x0000bc29   Gb    1  Code  De   0x42
-    1002  $Ven$TA$I$$__rt_udiv10     0x0000bc79   Gb    1  Code  De 
-    1003  __rt_udiv10                0x0000bc7c   Gb    1  Code  Hi   0x2c
-    1004  $Ven$TA$I$$__ARM_ll_cmpu   0x0000bca9   Gb    1  Code  De 
-    1005  __ARM_ll_cmpu              0x0000bcac   Gb    1  Code  Hi   0xc
-    1006  _ll_cmpu                   0x0000bcac   Gb    1  Code  Hi 
-    1007  __ARM_call_via_r0          0x0000bcb9   Gb    1  Code  Hi   0x2
-    1008  __call_via_r0              0x0000bcb9   Gb    1  Code  Hi 
-    1009  __ARM_call_via_r1          0x0000bcbb   Gb    1  Code  Hi   0x2
-    1010  __call_via_r1              0x0000bcbb   Gb    1  Code  Hi 
-    1011  __ARM_call_via_r2          0x0000bcbd   Gb    1  Code  Hi   0x2
-    1012  __call_via_r2              0x0000bcbd   Gb    1  Code  Hi 
-    1013  __ARM_call_via_r3          0x0000bcbf   Gb    1  Code  Hi   0x2
-    1014  __call_via_r3              0x0000bcbf   Gb    1  Code  Hi 
-    1015  __ARM_call_via_r4          0x0000bcc1   Gb    1  Code  Hi   0x2
-    1016  __call_via_r4              0x0000bcc1   Gb    1  Code  Hi 
-    1017  __ARM_call_via_r5          0x0000bcc3   Gb    1  Code  Hi   0x2
-    1018  __call_via_r5              0x0000bcc3   Gb    1  Code  Hi 
-    1019  __ARM_call_via_r6          0x0000bcc5   Gb    1  Code  Hi   0x2
-    1020  __call_via_r6              0x0000bcc5   Gb    1  Code  Hi 
-    1021  __ARM_call_via_r7          0x0000bcc7   Gb    1  Code  Hi   0x2
-    1022  __call_via_r7              0x0000bcc7   Gb    1  Code  Hi 
-    1023  _sys_open                  0x0000bcc9   Gb    1  Code  De   0x18
-    1024  _sys_close                 0x0000bce1   Gb    1  Code  De   0xe
-    1025  _sys_write                 0x0000bcef   Gb    1  Code  De   0x16
-    1026  _sys_read                  0x0000bd05   Gb    1  Code  De   0x10
-    1027  _sys_istty                 0x0000bd15   Gb    1  Code  De   0xc
-    1028  _sys_seek                  0x0000bd21   Gb    1  Code  De   0x12
-    1029  _sys_ensure                0x0000bd33   Gb    1  Code  De   0x4
-    1030  _sys_flen                  0x0000bd37   Gb    1  Code  De   0xc
-    1031  $Ven$TA$I$$_sys_exit       0x0000bd45   Gb    1  Code  De 
-    1032  _sys_exit                  0x0000bd48   Gb    1  Code  Hi   0x14
-    1033  $Ven$TA$I$$_mutex_initialize
-                                    0x0000bd61   Gb    1  Code  De 
-    1034  _mutex_initialize          0x0000bd64   Gb    1  Code  Hi   0x8
-    1035  __rt_div0                  0x0000bd6c   Gb    1  Code  Hi   0xc
-    1036  $Ven$TA$I$$__rt_raise      0x0000bd79   Gb    1  Code  De 
-    1037  __rt_raise                 0x0000bd7c   Gb    1  Code  Hi   0x1c
-    1038  _terminate_user_alloc      0x0000bd99   Gb    1  Code  De   0x2
-    1039  _init_user_alloc           0x0000bd9b   Gb    1  Code  De   0x2
-    1040  __Heap_Full                0x0000bd9d   Gb    1  Code  De   0x2a
-    1041  __Heap_Broken              0x0000bdc7   Gb    1  Code  De   0x10
-    1042  _init_alloc                0x0000bdd7   Gb    1  Code  De   0x5e
-    1043  malloc                     0x0000be35   Gb    1  Code  De   0x16
-    1044  free                       0x0000be4b   Gb    1  Code  De   0x1c
-    1045  $Ven$TA$I$$_ll_udiv10      0x0000be69   Gb    1  Code  De 
-    1046  _ll_udiv10                 0x0000be6c   Gb    1  Code  Hi   0xa0
-    1047  __printf                   0x0000bf0d   Gb    1  Code  De   0x2e8
-    1048  __lib_sel_fp_printf        0x0000c1f9   Gb    1  Code  De   0x2
-    1049  _fp_display                0x0000c425   Gb    1  Code  De   0x320
-    1050  _printf_fp_dec_real        0x0000c745   Gb    1  Code  De   0xe6
-    1051  _printf_outstr_char        0x0000c82b   Gb    1  Code  De   0x20
-    1052  _printf_input_char         0x0000c84b   Gb    1  Code  De   0xa
-    1053  _do_fflush                 0x0000c855   Gb    1  Code  De   0x68
-    1054  fflush                     0x0000c8bd   Gb    1  Code  De   0x42
-    1055  __flsbuf                   0x0000c909   Gb    1  Code  De   0x264
-    1056  _fseek                     0x0000cb79   Gb    1  Code  De   0x13c
-    1057  fseek                      0x0000ccb5   Gb    1  Code  De   0x2a
-    1058  setvbuf                    0x0000cce5   Gb    1  Code  De   0x6e
-    1059  setbuf                     0x0000cd53   Gb    1  Code  De   0x10
-    1060  _wcrtomb                   0x0000cd69   Gb    1  Code  De   0x4a
-    1061  exit                       0x0000cdb3   Gb    1  Code  Hi   0x14
-    1062  __lib_sel_stdio_assert     0x0000cdc9   Gb    1  Code  De   0x2
-    1063  __assert_puts              0x0000cdcb   Gb    1  Code  De   0x14
-    1064  $Ven$TA$I$$__aeabi_memclr4 0x0000cde5   Gb    1  Code  De 
-    1065  __aeabi_memclr4            0x0000cde8   Gb    1  Code  Hi 
-    1066  __aeabi_memclr8            0x0000cde8   Gb    1  Code  Hi 
-    1067  __rt_memclr_w              0x0000cde8   Gb    1  Code  Hi   0x58
-    1068  _memset_w                  0x0000cdec   Gb    1  Code  Hi 
-    1069  __rt_stackheap_init        0x0000ce40   Gb    1  Code  Hi   0x90
-    1070  __rt_heap_extend           0x0000ced0   Gb    1  Code  Hi   0x74
-    1071  $Ven$AT$I$$__rt_lib_init   0x0000cf44   Gb    1  Code  De 
-    1072  __rt_lib_init              0x0000cf4d   Gb    1  Code  Hi   0xb8
-    1073  __rt_lib_shutdown          0x0000d005   Gb    1  Code  Hi   0x16
-    1074  _platform_pre_stackheap_init
-                                    0x0000d01c   Gb    1  Code  Hi   0x4
-    1075  _platform_post_stackheap_init
-                                    0x0000d020   Gb    1  Code  Hi   0xc
-    1076  _platform_post_lib_init    0x0000d02c   Gb    1  Code  Hi   0x10
-    1077  _platform_pre_lib_shutdown 0x0000d03c   Gb    1  Code  Hi   0x4
-    1078  $Ven$TA$I$$__ARM_ll_neg    0x0000d041   Gb    1  Code  De 
-    1079  __ARM_ll_neg               0x0000d044   Gb    1  Code  Hi   0xc
-    1080  _ll_neg                    0x0000d044   Gb    1  Code  Hi 
-    1081  $Ven$TA$I$$__ARM_ll_cmpge  0x0000d051   Gb    1  Code  De 
-    1082  __ARM_ll_cmpge             0x0000d054   Gb    1  Code  Hi   0xc
-    1083  _ll_cmpge                  0x0000d054   Gb    1  Code  Hi 
-    1084  __user_initial_stackheap   0x0000d060   Gb    1  Code  Hi   0x50
-    1085  _RW_Limit                  0x0000d0ac   Gb    1  Data  Hi 
-    1086  $Ven$TA$I$$__user_perproc_libspace
-                                    0x0000d0b1   Wk    1  Code  De 
-    1087  __user_libspace            0x0000d0b4   Gb    1  Code  Hi   0x8
-    1088  __user_perproc_libspace    0x0000d0b4   Wk    1  Code  Hi 
-    1089  __user_perthread_libspace  0x0000d0b4   Wk    1  Code  Hi 
-    1090  __I_use_semihosting_swi    0x0000d0c0   Gb    1  Code  Hi   0x4
-    1091  __semihosting_swi_guard    0x0000d0c0   Gb    1  Code  Hi 
-    1092  $Ven$TA$I$$__rt_ctype_table
-                                    0x0000d0c5   Gb    1  Code  De 
-    1093  __rt_ctype_table           0x0000d0c8   Gb    1  Code  Hi   0x18
-    1094  __heap_guard               0x0000d0e1   Gb    1  Code  De   0x2
-    1095  __I_use_heap               0x0000d0e3   Gb    1  Code  De   0x2
-    1096  __Heap_Initialize          0x0000d0e5   Gb    1  Code  De   0xa
-    1097  __Heap_DescSize            0x0000d0ef   Gb    1  Code  De   0x4
-    1098  __Heap_Alloc               0x0000d0f3   Gb    1  Code  De   0x6a
-    1099  __Heap_Alloc_Internal      0x0000d15d   Gb    1  Code  De   0x4
-    1100  __Heap_Free                0x0000d161   Gb    1  Code  De   0x40
-    1101  __Heap_Free_Internal       0x0000d1a1   Gb    1  Code  De   0x4
-    1102  __Heap_ProvideMemory       0x0000d1a5   Gb    1  Code  De   0x36
-    1103  _btod_etento               0x0000d1dd   Gb    1  Code  De   0xca
-    1104  fputs                      0x0000d2ad   Gb    1  Code  De   0x24
-    1105  _get_lc_numeric            0x0000d2d1   Gb    1  Code  De   0x24
-    1106  $Ven$AT$I$$__raise         0x0000d2fc   Gb    1  Code  De 
-    1107  __raise                    0x0000d305   Gb    1  Code  Hi   0x34
-    1108  strlen                     0x0000d339   Gb    1  Code  De   0x44
-    1109  $Ven$TA$I$$__heap_extend   0x0000d381   Gb    1  Code  De 
-    1110  __heap_extend              0x0000d384   Gb    1  Code  Hi   0x10
-    1111  _cpu_pre_main              0x0000d394   Gb    1  Code  Hi   0x4
-    1112  $Ven$TA$I$$__mathlib_classify
-                                    0x0000d399   Gb    1  Code  De 
-    1113  __mathlib_classify         0x0000d39c   Gb    1  Code  De   0x44
-    1114  $Ven$TA$I$$__support_dtoi  0x0000d3e1   Gb    1  Code  De 
-    1115  __support_dtoi             0x0000d3e4   Gb    1  Code  De   0x78
-    1116  __rt_fp_status_addr        0x0000d45c   Gb    1  Code  Hi   0x14
-    1117  _get_lc_ctype              0x0000d471   Gb    1  Code  Hi   0x24
-    1118  abort                      0x0000d49d   Gb    1  Code  De   0x1a
-    1119  __default_signal_handler   0x0000d4b9   Gb    1  Code  De   0x86
-    1120  $Ven$TA$I$$strcmp          0x0000d5c1   Gb    1  Code  De 
-    1121  strcmp                     0x0000d5c4   Gb    1  Code  Hi   0x9c
-    1122  __ARM_fpclassify           0x0000d664   Gb    1  Code  De   0x3c
-    1123  _ttywrch                   0x0000d6a5   Gb    1  Code  De   0x10
-    1124  __aeabi_uidiv              0x0000d6b4   Gb    1  Code  Hi 
-    1125  __aeabi_uidivmod           0x0000d6b4   Gb    1  Code  Hi   0x1c
-    1126  $Ven$TA$I$$_btod_d2e       0x0000d6d1   Gb    1  Code  De 
-    1127  _btod_d2e                  0x0000d6d4   Gb    1  Code  Hi   0x38
-    1128  _d2e_denorm_low            0x0000d70c   Gb    1  Code  Hi   0x54
-    1129  _d2e_norm_op1              0x0000d760   Gb    1  Code  Hi   0x68
-    1130  __btod_div_common          0x0000d7c8   Gb    1  Code  Hi   0x2cc
-    1131  _e2e                       0x0000db14   Gb    1  Code  Hi   0xdc
-    1132  $Ven$TA$I$$_btod_ediv      0x0000dbf1   Gb    1  Code  De 
-    1133  _btod_ediv                 0x0000dbf4   Gb    1  Code  Hi   0x34
-    1134  $Ven$TA$I$$_btod_emul      0x0000dc29   Gb    1  Code  De 
-    1135  _btod_emul                 0x0000dc2c   Gb    1  Code  Hi   0x34
-    1136  __btod_mult_common         0x0000dc60   Gb    1  Code  Hi   0x268
-    1137  $Ven$AT$L$$testThumb       0x0000dec8   Gb    1  Code  De 
-    1138  $Ven$TA$S$$testRecurse     0x0000ded5   Gb    1  Code  De 
-    1139  $Ven$TA$S$$testArm1        0x0000dedd   Gb    1  Code  De 
-    1140  $Ven$AT$L$$__rt_lib_shutdown
-                                    0x0000dee4   Gb    1  Code  De 
-    1141  $Ven$TA$S$$__rt_exit       0x0000def1   Gb    1  Code  De 
-    1142  $Ven$AT$L$$_printf_fp_dec_real
-                                    0x0000def8   Gb    1  Code  De 
-    1143  __ARM_get_argv             0x0000df04   Gb    1  Code  Hi   0x4
-    1144  __fpl_dcheck_NaN1          0x0000df08   Gb    1  Code  De   0xc
-    1145  $Ven$TA$I$$_fp_init        0x0000df19   Gb    1  Code  De 
-    1146  _fp_init                   0x0000df1c   Gb    1  Code  Hi   0x18
-    1147  __fplib_config_pureend_doubles
-                                    0x0000df2c   Gb    1  Code  De 
-    1148  $Ven$TA$I$$__ieee_status   0x0000df35   Gb    1  Code  De 
-    1149  __ieee_status              0x0000df38   Gb    1  Code  Hi   0x8
-    1150  $Ven$TA$I$$_printf_fp_dec  0x0000df41   Gb    1  Code  De 
-    1151  _printf_fp_dec             0x0000df44   Gb    1  Code  De   0x4
-    1152  $Ven$TA$I$$_printf_fp_hex  0x0000df49   Gb    1  Code  De 
-    1153  _printf_fp_hex             0x0000df4c   Gb    1  Code  De   0x4
-    1154  __fpl_return_NaN           0x0000df50   Gb    1  Code  De   0x54
-    1155  __ARM_scalbn               0x0000dfac   Gb    1  Code  Hi 
-    1156  scalbln                    0x0000dfac   Gb    1  Code  De 
-    1157  scalblnl                   0x0000dfac   Gb    1  Code  De 
-    1158  scalbn                     0x0000dfac   Gb    1  Code  De   0x74
-    1159  scalbnl                    0x0000dfac   Gb    1  Code  De 
-    1160  __fpl_inf_scalbn           0x0000e01c   Gb    1  Code  De 
-    1161  __fpl_cmpreturn            0x0000e020   Gb    1  Code  De   0x3c
-    1162  cliCallbacks               0x0000e0c0   Gb    1  Data  Hi   0x14
-    1163  __stdin_name               0x0000e0fc   Gb    1  Data  De   0x4
-    1164  __stdout_name              0x0000e100   Gb    1  Data  De   0x4
-    1165  __stderr_name              0x0000e104   Gb    1  Data  De   0x4
-    1166  __select_optimised_fwrite  0x0000e1b0   Gb    1  Data  De   0x1
-    1167  __ctype                    0x0000e1dd   Gb    1  Data  De   0x100
-    1168  Region$$Table$$Base        0x0000e460   Gb    1   --   Hi 
-    1169  Region$$Table$$Limit       0x0000e470   Gb    1  Data  Hi 
-    1170  _stream_list_lock          0x0000e474   Gb    2  Data  Hi   0x4
-    1171  __stdin                    0x0000e478   Gb    3  Data  Hi   0x44
-    1172  __stdout                   0x0000e4bc   Gb    3  Data  Hi   0x44
-    1173  __stderr                   0x0000e500   Gb    3  Data  Hi   0x44
-    1174  Image$$ZI$$Limit           0x0000e5a4   Gb  Abs   --   Hi 
-
-
-** Section #6 '.strtab' (SHT_STRTAB)
-    Size   : 6440 bytes
-
-
-** Section #7 '.note' (SHT_NOTE)
-    Size   : 28 bytes (alignment 4)
-
-
-** Section #8 '.comment' (SHT_PROGBITS)
-    Size   : 36032 bytes
-
-
-** Section #9 '.shstrtab' (SHT_STRTAB)
-    Size   : 76 bytes
-
-