BuildRequires: libelf-devel libelf
BuildRequires: libebl-devel libebl
BuildRequires: libdw-devel libdw
+%ifarch %{arm}
+BuildRequires: pkgconfig(libunwind-ptrace)
+%endif
%if %{with doc}
BuildRequires: doxygen
%endif
Requires(post): coreutils
Requires(post): tar
Requires(post): gzip
-Requires: libunwind
Requires: zip
# If you need support for core dump files (see building below),
# you should add this dependency
%files doc
%{_datadir}/doc/crash-worker
%endif
-
+cmake_minimum_required(VERSION 2.8.11)
+
option(WITH_CORE_DUMP "builds with support for core dump files (with GPL2 license)")
set(CRASH_STACK_BIN "crash-stack")
set(CRASH_STACK_SRCS crash-stack.c crash-stack-libelf-helpers.c)
# Add architecture dependent source files
if (${CMAKE_SYSTEM_PROCESSOR} STREQUAL "armv7l")
- set(CRASH_STACK_SRCS ${CRASH_STACK_SRCS} crash-stack-arm.c wind/unwarm.c wind/unwarm_thumb.c wind/unwarm_arm.c wind/unwarmmem.c)
+ set(CRASH_STACK_SRCS ${CRASH_STACK_SRCS} crash-stack-arm.c)
else()
if (${CMAKE_SYSTEM_PROCESSOR} STREQUAL "aarch64")
set(CRASH_STACK_SRCS ${CRASH_STACK_SRCS} crash-stack-aarch64.c)
# Set architecture dependent options for the binary - it must be already added
if (${CMAKE_SYSTEM_PROCESSOR} STREQUAL "armv7l")
- set_property(TARGET ${CRASH_STACK_BIN} APPEND_STRING PROPERTY COMPILE_FLAGS " -DUPGRADE_ARM_STACK_UNWIND")
-# set_property(TARGET ${CRASH_STACK_BIN} APPEND_STRING PROPERTY COMPILE_FLAGS "-DUPGRADE_ARM_STACK_UNWIND -DUNW_DEBUG")
+ include(FindPkgConfig)
+ pkg_check_modules(LIBUNWIND_PTRACE REQUIRED libunwind-ptrace)
+ set_property(TARGET ${CRASH_STACK_BIN} APPEND_STRING PROPERTY COMPILE_FLAGS ${LIBUNWIND_PTRACE_CFLAGS_OTHER})
endif()
# Set compilation options for core dump support
endif()
# Linking
-target_link_libraries(${CRASH_STACK_BIN} ${EBL_LIBRARY} dw elf dl stdc++)
+target_link_libraries(${CRASH_STACK_BIN} ${LIBUNWIND_PTRACE_LIBRARIES} ${EBL_LIBRARY} dw elf dl stdc++)
# Installing
install(TARGETS ${CRASH_STACK_BIN} DESTINATION libexec)
* limitations under the License.
*
* Author: Adrian Szyndela <adrian.s@samsung.com>
+ * Rafal Pietruch <r.pietruch@samsung.com>
*/
/**
* @file crash-stack-arm.c
* @brief unwinding call stacks, functions specific for ARM
*/
#include "crash-stack.h"
-#include "wind/unwarm.h"
+#include <libunwind-ptrace.h>
#include <string.h>
#include <sys/ptrace.h>
#include <sys/user.h>
-static Elf *g_core = NULL; ///< core file handler
-static Dwfl *g_dwfl = NULL; ///< dwfl handler
-static Mappings *g_mappings = NULL; ///< pointer to mappings database
-static pid_t g_pid = 0; ///< PID of analyzed program
+// definitions copied from previously used McTernan unwinder
+#define REGS_REGULAR_NUM 13
+#define REG_FP 11
+#define REG_IP 12
+#define REG_SP 13
+#define REG_LR 14
+#define REG_PC 15
+#define REG_SPSR 16
/**
* @brief Important registers for unwinding stack on ARM
}
}
-/**
- * @brief Callback function for McTernan's unwinder - call stack frame reporting
- *
- * @param data pointer to call stack database
- * @param address return address of the function in the reported call frame
- */
-static Boolean __report(void *data, Int32 address)
-{
- Callstack *callstack = (Callstack *)(data);
- callstack->tab[callstack->elems++] = address;
-
- return callstack->elems < MAX_CALLSTACK_LEN ? TRUE : FALSE;
-}
-
-/**
- * @brief Helper function for reading values from target memory
- *
- * @param a target address to read from
- * @param v destination address to copy data to
- * @param size of the value
- */
-static Boolean __readT(Int32 a, void *v, size_t size)
-{
- return _crash_stack_libelf_read_value(g_dwfl, g_core, g_pid, a, v, size, g_mappings);
-}
-
-/**
- * @brief Callback function for McTernan's unwinder - reading 32 bits
- *
- * @param a target address to read from
- * @param v destination address to copy data to
- */
-static Boolean __readW(Int32 a, Int32 *v)
-{
- return __readT(a, v, sizeof(*v));
-}
-
-/**
- * @brief Callback function for McTernan's unwinder - reading 16 bits
- *
- * @param a target address to read from
- * @param v destination address to copy data to
- */
-static Boolean __readH(Int32 a, Int16 *v)
-{
- return __readT(a, v, sizeof(*v));
-}
-
-/**
- * @brief Callback function for McTernan's unwinder - reading 8 bits
- *
- * @param a target address to read from
- * @param v destination address to copy data to
- */
-static Boolean __readB(Int32 a, Int8 *v)
-{
- return __readT(a, v, sizeof(*v));
-}
-
-/**
- * @brief Callback function for McTernan's unwinder - trying to find function prologue
- *
- * @param current_pc address from inside of some function from target memory
- */
-static Int32 __getProloguePC(Int32 current_pc)
-{
- return _crash_stack_libelf_get_prologue_pc(g_dwfl, current_pc, g_mappings);
-}
-
void _create_crash_stack(Dwfl *dwfl, Elf *core, pid_t pid, Mappings *mappings, Callstack *callstack)
{
- UnwindCallbacks callbacks = {
- __report,
- __readW,
- __readH,
- __readB,
- __getProloguePC
-#ifdef UNW_DEBUG
- ,
- printf
-#endif
- };
- UnwState state;
-
- g_dwfl = dwfl;
- g_core = core;
- g_mappings = mappings;
- g_pid = pid;
-
- callstack->tab[0] = g_regs.pc;
- callstack->elems = 1;
-
- UnwInitState(&state, &callbacks, callstack, g_regs.pc, g_regs.sp);
- int i;
- for (i = 0; i < REGS_REGULAR_NUM; i++) {
- state.regData[i].v = g_regs.regs[i];
- state.regData[i].o = REG_VAL_FROM_CONST;
+ // reimplemented based on libunwind tests/test-ptrace.c file
+ callstack->elems = 0;
+ unw_addr_space_t as = unw_create_addr_space(&_UPT_accessors, 0);
+ if (as) {
+ void *uptInfo = _UPT_create(pid);
+ if (uptInfo) {
+ unw_cursor_t cursor;
+ if (unw_init_remote(&cursor, as, uptInfo) >= 0) {
+ // MaxDeep as proposed in libunwind tests/test-ptrace.c file
+ // guard against bad unwind info in old libraries
+ static const int MaxDeep = 64;
+ int n;
+ for (n = 0; n < MaxDeep; ++n) {
+ unw_word_t ip;
+ if (unw_get_reg(&cursor, UNW_REG_IP, &ip) >= 0) {
+ callstack->tab[callstack->elems++] = ip;
+ }
+ int step = unw_step(&cursor);
+ if (step <= 0)
+ break;
+ }
+ }
+ _UPT_destroy(uptInfo);
+ }
+ unw_destroy_addr_space(as);
}
- state.regData[REG_LR].v = g_regs.lr;
- state.regData[REG_LR].o = REG_VAL_FROM_STACK;
- state.regData[REG_SPSR].v = g_regs.spsr;
- state.regData[REG_SPSR].o = REG_VAL_FROM_CONST;
-
- if (UnwIsAddrThumb(g_regs.pc, g_regs.spsr))
- UnwStartThumb(&state);
- else
- UnwStartArm(&state);
}
void _crash_stack_print_regs(FILE* outputfile)
+++ /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
-
-Boolean UnwIsAddrThumb (Int32 pc, Int32 spsr)
-{
- return (pc & 0x1) != 0 || (spsr & 0x20) != 0;
-}
-
-/** Invalidate all general purpose registers.
- */
-void UnwInvalidateRegisterFile(RegData *regFile)
-{
- Int8 t = 0;
-
- do
- {
- regFile[t].o = REG_VAL_INVALID;
- t++;
- }
- while(t < 13);
-
-}
-
-
-/** Initialise the data used for unwinding.
- */
-void UnwInitState(UnwState * const state, /**< Pointer to structure to fill. */
- const UnwindCallbacks *cb, /**< Callbacks. */
- void *rptData, /**< Data to pass to report function. */
- Int32 pcValue, /**< PC at which to start unwinding. */
- Int32 spValue) /**< SP at which to start unwinding. */
-{
- UnwInvalidateRegisterFile(state->regData);
-
- /* Store the pointer to the callbacks */
- state->cb = cb;
- state->reportData = rptData;
-
- /* Setup the SP and PC */
- state->regData[13].v = spValue;
- state->regData[13].o = REG_VAL_FROM_CONST;
- state->regData[15].v = pcValue;
- state->regData[15].o = REG_VAL_FROM_CONST;
-
- UnwPrintd3("\nInitial: PC=0x%08x SP=0x%08x\n", pcValue, spValue);
-
- /* Invalidate all memory addresses */
- memset(state->memData.used, 0, sizeof(state->memData.used));
- memset(state->branchData.used, 0, sizeof(state->branchData.used));
-
- state->lastReported = 0;
-}
-
-
-/** Call the report function to indicate some return address.
- * This returns the value of the report function, which if TRUE
- * indicates that unwinding may continue.
- */
-Boolean UnwReportRetAddr(UnwState * const state, Int32 addr)
-{
- state->lastReported = addr;
- /* Cast away const from reportData.
- * The const is only to prevent the unw module modifying the data.
- */
- return state->cb->report((void *)state->reportData, addr);
-}
-
-
-/** Write some register to memory.
- * This will store some register and meta data onto the virtual stack.
- * The address for the write
- * \param state [in/out] The unwinding state.
- * \param wAddr [in] The address at which to write the data.
- * \param reg [in] The register to store.
- * \return TRUE if the write was successful, FALSE otherwise.
- */
-Boolean UnwMemWriteRegister(UnwState * const state,
- const Int32 addr,
- const RegData * const reg)
-{
- return UnwMemHashWrite(&state->memData,
- addr,
- reg->v,
- M_IsOriginValid(reg->o));
-}
-
-/** Read a register from memory.
- * This will read a register from memory, and setup the meta data.
- * If the register has been previously written to memory using
- * UnwMemWriteRegister, the local hash will be used to return the
- * value while respecting whether the data was valid or not. If the
- * register was previously written and was invalid at that point,
- * REG_VAL_INVALID will be returned in *reg.
- * \param state [in] The unwinding state.
- * \param addr [in] The address to read.
- * \param reg [out] The result, containing the data value and the origin
- * which will be REG_VAL_FROM_MEMORY, or REG_VAL_INVALID.
- * \return TRUE if the address could be read and *reg has been filled in.
- * FALSE is the data could not be read.
- */
-Boolean UnwMemReadRegister(UnwState * const state,
- const Int32 addr,
- RegData * const reg)
-{
- Boolean tracked;
-
- /* Check if the value can be found in the hash */
- if(UnwMemHashRead(&state->memData, addr, ®->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 200
-
-/** The size of the hash used to track reads and writes to memory.
- * This should be a prime value for efficiency.
- */
-#define MEM_HASH_SIZE 31
-
-/***************************************************************************
- * Type Definitions
- **************************************************************************/
-
-typedef enum
-{
- /** Invalid value. */
- REG_VAL_INVALID = 0x00,
- REG_VAL_FROM_STACK = 0x01,
- REG_VAL_FROM_MEMORY = 0x02,
- REG_VAL_FROM_CONST = 0x04,
- REG_VAL_ARITHMETIC = 0x80
-}
-RegValOrigin;
-
-
-/** Type for tracking information about a register.
- * This stores the register value, as well as other data that helps unwinding.
- */
-typedef struct
-{
- /** The value held in the register. */
- Int32 v;
-
- /** The origin of the register value.
- * This is used to track how the value in the register was loaded.
- */
- RegValOrigin o;
-}
-RegData;
-
-
-/** Structure used to track reads and writes to memory.
- * This structure is used as a hash to store a small number of writes
- * to memory.
- */
-typedef struct
-{
- /** Memory contents. */
- Int32 v[MEM_HASH_SIZE];
-
- /** Address at which v[n] represents. */
- Int32 a[MEM_HASH_SIZE];
-
- /** Indicates whether the data in v[n] and a[n] is occupied.
- * Each bit represents one hash value.
- */
- Int8 used[(MEM_HASH_SIZE + 7) / 8];
-
- /** Indicates whether the data in v[n] is valid.
- * This allows a[n] to be set, but for v[n] to be marked as invalid.
- * Specifically this is needed for when an untracked register value
- * is written to memory.
- */
- Int8 tracked[(MEM_HASH_SIZE + 7) / 8];
-}
-MemData;
-
-#define REGS_REGULAR_NUM 13
-#define REG_FP 11
-#define REG_IP 12
-#define REG_SP 13
-#define REG_LR 14
-#define REG_PC 15
-#define REG_SPSR 16
-
-/** Structure that is used to keep track of unwinding meta-data.
- * This data is passed between all the unwinding functions.
- */
-typedef struct
-{
- /** The register values and meta-data. */
- RegData regData[17];
-
- /** Memory tracking data. */
- MemData memData;
-
- /** Branches tracking data. */
- MemData branchData;
-
- /** Pointer to the callback functions */
- const UnwindCallbacks *cb;
-
- /** Pointer to pass to the report function. */
- const void *reportData;
-
- /** Pointer to last reported function. */
- Int32 lastReported;
-}
-UnwState;
-
-/***************************************************************************
- * Macros
- **************************************************************************/
-
-#define M_IsOriginValid(v) (((v) & 0x7f) ? TRUE : FALSE)
-#define M_Origin2Str(v) ((v) ? "VALID" : "INVALID")
-
-#if defined(UNW_DEBUG)
-#define UnwPrintd1(a) state->cb->printf(a)
-#define UnwPrintd2(a,b) state->cb->printf(a,b)
-#define UnwPrintd3(a,b,c) state->cb->printf(a,b,c)
-#define UnwPrintd4(a,b,c,d) state->cb->printf(a,b,c,d)
-#define UnwPrintd5(a,b,c,d,e) state->cb->printf(a,b,c,d,e)
-#define UnwPrintd6(a,b,c,d,e,f) state->cb->printf(a,b,c,d,e,f)
-#define UnwPrintd7(a,b,c,d,e,f,g) state->cb->printf(a,b,c,d,e,f,g)
-#define UnwPrintd8(a,b,c,d,e,f,g,h) state->cb->printf(a,b,c,d,e,f,g,h)
-#else
-#define UnwPrintd1(a)
-#define UnwPrintd2(a,b)
-#define UnwPrintd3(a,b,c)
-#define UnwPrintd4(a,b,c,d)
-#define UnwPrintd5(a,b,c,d,e)
-#define UnwPrintd6(a,b,c,d,e,f)
-#define UnwPrintd7(a,b,c,d,e,f,g)
-#define UnwPrintd8(a,b,c,d,e,f,g,h)
-#endif
-
-/***************************************************************************
- * Function Prototypes
- **************************************************************************/
-
-Boolean UnwIsAddrThumb (Int32 pc, Int32 spsr);
-
-UnwResult UnwStartArm (UnwState * const state);
-
-UnwResult UnwStartThumb (UnwState * const state);
-
-void UnwInvalidateRegisterFile(RegData *regFile);
-
-void UnwInitState (UnwState * const state,
- const UnwindCallbacks *cb,
- void *rptData,
- Int32 pcValue,
- Int32 spValue);
-
-Boolean UnwReportRetAddr (UnwState * const state, Int32 addr);
-
-Boolean UnwMemWriteRegister (UnwState * const state,
- const Int32 addr,
- const RegData * const reg);
-
-Boolean UnwMemReadRegister (UnwState * const state,
- const Int32 addr,
- RegData * const reg);
-
-void UnwMemHashGC (UnwState * const state);
-
-#endif /* UPGRADE_ARM_STACK_UNWIND */
-
-#endif /* UNWARM_H */
-
-/* END OF FILE */
-
-
+++ /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(UnwIsAddrThumb(state->regData[REG_PC].v, state->regData[REG_SPSR].v))
- {
- UnwPrintd1("\nError: PC misalignment\n");
- return UNWIND_INCONSISTENT;
- }
-
- /* Check that the SP and PC have not been invalidated */
- if(!M_IsOriginValid(state->regData[13].o) || !M_IsOriginValid(state->regData[15].o))
- {
- UnwPrintd1("\nError: PC or SP invalidated\n");
- return UNWIND_INCONSISTENT;
- }
-
- /* Branch and Exchange (BX)
- * This is tested prior to data processing to prevent
- * mis-interpretation as an invalid TEQ instruction.
- */
- if((instr & 0xfffffff0) == 0xe12fff10)
- {
- Int8 rn = instr & 0xf;
-
- UnwPrintd4("BX r%d\t ; r%d %s\n", rn, rn, M_Origin2Str(state->regData[rn].o));
-
- if(!M_IsOriginValid(state->regData[rn].o))
- {
- UnwPrintd1("\nUnwind failure: BX to untracked register\n");
- return UNWIND_FAILURE;
- }
-
- /* Set the new PC value */
- state->regData[15].v = state->regData[rn].v;
-
- /* Check if the return value is from the stack */
- if(state->regData[rn].o == REG_VAL_FROM_STACK)
- {
- /* Now have the return address */
- UnwPrintd2(" Return PC=%x\n", state->regData[15].v & (~0x1));
-
- /* Report the return address */
- if(!UnwReportRetAddr(state, state->regData[rn].v))
- {
- return UNWIND_TRUNCATED;
- }
- }
-
- /* Determine the return mode */
- if(UnwIsAddrThumb(state->regData[rn].v, state->regData[REG_SPSR].v))
- {
- /* Branching to THUMB */
- return UnwStartThumb(state);
- }
- else
- {
- /* Branch to ARM */
-
- /* Account for the auto-increment which isn't needed */
- state->regData[15].v -= 4;
- }
- }
- /* Branch */
- else if((instr & 0xff000000) == 0xea000000)
- {
- SignedInt32 offset = (instr & 0x00ffffff);
-
- /* Shift value */
- offset = offset << 2;
-
- /* Sign extend if needed */
- if(offset & 0x02000000)
- {
- offset |= 0xfc000000;
- }
-
- UnwPrintd2("B %d\n", offset);
-
- /* Adjust PC */
- state->regData[15].v += offset;
-
- /* Account for pre-fetch, where normally the PC is 8 bytes
- * ahead of the instruction just executed.
- */
- state->regData[15].v += 4;
-
- }
- /* MRS */
- else if((instr & 0xffbf0fff) == 0xe10f0000)
- {
-#if defined(UNW_DEBUG)
- Boolean R = (instr & 0x00400000) ? TRUE : FALSE;
-#endif
- Int8 rd = (instr & 0x0000f000) >> 12;
-
- UnwPrintd4("MRS r%d,%s\t; r%d invalidated", rd, R ? "SPSR" : "CPSR", rd);
-
- /* Status registers untracked */
- state->regData[rd].o = REG_VAL_INVALID;
- }
- /* MSR */
- else if((instr & 0xffb0f000) == 0xe120f000)
- {
-#if defined(UNW_DEBUG)
- Boolean R = (instr & 0x00400000) ? TRUE : FALSE;
-
- UnwPrintd2("MSR %s_?, ???", R ? "SPSR" : "CPSR");
-#endif
- /* Status registers untracked.
- * Potentially this could change processor mode and switch
- * banked registers r8-r14. Most likely is that r13 (sp) will
- * be banked. However, invalidating r13 will stop unwinding
- * when potentially this write is being used to disable/enable
- * interrupts (a common case). Therefore no invalidation is
- * performed.
- */
- }
- /* Data processing */
- else if(isDataProc(instr))
- {
- Boolean I = (instr & 0x02000000) ? TRUE : FALSE;
- Int8 opcode = (instr & 0x01e00000) >> 21;
-#if defined(UNW_DEBUG)
- Boolean S = (instr & 0x00100000) ? TRUE : FALSE;
-#endif
- Int8 rn = (instr & 0x000f0000) >> 16;
- Int8 rd = (instr & 0x0000f000) >> 12;
- Int16 operand2 = (instr & 0x00000fff);
- Int32 op2val;
- RegValOrigin op2origin;
-
- switch(opcode)
- {
- case 0: UnwPrintd4("AND%s r%d,r%d,", S ? "S" : "", rd, rn); break;
- case 1: UnwPrintd4("EOR%s r%d,r%d,", S ? "S" : "", rd, rn); break;
- case 2: UnwPrintd4("SUB%s r%d,r%d,", S ? "S" : "", rd, rn); break;
- case 3: UnwPrintd4("RSB%s r%d,r%d,", S ? "S" : "", rd, rn); break;
- case 4: UnwPrintd4("ADD%s r%d,r%d,", S ? "S" : "", rd, rn); break;
- case 5: UnwPrintd4("ADC%s r%d,r%d,", S ? "S" : "", rd, rn); break;
- case 6: UnwPrintd4("SBC%s r%d,r%d,", S ? "S" : "", rd, rn); break;
- case 7: UnwPrintd4("RSC%s r%d,r%d,", S ? "S" : "", rd, rn); break;
- case 8: UnwPrintd3("TST%s r%d,", S ? "S" : "", rn); break;
- case 9: UnwPrintd3("TEQ%s r%d,", S ? "S" : "", rn); break;
- case 10: UnwPrintd3("CMP%s r%d,", S ? "S" : "", rn); break;
- case 11: UnwPrintd3("CMN%s r%d,", S ? "S" : "", rn); break;
- case 12: UnwPrintd3("ORR%s r%d,", S ? "S" : "", rn); break;
- case 13: UnwPrintd3("MOV%s r%d,", S ? "S" : "", rd); break;
- case 14: UnwPrintd4("BIC%s r%d,r%d", S ? "S" : "", rd, rn); break;
- case 15: UnwPrintd3("MVN%s r%d,", S ? "S" : "", rd); break;
- }
-
- /* Decode operand 2 */
- if(I)
- {
- Int8 shiftDist = (operand2 & 0x0f00) >> 8;
- Int8 shiftConst = (operand2 & 0x00ff);
-
- /* rotate const right by 2 * shiftDist */
- shiftDist *= 2;
- op2val = (shiftConst >> shiftDist) |
- (shiftConst << (32 - shiftDist));
- op2origin = REG_VAL_FROM_CONST;
-
- UnwPrintd2("#0x%x", op2val);
- }
- else
- {
- /* Register and shift */
- Int8 rm = (operand2 & 0x000f);
- Int8 regShift = (operand2 & 0x0010) ? TRUE : FALSE;
- Int8 shiftType = (operand2 & 0x0060) >> 5;
- Int32 shiftDist;
-#if defined(UNW_DEBUG)
- const char * const shiftMnu[4] = { "LSL", "LSR", "ASR", "ROR" };
-#endif
- UnwPrintd2("r%d ", rm);
-
- /* Get the shift distance */
- if(regShift)
- {
- Int8 rs = (operand2 & 0x0f00) >> 8;
-
- if(operand2 & 0x00800)
- {
- UnwPrintd1("\nError: Bit should be zero\n");
- return UNWIND_ILLEGAL_INSTR;
- }
- else if(rs == 15)
- {
- UnwPrintd1("\nError: Cannot use R15 with register shift\n");
- return UNWIND_ILLEGAL_INSTR;
- }
-
- /* Get shift distance */
- shiftDist = state->regData[rs].v;
- op2origin = state->regData[rs].o;
-
- UnwPrintd7("%s r%d\t; r%d %s r%d %s",
- shiftMnu[shiftType], rs,
- rm, M_Origin2Str(state->regData[rm].o),
- rs, M_Origin2Str(state->regData[rs].o));
- }
- else
- {
- shiftDist = (operand2 & 0x0f80) >> 7;
- op2origin = REG_VAL_FROM_CONST;
-
- if(shiftDist)
- {
- UnwPrintd3("%s #%d",
- shiftMnu[shiftType], shiftDist);
- }
- UnwPrintd3("\t; r%d %s", rm, M_Origin2Str(state->regData[rm].o));
-
- }
-
- /* Apply the shift type to the source register */
- switch(shiftType)
- {
- case 0: /* logical left */
- op2val = state->regData[rm].v << shiftDist;
- break;
- case 1: /* logical right */
-
- if(!regShift && shiftDist == 0)
- {
- shiftDist = 32;
- }
-
- op2val = state->regData[rm].v >> shiftDist;
- break;
- case 2: /* arithmetic right */
-
- if(!regShift && shiftDist == 0)
- {
- shiftDist = 32;
- }
-
- if(state->regData[rm].v & 0x80000000)
- {
- /* Register shifts maybe greater than 32 */
- if(shiftDist >= 32)
- {
- op2val = 0xffffffff;
- }
- else
- {
- op2val = state->regData[rm].v >> shiftDist;
- op2val |= 0xffffffff << (32 - shiftDist);
- }
- }
- else
- {
- op2val = state->regData[rm].v >> shiftDist;
- }
- break;
- case 3: /* rotate right */
-
- if(!regShift && shiftDist == 0)
- {
- /* Rotate right with extend.
- * This uses the carry bit and so always has an
- * untracked result.
- */
- op2origin = REG_VAL_INVALID;
- op2val = 0;
- }
- else
- {
- /* Limit shift distance to 0-31 incase of register shift */
- shiftDist &= 0x1f;
-
- op2val = (state->regData[rm].v >> shiftDist) |
- (state->regData[rm].v << (32 - shiftDist));
- }
- break;
-
- default:
- UnwPrintd2("\nError: Invalid shift type: %d\n", shiftType);
- return UNWIND_FAILURE;
- }
-
- /* Decide the data origin */
- if(M_IsOriginValid(op2origin) &&
- M_IsOriginValid(state->regData[rm].o))
- {
- op2origin = state->regData[rm].o;
- op2origin |= REG_VAL_ARITHMETIC;
- }
- else
- {
- op2origin = REG_VAL_INVALID;
- }
-
- }
-
- /* Propagate register validity */
- switch(opcode)
- {
- case 0: /* AND: Rd := Op1 AND Op2 */
- case 1: /* EOR: Rd := Op1 EOR Op2 */
- case 2: /* SUB: Rd:= Op1 - Op2 */
- case 3: /* RSB: Rd:= Op2 - Op1 */
- case 4: /* ADD: Rd:= Op1 + Op2 */
- case 12: /* ORR: Rd:= Op1 OR Op2 */
- case 14: /* BIC: Rd:= Op1 AND NOT Op2 */
- if(!M_IsOriginValid(state->regData[rn].o) ||
- !M_IsOriginValid(op2origin))
- {
- state->regData[rd].o = REG_VAL_INVALID;
- }
- else
- {
- state->regData[rd].o = state->regData[rn].o;
- state->regData[rd].o |= op2origin;
- }
- break;
- case 5: /* ADC: Rd:= Op1 + Op2 + C */
- case 6: /* SBC: Rd:= Op1 - Op2 + C */
- case 7: /* RSC: Rd:= Op2 - Op1 + C */
- /* CPSR is not tracked */
- state->regData[rd].o = REG_VAL_INVALID;
- break;
-
- case 8: /* TST: set condition codes on Op1 AND Op2 */
- case 9: /* TEQ: set condition codes on Op1 EOR Op2 */
- case 10: /* CMP: set condition codes on Op1 - Op2 */
- case 11: /* CMN: set condition codes on Op1 + Op2 */
- break;
-
-
- case 13: /* MOV: Rd:= Op2 */
- case 15: /* MVN: Rd:= NOT Op2 */
- state->regData[rd].o = op2origin;
- break;
- }
-
- /* Account for pre-fetch by temporarily adjusting PC */
- if(rn == 15)
- {
- /* If the shift amount is specified in the instruction,
- * the PC will be 8 bytes ahead. If a register is used
- * to specify the shift amount the PC will be 12 bytes
- * ahead.
- */
- if(!I && (operand2 & 0x0010))
- state->regData[rn].v += 12;
- else
- state->regData[rn].v += 8;
- }
-
- /* Compute values */
- switch(opcode)
- {
- case 0: /* AND: Rd := Op1 AND Op2 */
- state->regData[rd].v = state->regData[rn].v & op2val;
- break;
-
- case 1: /* EOR: Rd := Op1 EOR Op2 */
- state->regData[rd].v = state->regData[rn].v ^ op2val;
- break;
-
- case 2: /* SUB: Rd:= Op1 - Op2 */
- state->regData[rd].v = state->regData[rn].v - op2val;
- break;
- case 3: /* RSB: Rd:= Op2 - Op1 */
- state->regData[rd].v = op2val - state->regData[rn].v;
- break;
-
- case 4: /* ADD: Rd:= Op1 + Op2 */
- state->regData[rd].v = state->regData[rn].v + op2val;
- break;
-
- case 5: /* ADC: Rd:= Op1 + Op2 + C */
- case 6: /* SBC: Rd:= Op1 - Op2 + C */
- case 7: /* RSC: Rd:= Op2 - Op1 + C */
- case 8: /* TST: set condition codes on Op1 AND Op2 */
- case 9: /* TEQ: set condition codes on Op1 EOR Op2 */
- case 10: /* CMP: set condition codes on Op1 - Op2 */
- case 11: /* CMN: set condition codes on Op1 + Op2 */
- UnwPrintd1("\t; ????");
- break;
-
- case 12: /* ORR: Rd:= Op1 OR Op2 */
- state->regData[rd].v = state->regData[rn].v | op2val;
- break;
-
- case 13: /* MOV: Rd:= Op2 */
- state->regData[rd].v = op2val;
- break;
-
- case 14: /* BIC: Rd:= Op1 AND NOT Op2 */
- state->regData[rd].v = state->regData[rn].v & (~op2val);
- break;
-
- case 15: /* MVN: Rd:= NOT Op2 */
- state->regData[rd].v = ~op2val;
- break;
- }
-
- /* Remove the prefetch offset from the PC */
- if(rd != 15 && rn == 15)
- {
- if(!I && (operand2 & 0x0010))
- state->regData[rn].v -= 12;
- else
- state->regData[rn].v -= 8;
- }
-
- }
- /* Block Data Transfer
- * LDM, STM
- */
- else if((instr & 0xfe000000) == 0xe8000000)
- {
- Boolean P = (instr & 0x01000000) ? TRUE : FALSE;
- Boolean U = (instr & 0x00800000) ? TRUE : FALSE;
- Boolean S = (instr & 0x00400000) ? TRUE : FALSE;
- Boolean W = (instr & 0x00200000) ? TRUE : FALSE;
- Boolean L = (instr & 0x00100000) ? TRUE : FALSE;
- Int16 baseReg = (instr & 0x000f0000) >> 16;
- Int16 regList = (instr & 0x0000ffff);
- Int32 addr = state->regData[baseReg].v;
- Boolean addrValid = M_IsOriginValid(state->regData[baseReg].o);
- SignedInt8 r;
-
-#if defined(UNW_DEBUG)
- /* Display the instruction */
- if(L)
- {
- UnwPrintd6("LDM%c%c r%d%s, {reglist}%s\n",
- P ? 'E' : 'F',
- U ? 'D' : 'A',
- baseReg,
- W ? "!" : "",
- S ? "^" : "");
- }
- else
- {
- UnwPrintd6("STM%c%c r%d%s, {reglist}%s\n",
- !P ? 'E' : 'F',
- !U ? 'D' : 'A',
- baseReg,
- W ? "!" : "",
- S ? "^" : "");
- }
-#endif
- /* S indicates that banked registers (untracked) are used, unless
- * this is a load including the PC when the S-bit indicates that
- * that CPSR is loaded from SPSR (also untracked, but ignored).
- */
- if(S && (!L || (regList & (0x01 << 15)) == 0))
- {
- UnwPrintd1("\nError:S-bit set requiring banked registers\n");
- return UNWIND_FAILURE;
- }
- else if(baseReg == 15)
- {
- UnwPrintd1("\nError: r15 used as base register\n");
- return UNWIND_FAILURE;
- }
- else if(regList == 0)
- {
- UnwPrintd1("\nError: Register list empty\n");
- return UNWIND_FAILURE;
- }
-
- /* Check if ascending or descending.
- * Registers are loaded/stored in order of address.
- * i.e. r0 is at the lowest address, r15 at the highest.
- */
- r = U ? 0 : 15;
-
- do
- {
- /* Check if the register is to be transferred */
- if(regList & (0x01 << r))
- {
- if(P) addr += U ? 4 : -4;
-
- if(L)
- {
- if(addrValid)
- {
- if(!UnwMemReadRegister(state, addr, &state->regData[r]))
- {
- return UNWIND_DREAD_W_FAIL;
- }
-
- /* Update the origin if read via the stack pointer */
- if(M_IsOriginValid(state->regData[r].o) && baseReg == 13)
- {
- state->regData[r].o = REG_VAL_FROM_STACK;
- }
-
- UnwPrintd5(" R%d = 0x%08x\t; r%d %s\n",
- r,
- state->regData[r].v,
- r,
- M_Origin2Str(state->regData[r].o));
- }
- else
- {
- /* Invalidate the register as the base reg was invalid */
- state->regData[r].o = REG_VAL_INVALID;
-
- UnwPrintd2(" R%d = ???\n", r);
- }
- }
- else
- {
- if(addrValid)
- {
- if(!UnwMemWriteRegister(state, state->regData[13].v, &state->regData[r]))
- {
- return UNWIND_DWRITE_W_FAIL;
- }
- }
-
- UnwPrintd2(" R%d = 0x%08x\n", r);
- }
-
- if(!P) addr += U ? 4 : -4;
- }
-
- /* Check the next register */
- r += U ? 1 : -1;
- }
- while(r >= 0 && r <= 15);
-
- /* Check the writeback bit */
- if(W) state->regData[baseReg].v = addr;
-
- /* Check if the PC was loaded */
- if(L && (regList & (0x01 << 15)))
- {
- if(!M_IsOriginValid(state->regData[15].o))
- {
- /* Return address is not valid */
- UnwPrintd1("PC popped with invalid address\n");
- return UNWIND_FAILURE;
- }
- else
- {
- /* Store the return address */
- if(!UnwReportRetAddr(state, state->regData[15].v))
- {
- return UNWIND_TRUNCATED;
- }
-
- UnwPrintd2(" Return PC=0x%x", state->regData[15].v);
-
- /* Determine the return mode */
- if(UnwIsAddrThumb(state->regData[REG_PC].v, state->regData[REG_SPSR].v))
- {
- /* Branching to THUMB */
- return UnwStartThumb(state);
- }
- else
- {
- /* Branch to ARM */
-
- /* Account for the auto-increment which isn't needed */
- state->regData[15].v -= 4;
- }
- }
- }
- }
- else
- {
- UnwPrintd1("????");
-
- /* Unknown/undecoded. May alter some register, so invalidate file */
- UnwInvalidateRegisterFile(state->regData);
- }
-
- UnwPrintd1("\n");
-
- /* Should never hit the reset vector */
- if(state->regData[15].v == 0) return UNWIND_RESET;
-
- /* Check next address */
- state->regData[15].v += 4;
-
- /* Garbage collect the memory hash (used only for the stack) */
- UnwMemHashGC(state);
-
- t--;
- if(t == 0) return UNWIND_EXHAUSTED;
-
- }
- while(!found);
-
- return UNWIND_UNSUPPORTED;
-}
-
-#endif /* UPGRADE_ARM_STACK_UNWIND */
-
-/* END OF FILE */
-
+++ /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"
-#include "unwarmmem.h"
-
-/***************************************************************************
- * Manifest Constants
- **************************************************************************/
-
-
-/***************************************************************************
- * Type Definitions
- **************************************************************************/
-
-
-/***************************************************************************
- * Variables
- **************************************************************************/
-
-
-/***************************************************************************
- * Macros
- **************************************************************************/
-
-
-/***************************************************************************
- * Local Functions
- **************************************************************************/
-
-/** Sign extend an 11 bit value.
- * This function simply inspects bit 11 of the input \a value, and if
- * set, the top 5 bits are set to give a 2's compliment signed value.
- * \param value The value to sign extend.
- * \return The signed-11 bit value stored in a 16bit data type.
- */
-static SignedInt16 signExtend11(Int16 value)
-{
- if(value & 0x400)
- {
- value |= 0xf800;
- }
-
- return value;
-}
-
-static SignedInt16 signExtend8(Int16 value)
-{
- if(value & 0x80)
- {
- value |= 0xff00;
- }
-
- return value;
-}
-
-/***************************************************************************
- * Global Functions
- **************************************************************************/
-
-static Int32 ThumbExpandImm (Int32 imm32)
-{
- Int8 ab = (imm32 & (3 << 10)) >> 10;
- Int8 cd = (imm32 & (3 << 8)) >> 8;
- Int8 ror = (imm32 & (0x1F << 7)) >> 7;
- Int32 nn = imm32 & 0xFF;
- if (0 == ab)
- {
- switch (cd)
- {
- case 0: return nn;
- case 1: return (nn << 16) | nn;
- case 2: return (nn << 24) | (nn << 8);
- case 3: return (nn << 24) | (nn << 16) | (nn << 8) | nn;
- }
- }
- else
- {
- nn = nn | 0x80;
- ror = 32 - ror;
- return nn << ror;
- }
- return 0;
-}
-
-static UnwResult Unw32DataProcessingModifiedImmediate (UnwState * const state, Int16 instr, Int16 instr2)
-{
- Int8 op = (instr & (0xF << 5)) >> 5;
- Int8 Rn = instr & 0xF;
- Int8 S = (instr & (1 << 4)) >> 4;
- Int8 Rd = (instr2 & (0xF << 8)) >> 8;
-
- switch (op)
- {
- case 0:
- if (0xF==Rd)
- {
- if (0==S) return UNWIND_ILLEGAL_INSTR;
-
- UnwPrintd1("TST ...\n");
- }
- else
- {
- state->regData[Rd].o = REG_VAL_INVALID;
- UnwPrintd1("AND ...\n");
- }
- break;
- case 1:
- state->regData[Rd].o = REG_VAL_INVALID;
- UnwPrintd1("BIC ...\n");
- break;
- case 2:
- state->regData[Rd].o = REG_VAL_INVALID;
- if (0xF != Rn)
- UnwPrintd1("ORR ...\n");
- else
- UnwPrintd1("MOV ...\n");
- break;
- case 3:
- if (0xF != Rn)
- {
- state->regData[Rd].o = REG_VAL_INVALID;
- UnwPrintd1("ORN ...\n");
- }
- else
- UnwPrintd1("MVN ...\n");
- break;
- case 4:
- if (0xF != Rd)
- {
- UnwPrintd1("EOR ...\n");
- state->regData[Rd].o = REG_VAL_INVALID;
- }
- else
- {
- if (0==S) return UNWIND_ILLEGAL_INSTR;
-
- UnwPrintd1("TEQ ...\n");
- }
- break;
- case 8:
- if (0xF != Rd)
- {
- Int16 i = (instr & (1 << 10)) >> 10;
- Int16 imm3 = (instr2 & (0x7 << 12)) >> 12;
- Int16 imm8 = instr2 & 0xFF;
- Int32 imm32 = imm8 | (imm3 << 8) | (i << 11);
-
- imm32 = ThumbExpandImm (imm32);
-
- UnwPrintd4("ADD r%d, r%d, #0x%x", Rd, Rn, imm32);
- state->regData[Rd].v = state->regData[Rn].v + imm32;
- state->regData[Rd].o = state->regData[Rn].o;
- }
- else
- {
- if (0==S) return UNWIND_ILLEGAL_INSTR;
-
- UnwPrintd1("CMN ...\n");
- }
- break;
- case 10:
- state->regData[Rd].o = REG_VAL_INVALID;
- UnwPrintd1("ADC ...\n");
- break;
- case 11:
- state->regData[Rd].o = REG_VAL_INVALID;
- UnwPrintd1("SBC ...\n");
- break;
- case 13:
- if (0xF != Rd)
- {
- state->regData[Rd].o = REG_VAL_INVALID;
- UnwPrintd1("SUB ...\n");
- }
- else
- {
- if (0==S) return UNWIND_ILLEGAL_INSTR;
-
- UnwPrintd1("CMP ...\n");
- }
- break;
- case 14:
- state->regData[Rd].o = REG_VAL_INVALID;
- UnwPrintd1("RSB ...\n");
- break;
- default:
- return UNWIND_ILLEGAL_INSTR;
- }
- return UNWIND_SUCCESS;
-}
-
-static UnwResult Unw32LoadWord (UnwState * const state, Int16 instr, Int16 instr2)
-{
- Int8 op1 = (instr & (0x3 << 7)) >> 7;
- Int8 Rn = instr & 0xF;
-// Int8 op2 = (instr2 & (0x3F << 6)) >> 6;
-
- if (1 == op1 && 0xF != Rn)
- {
- /* LDR imm */
- Int8 Rt = (instr2 & (0xF << 12)) >> 12;
- Int32 imm12 = instr2 & 0xFFF;
-
- UnwPrintd4("LDR r%d, [r%d, #0x%08x]", Rt, Rn, imm12);
-
- imm12 += state->regData[Rn].v;
-
- if (state->regData[Rn].o == REG_VAL_INVALID)
- {
- state->regData[Rt].o = REG_VAL_INVALID;
- }
- else
- {
- if(!UnwMemReadRegister(state, imm12, &state->regData[Rt]))
- {
- return UNWIND_DREAD_W_FAIL;
- }
- }
- }
- else if (0 == op1 && 0xF != Rn)
- {
- Int8 Rt = (instr2 & (0xF << 12)) >> 12;
- Int32 imm8 = instr2 & 0xFF;
- Int8 U = (instr2 & (1 << 9)) >> 9;
- Int8 P = (instr2 & (1 << 10)) >> 10;
- Int8 W = (instr2 & (1 << 8)) >> 8;
- Int32 offset_addr;
- Int32 addr;
-
- UnwPrintd8("LDR r%d, [r%d%c,#%c0x%08x%c%c\n",
- Rt, Rn,
- P ? ' ' : ']',
- U ? '+' : '-',
- imm8,
- P ? ']' : ' ',
- W ? '!' : ' ');
-
- if (state->regData[Rn].o == REG_VAL_INVALID)
- {
- state->regData[Rt].o = REG_VAL_INVALID;
- }
- else
- {
- offset_addr = state->regData[Rn].v + (U ? 1 : -1) * imm8;
- addr = P ? offset_addr : state->regData[Rn].v;
-
- if(!UnwMemReadRegister(state, addr, &state->regData[Rt]))
- {
- return UNWIND_DREAD_W_FAIL;
- }
-
- if (REG_SP == Rn)
- state->regData[Rt].o = REG_VAL_FROM_STACK;
-
- if (W)
- state->regData[Rn].v = offset_addr;
- }
- }
-// else if (op1 < 2 && 0xF == Rn)
-// {
- /* LDR literal */
-// }
- else
- {
- /* UNDEFINED */
- UnwPrintd1("????");
- UnwInvalidateRegisterFile(state->regData);
- }
- return UNWIND_SUCCESS;
-}
-static UnwResult Unw32LoadStoreMultiple (UnwState * const state, Int16 instr, Int16 instr2)
-{
- Int8 op = (instr & (0x3 << 7)) >> 7;
- Int8 L = (instr & (0x1 << 4)) >> 4;
- Int8 Rn = instr & 0xF;
-
- UnwResult res = UNWIND_SUCCESS;
-
- switch (op)
- {
- case 0:
- if (0 == L) UnwPrintd1("SRS ...");
- else
- {
- state->regData[REG_PC].o = REG_VAL_INVALID;
- UnwPrintd1("LRE ...");
- }
- break;
- case 1:
- {
- Int8 bitCount = 0;
- Int16 register_list = (instr2 & 0x7FFF);
- int i;
-
- for (i = 0; i < 15; i++)
- {
- if ((register_list & (0x1 << i)) != 0) bitCount++;
- }
-
- if (0 == L)
- {
- Int8 W = (instr & (0x1 << 5)) >> 5;
- if (W) state->regData[Rn].v += 4*bitCount;
- UnwPrintd1("STM ...");
- }
- else
- {
- if (13 != Rn)
- {
- Int8 W = (instr & (0x1 << 5)) >> 5;
- for (i = 0; i < 15; i++)
- {
- if ((register_list & (0x1 << i)) != 0)
- state->regData[i].o = REG_VAL_INVALID;
- }
- if (W)
- {
- if ((register_list & (1 << Rn)) == 0)
- state->regData[Rn].v += 4*bitCount;
- else
- state->regData[Rn].o = REG_VAL_INVALID;
- }
- UnwPrintd1("LDM ...");
- }
- else
- {
- Boolean new_pc = FALSE;
- Boolean got_lr = FALSE;
-
- register_list = register_list | (instr2 & 0x8000);
- UnwPrintd1("POP {");
- for (i = 0; i < 16; i++)
- {
- if ((register_list & (0x1 << i)) != 0)
- {
- if (!UnwMemReadRegister(state,
- state->regData[REG_SP].v,
- &state->regData[i]))
- {
- return UNWIND_DREAD_W_FAIL;
- }
- state->regData[i].o = REG_VAL_FROM_STACK;
- state->regData[REG_SP].v += 4;
- if (i < 13)
- UnwPrintd2 ("r%d,", i);
- else if (REG_LR==i)
- {
- UnwPrintd1 ("lr,");
- got_lr = TRUE;
- }
- else if (REG_PC==i)
- {
- UnwPrintd1 ("pc");
- new_pc = TRUE;
- }
- }
- }
- UnwPrintd1("}");
- if (new_pc)
- {
- UnwPrintd2("\n New PC=%x\n", state->regData[REG_PC].v);
-
- /* Report the return address, including mode bit */
- if(!UnwReportRetAddr(state, state->regData[REG_PC].v))
- {
- return UNWIND_TRUNCATED;
- }
- }
- else if (got_lr)
- {
- UnwPrintd2("\n New PC=%x\n", state->regData[REG_LR].v);
-
- /* Report the return address, including mode bit */
- if(!UnwReportRetAddr(state, state->regData[REG_LR].v))
- {
- return UNWIND_TRUNCATED;
- }
-
- state->regData[REG_PC].v = state->regData[REG_LR].v;
-
- if(UnwIsAddrThumb(state->regData[REG_PC].v, state->regData[REG_SPSR].v))
- {
- /* Branching to THUMB */
-
- /* Account for the auto-increment which isn't needed */
- state->regData[REG_PC].v -= 2;
- }
- else
- {
- return UnwStartArm(state);
- }
- }
- }
- }
- }
- break;
- case 2:
- if (0 == L)
- {
- /* STMDB / PUSH if Rn == 13 */
- if (13 != Rn)
- {
- UnwPrintd1("STMDB ...");
- }
- else
- {
- Int16 register_list = (instr2 & 0x7FFF);
- Int8 bitCount = 0;
- Int32 address;
- Int8 i;
-
- for (i = 0; i < 15; i++)
- {
- if ((register_list & (0x1 << i)) != 0) bitCount++;
- }
- address = state->regData[REG_SP].v - 4*bitCount;
- UnwPrintd1("PUSH {");
- for (i = 0; i < 15; i++)
- {
- if ((register_list & (0x1 << i)) != 0)
- {
- if (!UnwMemWriteRegister (state,
- address,
- &state->regData[i]))
- {
- return UNWIND_DREAD_W_FAIL;
- }
- address += 4;
- UnwPrintd2("r%d,", i);
- }
- }
- state->regData[REG_SP].v = address;
- UnwPrintd1("}");
- }
- }
- else
- {
- /* LDMDB */
- UnwPrintd1("LDMDB ...");
- }
- break;
- case 3:
- if (0 == L)
- {
- /* SRS */
- UnwPrintd1("SRS ...");
- }
- else
- {
- /* RFE */
- UnwPrintd1("RFE ...");
- }
- break;
- }
-
- return res;
-}
-
-static UnwResult UnwLoadStoreSingleDataItemOpA0101(UnwState * const state, Int32 instr)
-{
- Int8 opB = (instr & (0x7 << 9)) >> 9;
- Int8 Rt;
- switch (opB)
- {
- case 0:
- case 1:
- case 2:
- /* stores - ignore */
- UnwPrintd1("STR(H/B) ...");
- break;
- case 3:
- case 4:
- case 5:
- case 6:
- case 7:
- Rt = instr & 0x7;
- state->regData[Rt].o = REG_VAL_INVALID;
- UnwPrintd2("LDR(SB/H/B/SH) r%d", Rt);
- break;
- }
- return UNWIND_SUCCESS;
-}
-
-static void doBranchOffset(UnwState * const state, SignedInt16 branchValue)
-{
- /* Update PC */
- state->regData[REG_PC].v += branchValue;
-
- /* Need to advance by a word to account for pre-fetch.
- * Advance by a half word here, allowing the normal address
- * advance to account for the other half word.
- */
- state->regData[REG_PC].v += 2;
-
- /* Display PC of next instruction */
- UnwPrintd2("\n New PC=%x", state->regData[REG_PC].v + 2);
-}
-
-static UnwResult doBranch (UnwState * const state, SignedInt16 branchValue,
- const char *opname)
-{
- Int32 data;
- Boolean tracked;
-
- Boolean used = UnwMemHashRead (&state->branchData,
- state->regData[REG_PC].v, &data, &tracked);
-
- UnwPrintd4 ("%s %d ; %s", opname, branchValue, used ? "FOLLOW" : "SKIPPING");
-
- if (!used)
- {
- UnwMemHashWrite (&state->branchData,
- state->regData[REG_PC].v, 0, TRUE);
- }
- else
- {
- UnwMemHashWrite (&state->branchData,
- state->regData[REG_PC].v, 0, FALSE);
- doBranchOffset (state, branchValue);
- }
- return UNWIND_SUCCESS;
-}
-
-UnwResult UnwStartThumb(UnwState * const state)
-{
- Boolean found = FALSE;
- Int16 t = UNW_MAX_INSTR_COUNT;
- UnwResult result = UNWIND_SUCCESS;
-
- do
- {
- Int16 instr;
-
- result = UNWIND_SUCCESS;
-
- /* Attempt to read the instruction */
- if(!state->cb->readH(state->regData[15].v & (~0x1), &instr))
- {
- return UNWIND_IREAD_H_FAIL;
- }
-
- UnwPrintd4("T %x %x %04x:",
- state->regData[13].v, state->regData[15].v, instr);
-
- /* Check that the PC is still on Thumb alignment */
- if(!UnwIsAddrThumb(state->regData[REG_PC].v, state->regData[REG_SPSR].v))
- {
- UnwPrintd1("\nError: PC misalignment\n");
- return UNWIND_INCONSISTENT;
- }
-
- /* Check that the SP and PC have not been invalidated */
- if(!M_IsOriginValid(state->regData[13].o) || !M_IsOriginValid(state->regData[15].o))
- {
- UnwPrintd1("\nError: PC or SP invalidated\n");
- return UNWIND_INCONSISTENT;
- }
-
- /* Format 1: Move shifted register
- * LSL Rd, Rs, #Offset5
- * LSR Rd, Rs, #Offset5
- * ASR Rd, Rs, #Offset5
- */
- if((instr & 0xe000) == 0x0000 && (instr & 0x1800) != 0x1800)
- {
- Boolean signExtend;
- Int8 op = (instr & 0x1800) >> 11;
- Int8 offset5 = (instr & 0x07c0) >> 6;
- Int8 rs = (instr & 0x0038) >> 3;
- Int8 rd = (instr & 0x0007);
-
- switch(op)
- {
- case 0: /* LSL */
- UnwPrintd6("LSL r%d, r%d, #%d\t; r%d %s", rd, rs, offset5, rs, M_Origin2Str(state->regData[rs].o));
- state->regData[rd].v = state->regData[rs].v << offset5;
- state->regData[rd].o = state->regData[rs].o;
- state->regData[rd].o |= REG_VAL_ARITHMETIC;
- break;
-
- case 1: /* LSR */
- UnwPrintd6("LSR r%d, r%d, #%d\t; r%d %s", rd, rs, offset5, rs, M_Origin2Str(state->regData[rs].o));
- state->regData[rd].v = state->regData[rs].v >> offset5;
- state->regData[rd].o = state->regData[rs].o;
- state->regData[rd].o |= REG_VAL_ARITHMETIC;
- break;
-
- case 2: /* ASR */
- UnwPrintd6("ASL r%d, r%d, #%d\t; r%d %s", rd, rs, offset5, rs, M_Origin2Str(state->regData[rs].o));
-
- signExtend = (state->regData[rs].v & 0x8000) ? TRUE : FALSE;
- state->regData[rd].v = state->regData[rs].v >> offset5;
- if(signExtend)
- {
- state->regData[rd].v |= 0xffffffff << (32 - offset5);
- }
- state->regData[rd].o = state->regData[rs].o;
- state->regData[rd].o |= REG_VAL_ARITHMETIC;
- break;
- }
- }
- /* Format 2: add/subtract
- * ADD Rd, Rs, Rn
- * ADD Rd, Rs, #Offset3
- * SUB Rd, Rs, Rn
- * SUB Rd, Rs, #Offset3
- */
- else if((instr & 0xf800) == 0x1800)
- {
- Boolean I = (instr & 0x0400) ? TRUE : FALSE;
- Boolean op = (instr & 0x0200) ? TRUE : FALSE;
- Int8 rn = (instr & 0x01c0) >> 6;
- Int8 rs = (instr & 0x0038) >> 3;
- Int8 rd = (instr & 0x0007);
-
- /* Print decoding */
- UnwPrintd6("%s r%d, r%d, %c%d\t;",
- op ? "SUB" : "ADD",
- rd, rs,
- I ? '#' : 'r',
- rn);
- UnwPrintd5("r%d %s, r%d %s",
- rd, M_Origin2Str(state->regData[rd].o),
- rs, M_Origin2Str(state->regData[rs].o));
- if(!I)
- {
- UnwPrintd3(", r%d %s", rn, M_Origin2Str(state->regData[rn].o));
-
- /* Perform calculation */
- if(op)
- {
- state->regData[rd].v = state->regData[rs].v - state->regData[rn].v;
- }
- else
- {
- state->regData[rd].v = state->regData[rs].v + state->regData[rn].v;
- }
-
- /* Propagate the origin */
- if(M_IsOriginValid(state->regData[rs].v) &&
- M_IsOriginValid(state->regData[rn].v))
- {
- state->regData[rd].o = state->regData[rs].o;
- state->regData[rd].o |= REG_VAL_ARITHMETIC;
- }
- else
- {
- state->regData[rd].o = REG_VAL_INVALID;
- }
- }
- else
- {
- /* Perform calculation */
- if(op)
- {
- state->regData[rd].v = state->regData[rs].v - rn;
- }
- else
- {
- state->regData[rd].v = state->regData[rs].v + rn;
- }
-
- /* Propagate the origin */
- state->regData[rd].o = state->regData[rs].o;
- state->regData[rd].o |= REG_VAL_ARITHMETIC;
- }
- }
- /* Format 3: move/compare/add/subtract immediate
- * MOV Rd, #Offset8
- * CMP Rd, #Offset8
- * ADD Rd, #Offset8
- * SUB Rd, #Offset8
- */
- else if((instr & 0xe000) == 0x2000)
- {
- Int8 op = (instr & 0x1800) >> 11;
- Int8 rd = (instr & 0x0700) >> 8;
- Int8 offset8 = (instr & 0x00ff);
-
- switch(op)
- {
- case 0: /* MOV */
- UnwPrintd3("MOV r%d, #0x%x", rd, offset8);
- state->regData[rd].v = offset8;
- state->regData[rd].o = REG_VAL_FROM_CONST;
- break;
-
- case 1: /* CMP */
- /* Irrelevant to unwinding */
- UnwPrintd1("CMP ???");
- break;
-
- case 2: /* ADD */
- UnwPrintd5("ADD r%d, #0x%x\t; r%d %s",
- rd, offset8, rd, M_Origin2Str(state->regData[rd].o));
- state->regData[rd].v += offset8;
- state->regData[rd].o |= REG_VAL_ARITHMETIC;
- break;
-
- case 3: /* SUB */
- UnwPrintd5("SUB r%d, #0x%d\t; r%d %s",
- rd, offset8, rd, M_Origin2Str(state->regData[rd].o));
- state->regData[rd].v += offset8;
- state->regData[rd].o |= REG_VAL_ARITHMETIC;
- break;
- }
- }
- /* Format 4: ALU operations
- * AND Rd, Rs
- * EOR Rd, Rs
- * LSL Rd, Rs
- * LSR Rd, Rs
- * ASR Rd, Rs
- * ADC Rd, Rs
- * SBC Rd, Rs
- * ROR Rd, Rs
- * TST Rd, Rs
- * NEG Rd, Rs
- * CMP Rd, Rs
- * CMN Rd, Rs
- * ORR Rd, Rs
- * MUL Rd, Rs
- * BIC Rd, Rs
- * MVN Rd, Rs
- */
- else if((instr & 0xfc00) == 0x4000)
- {
- Int8 op = (instr & 0x03c0) >> 6;
- Int8 rs = (instr & 0x0038) >> 3;
- Int8 rd = (instr & 0x0007);
-#if defined(UNW_DEBUG)
- static const char * const mnu[16] =
- { "AND", "EOR", "LSL", "LSR",
- "ASR", "ADC", "SBC", "ROR",
- "TST", "NEG", "CMP", "CMN",
- "ORR", "MUL", "BIC", "MVN" };
-#endif
- /* Print the mnemonic and registers */
- switch(op)
- {
- case 0: /* AND */
- case 1: /* EOR */
- case 2: /* LSL */
- case 3: /* LSR */
- case 4: /* ASR */
- case 7: /* ROR */
- case 9: /* NEG */
- case 12: /* ORR */
- case 13: /* MUL */
- case 15: /* MVN */
- UnwPrintd8("%s r%d ,r%d\t; r%d %s, r%d %s",
- mnu[op],
- rd, rs,
- rd, M_Origin2Str(state->regData[rd].o),
- rs, M_Origin2Str(state->regData[rs].o));
- break;
-
- case 5: /* ADC */
- case 6: /* SBC */
- UnwPrintd4("%s r%d, r%d", mnu[op], rd, rs);
- break;
-
- case 8: /* TST */
- case 10: /* CMP */
- case 11: /* CMN */
- /* Irrelevant to unwinding */
- UnwPrintd2("%s ???", mnu[op]);
- break;
-
- case 14: /* BIC */
- UnwPrintd5("r%d ,r%d\t; r%d %s",
- rd, rs,
- rs, M_Origin2Str(state->regData[rs].o));
- state->regData[rd].v &= !state->regData[rs].v;
- break;
- }
-
-
- /* Perform operation */
- switch(op)
- {
- case 0: /* AND */
- state->regData[rd].v &= state->regData[rs].v;
- break;
-
- case 1: /* EOR */
- state->regData[rd].v ^= state->regData[rs].v;
- break;
-
- case 2: /* LSL */
- state->regData[rd].v <<= state->regData[rs].v;
- break;
-
- case 3: /* LSR */
- state->regData[rd].v >>= state->regData[rs].v;
- break;
-
- case 4: /* ASR */
- if(state->regData[rd].v & 0x80000000)
- {
- state->regData[rd].v >>= state->regData[rs].v;
- state->regData[rd].v |= 0xffffffff << (32 - state->regData[rs].v);
- }
- else
- {
- state->regData[rd].v >>= state->regData[rs].v;
- }
-
- break;
-
- case 5: /* ADC */
- case 6: /* SBC */
- case 8: /* TST */
- case 10: /* CMP */
- case 11: /* CMN */
- break;
- case 7: /* ROR */
- state->regData[rd].v = (state->regData[rd].v >> state->regData[rs].v) |
- (state->regData[rd].v << (32 - state->regData[rs].v));
- break;
-
- case 9: /* NEG */
- state->regData[rd].v = -state->regData[rs].v;
- break;
-
- case 12: /* ORR */
- state->regData[rd].v |= state->regData[rs].v;
- break;
-
- case 13: /* MUL */
- state->regData[rd].v *= state->regData[rs].v;
- break;
-
- case 14: /* BIC */
- state->regData[rd].v &= !state->regData[rs].v;
- break;
-
- case 15: /* MVN */
- state->regData[rd].v = !state->regData[rs].v;
- break;
- }
-
- /* Propagate data origins */
- switch(op)
- {
- case 0: /* AND */
- case 1: /* EOR */
- case 2: /* LSL */
- case 3: /* LSR */
- case 4: /* ASR */
- case 7: /* ROR */
- case 12: /* ORR */
- case 13: /* MUL */
- case 14: /* BIC */
- if(M_IsOriginValid(state->regData[rs].o) && M_IsOriginValid(state->regData[rs].o))
- {
- state->regData[rd].o = state->regData[rs].o;
- state->regData[rd].o |= REG_VAL_ARITHMETIC;
- }
- else
- {
- state->regData[rd].o = REG_VAL_INVALID;
- }
- break;
-
- case 5: /* ADC */
- case 6: /* SBC */
- /* C-bit not tracked */
- state->regData[rd].o = REG_VAL_INVALID;
- break;
-
- case 8: /* TST */
- case 10: /* CMP */
- case 11: /* CMN */
- /* Nothing propagated */
- break;
-
- case 9: /* NEG */
- case 15: /* MVN */
- state->regData[rd].o = state->regData[rs].o;
- state->regData[rd].o |= REG_VAL_ARITHMETIC;
- break;
-
- }
-
- }
- /* Format 5: Hi register operations/branch exchange
- * ADD Rd, Hs
- * ADD Hd, Rs
- * ADD Hd, Hs
- * CMP Hd
- * MOV Rd
- * MOV Hd
- * BX
- * BLX
- */
- else if((instr & 0xfc00) == 0x4400)
- {
- Int8 op = (instr & 0x0300) >> 8;
- Boolean h1 = (instr & 0x0080) ? TRUE: FALSE;
- Boolean h2 = (instr & 0x0040) ? TRUE: FALSE;
- Int8 rhs = (instr & 0x0038) >> 3;
- Int8 rhd = (instr & 0x0007);
-
- /* Adjust the register numbers */
- if(h2) rhs += 8;
- if(h1) rhd += 8;
-
- if(op == 1 && !h1 && !h2)
- {
- UnwPrintd1("\nError: h1 or h2 must be set for ADD, CMP or MOV\n");
- return UNWIND_ILLEGAL_INSTR;
- }
-
- switch(op)
- {
- case 0: /* ADD */
- UnwPrintd5("ADD r%d, r%d\t; r%d %s",
- rhd, rhs, rhs, M_Origin2Str(state->regData[rhs].o));
- state->regData[rhd].v += state->regData[rhs].v;
- state->regData[rhd].o = state->regData[rhs].o;
- state->regData[rhd].o |= REG_VAL_ARITHMETIC;
- break;
-
- case 1: /* CMP */
- /* Irrelevant to unwinding */
- UnwPrintd1("CMP ???");
- break;
-
- case 2: /* MOV */
- UnwPrintd5("MOV r%d, r%d\t; r%d %s",
- rhd, rhs, rhd, M_Origin2Str(state->regData[rhs].o));
- state->regData[rhd].v = state->regData[rhs].v;
- state->regData[rhd].o = state->regData[rhd].o;
- break;
-
- case 3: /* BX */
- UnwPrintd4("BX r%d\t; r%d %s\n",
- rhs, rhs, M_Origin2Str(state->regData[rhs].o));
-
- /* Only follow BX if the data was from the stack */
- if(state->regData[rhs].o == REG_VAL_FROM_STACK)
- {
- UnwPrintd2(" Return PC=0x%x\n", state->regData[rhs].v & (~0x1));
-
- /* Report the return address, including mode bit */
- if(!UnwReportRetAddr(state, state->regData[rhs].v))
- {
- return UNWIND_TRUNCATED;
- }
- t = UNW_MAX_INSTR_COUNT;
-
- /* Update the PC */
- state->regData[15].v = state->regData[rhs].v;
-
- /* Determine the new mode */
- if(UnwIsAddrThumb(state->regData[rhs].v, state->regData[REG_SPSR].v))
- {
- /* Branching to THUMB */
-
- /* Account for the auto-increment which isn't needed */
- state->regData[15].v -= 2;
- }
- else
- {
- /* Branch to ARM */
- return UnwStartArm(state);
- }
- }
- else
- {
- UnwPrintd4("\nError: BX to invalid register: r%d = 0x%x (%s)\n",
- rhs, state->regData[rhs].o, M_Origin2Str(state->regData[rhs].o));
- result = UNWIND_FAILURE;
- }
- }
- }
- /* Format 9: load/store with immediate offset
- * LDR/STR Rd, [Rb, #imm]
- */
- else if ((instr & 0xe000) == 0x6000)
- {
- Int8 rd = instr & 0x7;
- Int8 rb = (instr & (0x7 << 3)) >> 3;
- Int32 offset5 = (instr & (0x1f << 6)) >> 6;
-
- offset5 += state->regData[rb].v;
-
- if ((instr & 0x0400) != 0)
- {
- /* This is LDR */
-
- UnwPrintd3("LDR r%d, 0x%08x", rd, offset5);
-
- if (!UnwMemReadRegister (state, offset5, &state->regData[rd]))
- {
- state->regData[rd].o = REG_VAL_INVALID;
- }
- }
- else
- {
- /* in STR case, ignore it (for now) */
- UnwPrintd3("STR r%d, 0x%08x", rd, offset5);
- }
- }
- /* Format 9: PC-relative load
- * LDR Rd,[PC, #imm]
- */
- else if((instr & 0xf800) == 0x4800)
- {
- Int8 rd = (instr & 0x0700) >> 8;
- Int8 word8 = (instr & 0x00ff);
- Int32 address;
-
- /* Compute load address, adding a word to account for prefetch */
- address = (state->regData[15].v & (~0x3)) + 4 + (word8 << 2);
-
- UnwPrintd3("LDR r%d, 0x%08x", rd, address);
-
- if(!UnwMemReadRegister(state, address, &state->regData[rd]))
- {
- state->regData[rd].o = REG_VAL_INVALID;
- }
- }
- else if((instr & 0xf800) == 0x4000)
- {
- /* in STR case, ignore it (for now) */
- UnwPrintd1("STR ???");
- }
- /* Format 13: add offset to Stack Pointer
- * ADD sp,#+imm
- * ADD sp,#-imm
- */
- else if((instr & 0xff00) == 0xB000)
- {
- Int8 value = (instr & 0x7f) * 4;
-
- /* Check the negative bit */
- if((instr & 0x80) != 0)
- {
- UnwPrintd2("SUB sp,#0x%x", value);
- state->regData[13].v -= value;
- }
- else
- {
- UnwPrintd2("ADD sp,#0x%x", value);
- state->regData[13].v += value;
- }
- }
- /* Format 14: push/pop registers
- * PUSH {Rlist}
- * PUSH {Rlist, LR}
- * POP {Rlist}
- * POP {Rlist, PC}
- */
- else if((instr & 0xf600) == 0xb400)
- {
- Boolean L = (instr & 0x0800) ? TRUE : FALSE;
- Boolean R = (instr & 0x0100) ? TRUE : FALSE;
- Int8 rList = (instr & 0x00ff);
-
- if(L)
- {
- Int8 r;
-
- /* Load from memory: POP */
- UnwPrintd2("POP {Rlist%s}\n", R ? ", PC" : "");
-
- for(r = 0; r < 8; r++)
- {
- if(rList & (0x1 << r))
- {
- /* Read the word */
- if(!UnwMemReadRegister(state, state->regData[13].v, &state->regData[r]))
- {
- return UNWIND_DREAD_W_FAIL;
- }
-
- /* Alter the origin to be from the stack if it was valid */
- if(M_IsOriginValid(state->regData[r].o))
- {
- state->regData[r].o = REG_VAL_FROM_STACK;
- }
-
- state->regData[13].v += 4;
-
- UnwPrintd3(" r%d = 0x%08x\n", r, state->regData[r].v);
- }
- }
-
- /* Check if the PC is to be popped */
- if(R)
- {
- /* Get the return address */
- if(!UnwMemReadRegister(state, state->regData[13].v, &state->regData[15]))
- {
- return UNWIND_DREAD_W_FAIL;
- }
-
- /* Alter the origin to be from the stack if it was valid */
- if(!M_IsOriginValid(state->regData[15].o))
- {
- /* Return address is not valid */
- UnwPrintd1("PC popped with invalid address\n");
- return UNWIND_FAILURE;
- }
- else
- {
- /* The bottom bit should have been set to indicate that
- * the caller was from Thumb. This would allow return
- * by BX for interworking APCS.
- */
- if(!UnwIsAddrThumb(state->regData[REG_PC].v, state->regData[REG_SPSR].v))
- {
- UnwPrintd2("Warning: Return address not to Thumb: 0x%08x\n",
- state->regData[15].v);
-
- /* Pop into the PC will not switch mode */
- return UNWIND_INCONSISTENT;
- }
-
- /* Store the return address */
- if(!UnwReportRetAddr(state, state->regData[15].v))
- {
- return UNWIND_TRUNCATED;
- }
- t = UNW_MAX_INSTR_COUNT;
-
- /* Now have the return address */
- UnwPrintd2(" Return PC=%x\n", state->regData[15].v);
-
- /* Update the pc */
- state->regData[13].v += 4;
-
- /* Compensate for the auto-increment, which isn't needed here */
- state->regData[15].v -= 2;
- }
- }
-
- }
- else
- {
- SignedInt8 r;
-
- /* Store to memory: PUSH */
- UnwPrintd2("PUSH {Rlist%s}", R ? ", LR" : "");
-
- /* Check if the LR is to be pushed */
- if(R)
- {
- UnwPrintd3("\n lr = 0x%08x\t; %s",
- state->regData[14].v, M_Origin2Str(state->regData[14].o));
-
- state->regData[13].v -= 4;
-
- /* Write the register value to memory */
- if(!UnwMemWriteRegister(state, state->regData[13].v, &state->regData[14]))
- {
- return UNWIND_DWRITE_W_FAIL;
- }
- }
-
- for(r = 7; r >= 0; r--)
- {
- if(rList & (0x1 << r))
- {
- UnwPrintd4("\n r%d = 0x%08x\t; %s",
- r, state->regData[r].v, M_Origin2Str(state->regData[r].o));
-
- state->regData[13].v -= 4;
-
- if(!UnwMemWriteRegister(state, state->regData[13].v, &state->regData[r]))
- {
- return UNWIND_DWRITE_W_FAIL;
- }
- }
- }
- }
- }
- /* Format 18: unconditional branch
- * B label
- */
- else if((instr & 0xf800) == 0xe000)
- {
- SignedInt16 branchValue = signExtend11(instr & 0x07ff);
-
- /* Branch distance is twice that specified in the instruction. */
- branchValue *= 2;
-
- UnwPrintd2("B %d \n", branchValue);
-
- doBranchOffset (state, branchValue);
- }
- /* Load/store single data item
- * STR/STRH/STRB/LDRSB/LDR/LDRH/LDRB/LDRSH (register)
- */
- else if ((instr & 0xf000) == 0x5000)
- {
- result = UnwLoadStoreSingleDataItemOpA0101(state, instr);
- }
- /* Load/store single data item
- * Store/Load Register SP relative
- */
- else if ((instr & 0xf000) == 0x9000)
- {
- Int8 opB = (instr & (0x1 << 11)) >> 11;
- Int16 Rt = (instr & (0x7 << 8)) >> 8;
- Int16 imm8 = instr &0xFF;
-
- imm8 <<= 2;
-
- if (0 == opB)
- {
- UnwPrintd3("STR r%d, [sp, #0x%08x]", Rt, imm8);
- if (!UnwMemWriteRegister(state, state->regData[REG_SP].v+imm8, &state->regData[Rt]))
- {
- return UNWIND_DREAD_W_FAIL;
- }
- }
- else
- {
- UnwPrintd3("LDR r%d, [sp, #0x%08x]", Rt, imm8);
- if (!UnwMemReadRegister(state, state->regData[REG_SP].v+imm8, &state->regData[Rt]))
- {
- return UNWIND_DREAD_W_FAIL;
- }
- state->regData[Rt].v = REG_VAL_FROM_STACK;
- }
- }
- /* Conditional branch, and Supervisor Call */
- else if ((instr & 0xf000) == 0xd000)
- {
- Int8 cond = (instr & (0xF << 8)) >> 8;
- switch (cond)
- {
- case 0xF:
- UnwPrintd2("SVC ... (lr=%x)", state->regData[REG_LR].v);
- break;
- case 0xE:
- result = UNWIND_FAILURE;
- UnwPrintd1("ILLEGAL ; breaking");
- break;
- default:
- {
- SignedInt16 branchValue = (signExtend8 (instr & 0xFF)) * 2;
-
- result = doBranch(state, branchValue, "B(cond)");
- }
- break;
- }
- }
- /* Compare and Branch on Zero */
- else if ((instr & 0xff00) == 0xb100)
- {
- SignedInt16 imm32 = (instr & (0x1F << 3)) >> 3;
- SignedInt16 i = (instr & (1 << 9)) >> 9;
- imm32 = (imm32 | (i << 5)) << 1;
-
- result = doBranch(state, imm32, "CB{N}Z");
- }
- else if ((instr & 0xff00) == 0xbf00)
- {
- UnwPrintd1("IT/NOP/YIELD/WFE/WFI/SEV ...");
- }
- /* 32-bit instructions */
- else if (((instr & 0xe000) == 0xe000) && ((instr & 0xf800) != 0xe00))
- {
- Int8 op1 = (instr & (0x3 << 11)) >> 11;
- Int8 op2 = (instr & (0x7F << 4)) >> 4;
- Int8 op;
- UnwResult res = UNWIND_SUCCESS;
-
- Int16 instr2;
- /* read second part of this 32-bit instruction */
- if(!state->cb->readH((state->regData[15].v + 2) & (~0x1), &instr2))
- {
- return UNWIND_IREAD_H_FAIL;
- }
-
- op = (instr2 & (1 << 15)) >> 15;
-
- switch (op1)
- {
- case 1:
- if ((op2 & 0x64) == 0)
- {
- /* Load/store multiple */
- res = Unw32LoadStoreMultiple(state, instr, instr2);
- }
- else if ((op2 & 0x64) == 4)
- {
- /* Load/store dual, load/store exclusive, table branch */
- UnwPrintd1("32-bit load/store dual, load/store exclusive, table branch...");
- }
- else if ((op2 & 0x60) == 0x20)
- {
- /* Data-processing (shifted register) */
- UnwPrintd1("32-bit data processing (shifted register)...");
- }
- else /* if (op2 & 0x40 == 0x40) */
- {
- /* Coprocessor instructions */
- UnwPrintd1("32-bit coprocessor...");
- }
- break;
- case 2:
- if (0 == op)
- {
- if ((op2 & 0x20) == 0)
- {
- /* Data processing (modified immediate) */
- res = Unw32DataProcessingModifiedImmediate(state, instr, instr2);
- }
- else
- {
- /* Data-processing (plain binary immediate) */
- UnwPrintd1("32-bit data processing (plain binary immediate)...");
- }
- }
- else
- {
- /* Branches and miscellaneous control */
- UnwPrintd1("32-bit branches and miscellaneous control...");
- }
- break;
- case 3:
- if ((op2 & 0x71) == 0)
- {
- /* Store single data item */
- UnwPrintd1("32-bit store single data item...");
- }
- else if ((op2 & 0x71) == 0x10)
- {
- /* Advanced SIMD element or structure load/store instructions */
- UnwPrintd1("32-bit advanced SIMD element or structure load/store...");
- }
- else if ((op2 & 0x67) == 1)
- {
- /* Load byte, memory hints */
- UnwPrintd1("32-bit load byte, memory hints...");
- }
- else if ((op2 & 0x67) == 3)
- {
- /* Load halfword, memory hints */
- UnwPrintd1("32-bit load halfword, memory hints...");
- }
- else if ((op2 & 0x67) == 5)
- {
- /* Load word */
- res = Unw32LoadWord (state, instr, instr2);
- }
- else if ((op2 & 0x67) == 7)
- {
- res = UNWIND_ILLEGAL_INSTR;
- }
- else if ((op2 & 0x70) == 0x20)
- {
- /* Data-processing (register) */
- UnwPrintd1("32-bit data processing...");
- }
- else if ((op2 & 0x78) == 0x30)
- {
- /* Multiply, multiply accumulate, and absolute difference */
- UnwPrintd1("32-bit multiply...");
- }
- else if ((op2 & 0x78) == 0x38)
- {
- /* Long multiply, long multiply accumulate, and divide */
- UnwPrintd1("32-bit long multiply...");
- }
- else if ((op2 & 0x80) == 0x80)
- {
- /* Coprocessor instructions */
- UnwPrintd1("32-bit coprocessor (2) ...");
- }
- else
- res = UNWIND_ILLEGAL_INSTR;
- }
-
- state->regData[REG_PC].v += 2;
-
- if (UNWIND_SUCCESS != res)
- return res;
- }
- else
- {
- UnwPrintd1("????");
-
- /* Unknown/undecoded. May alter some register, so invalidate file */
- UnwInvalidateRegisterFile(state->regData);
- }
-
- UnwPrintd1("\n");
-
- /* Should never hit the reset vector */
- if(state->regData[15].v == 0) return UNWIND_RESET;
-
- /* Check next address */
- state->regData[15].v += 2;
-
- /* Garbage collect the memory hash (used only for the stack) */
- UnwMemHashGC(state);
-
- t--;
- if(t == 0 || result == UNWIND_FAILURE)
- {
- /* TODO: try scanning prologue - here */
- /* call callback to get address of current function */
- Int32 prologue_pc = state->cb->getProloguePC (state->lastReported);
- /* Prologue fits within 32 16-bit instructions */
- Int32 prologue_pc_end = prologue_pc + 31*2;
- Boolean changed = FALSE;
-
- if (0 == t) result = UNWIND_EXHAUSTED;
-
- UnwPrintd3("Unwind exhausted (result=%d), prologue at: %x\n", result, prologue_pc);
-
- if (0 == prologue_pc) return UNWIND_FAILURE;
-
- UnwInvalidateRegisterFile (state->regData);
-
- while (prologue_pc_end > prologue_pc)
- {
- Int16 instr;
- Int16 prev_instr = 0;
-
- if(!state->cb->readH(prologue_pc_end & (~0x1), &instr))
- {
- return UNWIND_IREAD_H_FAIL;
- }
- if (prologue_pc_end - 2 >= prologue_pc)
- {
- if(!state->cb->readH((prologue_pc_end-2) & (~0x1), &prev_instr))
- {
- return UNWIND_IREAD_H_FAIL;
- }
- }
- /* Check if this is not a part of previous 32-bit instruction */
- if ((prev_instr & 0xf800) != 0xe000)
- {
- /* Now, let's look for all the interesting stuff we want:
- * push {rlist, lr}
- * sub sp, #imm
- */
- if ((instr & 0xff80) == 0xb080)
- {
- /* sub sp, #imm */
- Int16 imm7 = instr & 0x7F;
- imm7 = imm7 << 2;
- state->regData[REG_SP].v += imm7;
- changed = TRUE;
- }
- else if ((instr & 0xfe00) == 0xb400)
- {
- /* push {rlist, lr} */
- Int16 M = (instr & (0x1 << 8)) >> 8;
- Int16 register_list = (instr & 0xFF) | (M << 14);
- int i;
-
- for (i = 0; i < 15; i++)
- {
- if ((register_list & (0x1 << i)) != 0)
- {
- if (!UnwMemReadRegister(state, state->regData[REG_SP].v,
- &state->regData[i]))
- {
- return UNWIND_DREAD_W_FAIL;
- }
- state->regData[i].o = REG_VAL_FROM_STACK;
- state->regData[REG_SP].v += 4;
- changed = TRUE;
- }
- }
- }
- }
- prologue_pc_end -= 2;
- }
-
- if (changed)
- {
- /* Report the return address, including mode bit */
- if(!UnwReportRetAddr(state, state->regData[REG_LR].v))
- {
- return UNWIND_TRUNCATED;
- }
-
- if (state->regData[REG_PC].v-2 == state->regData[REG_LR].v)
- {
- return UNWIND_FAILURE;
- }
-
- /* Update the PC */
- state->regData[REG_PC].v = state->regData[REG_LR].v;
-
- UnwPrintd2(" New PC=%x\n", state->regData[REG_PC].v);
-
- /* Determine the new mode */
- if(UnwIsAddrThumb(state->regData[REG_PC].v, state->regData[REG_SPSR].v))
- {
- /* Branching to THUMB - PC already set - restore count */
- t = UNW_MAX_INSTR_COUNT;
- }
- else
- {
- /* Branch to ARM */
- return UnwStartArm(state);
- }
- }
- else
- return result;
- }
-
- }
- while(!found);
-
- return result;
-}
-
-#endif /* UPGRADE_ARM_STACK_UNWIND */
-
-/* END OF FILE */
-
+++ /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);
-
- Int32 (*getProloguePC)(const Int32 current_pc);
-
-#if defined(UNW_DEBUG)
- /** Print a formatted line for debug. */
- int (*printf)(const char *format, ...);
-#endif
-
-}
-UnwindCallbacks;
-
-/***************************************************************************
- * Macros
- **************************************************************************/
-
-/***************************************************************************
- * Function Prototypes
- **************************************************************************/
-
-/** Start unwinding the current stack.
- * This will unwind the stack starting at the PC value supplied to in the
- * link register (i.e. not a normal register) and the stack pointer value
- * supplied.
- */
-UnwResult UnwindStart(Int32 spValue,
- const UnwindCallbacks *cb,
- void *data);
-
-#endif /* UPGRADE_ARM_STACK_UNWIND */
-
-#endif /* UNWARMINDER_H */
-
-/* END OF FILE */
+++ /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