--- /dev/null
+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
--- /dev/null
+Makefile.make
\ No newline at end of file
--- /dev/null
+
+# 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
--- /dev/null
+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
--- /dev/null
+/***************************************************************************
+ * 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 */
--- /dev/null
+/***************************************************************************
+ * 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 */
--- /dev/null
+/***************************************************************************
+ * 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 */
--- /dev/null
+/***************************************************************************
+ * 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 */
--- /dev/null
+/***************************************************************************
+ * 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();
+}
--- /dev/null
+/***************************************************************************
+ * 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 */
--- /dev/null
+/***************************************************************************
+ * 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
+
+/** 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));
+}
+
+
+/** 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)
+{
+ /* 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, ®->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, ®->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 */
--- /dev/null
+/***************************************************************************
+ * 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 100
+
+/** 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;
+
+
+/** 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[16];
+
+ /** Memory tracking data. */
+ MemData memData;
+
+ /** Pointer to the callback functions */
+ const UnwindCallbacks *cb;
+
+ /** Pointer to pass to the report function. */
+ const void *reportData;
+}
+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
+ **************************************************************************/
+
+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 */
+
+
--- /dev/null
+/***************************************************************************
+ * 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(state->regData[15].v & 0x3)
+ {
+ 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(state->regData[rn].v & 0x1)
+ {
+ /* 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(state->regData[15].v & 0x1)
+ {
+ /* 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 */
+
--- /dev/null
+/***************************************************************************
+ * 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"
+
+/***************************************************************************
+ * 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;
+}
+
+
+/***************************************************************************
+ * Global Functions
+ **************************************************************************/
+
+
+UnwResult UnwStartThumb(UnwState * const state)
+{
+ Boolean found = FALSE;
+ Int16 t = UNW_MAX_INSTR_COUNT;
+
+ do
+ {
+ Int16 instr;
+
+ /* 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(!(state->regData[15].v & 0x1))
+ {
+ 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
+ */
+ 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 != 3 && !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;
+ }
+
+ /* Update the PC */
+ state->regData[15].v = state->regData[rhs].v;
+
+ /* Determine the new mode */
+ if(state->regData[rhs].v & 0x1)
+ {
+ /* 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));
+ return UNWIND_FAILURE;
+ }
+ }
+ }
+ /* 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]))
+ {
+ return UNWIND_DREAD_W_FAIL;
+ }
+ }
+ /* 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((state->regData[15].v & 0x1) == 0)
+ {
+ 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;
+ }
+
+ /* 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);
+
+ /* Update PC */
+ state->regData[15].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[15].v += 2;
+
+ /* Display PC of next instruction */
+ UnwPrintd2(" New PC=%x", state->regData[15].v + 2);
+
+ }
+ 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) return UNWIND_EXHAUSTED;
+
+ }
+ while(!found);
+
+ return UNWIND_SUCCESS;
+}
+
+#endif /* UPGRADE_ARM_STACK_UNWIND */
+
+/* END OF FILE */
+
--- /dev/null
+/***************************************************************************
+ * 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 */
+
--- /dev/null
+/***************************************************************************
+ * 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);
+
+#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 */
--- /dev/null
+/***************************************************************************
+ * 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 */
--- /dev/null
+/***************************************************************************
+ * 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 */
--- /dev/null
+
+========================================================================
+
+** 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
+
+
projects / platform / core / system / crash-worker.git / commitdiff