2012-05-30 19:31:44 +00:00
|
|
|
/* Target-dependent code for the Tilera TILE-Gx processor.
|
|
|
|
|
|
2014-01-01 03:54:24 +00:00
|
|
|
Copyright (C) 2012-2014 Free Software Foundation, Inc.
|
2012-05-30 19:31:44 +00:00
|
|
|
|
|
|
|
|
This file is part of GDB.
|
|
|
|
|
|
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
|
the Free Software Foundation; either version 3 of the License, or
|
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
|
|
|
|
|
|
|
|
|
#include "defs.h"
|
|
|
|
|
#include "frame.h"
|
|
|
|
|
#include "frame-base.h"
|
|
|
|
|
#include "frame-unwind.h"
|
|
|
|
|
#include "dwarf2-frame.h"
|
|
|
|
|
#include "trad-frame.h"
|
|
|
|
|
#include "symtab.h"
|
|
|
|
|
#include "gdbtypes.h"
|
|
|
|
|
#include "gdbcmd.h"
|
|
|
|
|
#include "gdbcore.h"
|
|
|
|
|
#include "value.h"
|
|
|
|
|
#include "dis-asm.h"
|
|
|
|
|
#include "inferior.h"
|
remove gdb_string.h
This removes gdb_string.h. This patch is purely mechanical. I
created it by running the two commands:
git rm common/gdb_string.h
perl -pi -e's/"gdb_string.h"/<string.h>/;' *.[chyl] */*.[chyl]
2013-11-18 Tom Tromey <tromey@redhat.com>
* common/gdb_string.h: Remove.
* aarch64-tdep.c: Use string.h, not gdb_string.h.
* ada-exp.y: Use string.h, not gdb_string.h.
* ada-lang.c: Use string.h, not gdb_string.h.
* ada-lex.l: Use string.h, not gdb_string.h.
* ada-typeprint.c: Use string.h, not gdb_string.h.
* ada-valprint.c: Use string.h, not gdb_string.h.
* aix-thread.c: Use string.h, not gdb_string.h.
* alpha-linux-tdep.c: Use string.h, not gdb_string.h.
* alpha-mdebug-tdep.c: Use string.h, not gdb_string.h.
* alpha-nat.c: Use string.h, not gdb_string.h.
* alpha-osf1-tdep.c: Use string.h, not gdb_string.h.
* alpha-tdep.c: Use string.h, not gdb_string.h.
* alphanbsd-tdep.c: Use string.h, not gdb_string.h.
* amd64-dicos-tdep.c: Use string.h, not gdb_string.h.
* amd64-linux-nat.c: Use string.h, not gdb_string.h.
* amd64-linux-tdep.c: Use string.h, not gdb_string.h.
* amd64-nat.c: Use string.h, not gdb_string.h.
* amd64-sol2-tdep.c: Use string.h, not gdb_string.h.
* amd64fbsd-tdep.c: Use string.h, not gdb_string.h.
* amd64obsd-tdep.c: Use string.h, not gdb_string.h.
* arch-utils.c: Use string.h, not gdb_string.h.
* arm-linux-nat.c: Use string.h, not gdb_string.h.
* arm-linux-tdep.c: Use string.h, not gdb_string.h.
* arm-tdep.c: Use string.h, not gdb_string.h.
* arm-wince-tdep.c: Use string.h, not gdb_string.h.
* armbsd-tdep.c: Use string.h, not gdb_string.h.
* armnbsd-nat.c: Use string.h, not gdb_string.h.
* armnbsd-tdep.c: Use string.h, not gdb_string.h.
* armobsd-tdep.c: Use string.h, not gdb_string.h.
* avr-tdep.c: Use string.h, not gdb_string.h.
* ax-gdb.c: Use string.h, not gdb_string.h.
* ax-general.c: Use string.h, not gdb_string.h.
* bcache.c: Use string.h, not gdb_string.h.
* bfin-tdep.c: Use string.h, not gdb_string.h.
* breakpoint.c: Use string.h, not gdb_string.h.
* build-id.c: Use string.h, not gdb_string.h.
* buildsym.c: Use string.h, not gdb_string.h.
* c-exp.y: Use string.h, not gdb_string.h.
* c-lang.c: Use string.h, not gdb_string.h.
* c-typeprint.c: Use string.h, not gdb_string.h.
* c-valprint.c: Use string.h, not gdb_string.h.
* charset.c: Use string.h, not gdb_string.h.
* cli-out.c: Use string.h, not gdb_string.h.
* cli/cli-cmds.c: Use string.h, not gdb_string.h.
* cli/cli-decode.c: Use string.h, not gdb_string.h.
* cli/cli-dump.c: Use string.h, not gdb_string.h.
* cli/cli-interp.c: Use string.h, not gdb_string.h.
* cli/cli-logging.c: Use string.h, not gdb_string.h.
* cli/cli-script.c: Use string.h, not gdb_string.h.
* cli/cli-setshow.c: Use string.h, not gdb_string.h.
* cli/cli-utils.c: Use string.h, not gdb_string.h.
* coffread.c: Use string.h, not gdb_string.h.
* common/common-utils.c: Use string.h, not gdb_string.h.
* common/filestuff.c: Use string.h, not gdb_string.h.
* common/linux-procfs.c: Use string.h, not gdb_string.h.
* common/linux-ptrace.c: Use string.h, not gdb_string.h.
* common/signals.c: Use string.h, not gdb_string.h.
* common/vec.h: Use string.h, not gdb_string.h.
* core-regset.c: Use string.h, not gdb_string.h.
* corefile.c: Use string.h, not gdb_string.h.
* corelow.c: Use string.h, not gdb_string.h.
* cp-abi.c: Use string.h, not gdb_string.h.
* cp-support.c: Use string.h, not gdb_string.h.
* cp-valprint.c: Use string.h, not gdb_string.h.
* cris-tdep.c: Use string.h, not gdb_string.h.
* d-lang.c: Use string.h, not gdb_string.h.
* dbxread.c: Use string.h, not gdb_string.h.
* dcache.c: Use string.h, not gdb_string.h.
* demangle.c: Use string.h, not gdb_string.h.
* dicos-tdep.c: Use string.h, not gdb_string.h.
* disasm.c: Use string.h, not gdb_string.h.
* doublest.c: Use string.h, not gdb_string.h.
* dsrec.c: Use string.h, not gdb_string.h.
* dummy-frame.c: Use string.h, not gdb_string.h.
* dwarf2-frame.c: Use string.h, not gdb_string.h.
* dwarf2loc.c: Use string.h, not gdb_string.h.
* dwarf2read.c: Use string.h, not gdb_string.h.
* elfread.c: Use string.h, not gdb_string.h.
* environ.c: Use string.h, not gdb_string.h.
* eval.c: Use string.h, not gdb_string.h.
* event-loop.c: Use string.h, not gdb_string.h.
* exceptions.c: Use string.h, not gdb_string.h.
* exec.c: Use string.h, not gdb_string.h.
* expprint.c: Use string.h, not gdb_string.h.
* f-exp.y: Use string.h, not gdb_string.h.
* f-lang.c: Use string.h, not gdb_string.h.
* f-typeprint.c: Use string.h, not gdb_string.h.
* f-valprint.c: Use string.h, not gdb_string.h.
* fbsd-nat.c: Use string.h, not gdb_string.h.
* findcmd.c: Use string.h, not gdb_string.h.
* findvar.c: Use string.h, not gdb_string.h.
* fork-child.c: Use string.h, not gdb_string.h.
* frame.c: Use string.h, not gdb_string.h.
* frv-linux-tdep.c: Use string.h, not gdb_string.h.
* frv-tdep.c: Use string.h, not gdb_string.h.
* gdb.c: Use string.h, not gdb_string.h.
* gdb_bfd.c: Use string.h, not gdb_string.h.
* gdbarch.c: Use string.h, not gdb_string.h.
* gdbtypes.c: Use string.h, not gdb_string.h.
* gnu-nat.c: Use string.h, not gdb_string.h.
* gnu-v2-abi.c: Use string.h, not gdb_string.h.
* gnu-v3-abi.c: Use string.h, not gdb_string.h.
* go-exp.y: Use string.h, not gdb_string.h.
* go-lang.c: Use string.h, not gdb_string.h.
* go32-nat.c: Use string.h, not gdb_string.h.
* hppa-hpux-tdep.c: Use string.h, not gdb_string.h.
* hppa-linux-nat.c: Use string.h, not gdb_string.h.
* hppanbsd-tdep.c: Use string.h, not gdb_string.h.
* hppaobsd-tdep.c: Use string.h, not gdb_string.h.
* i386-cygwin-tdep.c: Use string.h, not gdb_string.h.
* i386-dicos-tdep.c: Use string.h, not gdb_string.h.
* i386-linux-nat.c: Use string.h, not gdb_string.h.
* i386-linux-tdep.c: Use string.h, not gdb_string.h.
* i386-nto-tdep.c: Use string.h, not gdb_string.h.
* i386-sol2-tdep.c: Use string.h, not gdb_string.h.
* i386-tdep.c: Use string.h, not gdb_string.h.
* i386bsd-tdep.c: Use string.h, not gdb_string.h.
* i386gnu-nat.c: Use string.h, not gdb_string.h.
* i386nbsd-tdep.c: Use string.h, not gdb_string.h.
* i386obsd-tdep.c: Use string.h, not gdb_string.h.
* i387-tdep.c: Use string.h, not gdb_string.h.
* ia64-libunwind-tdep.c: Use string.h, not gdb_string.h.
* ia64-linux-nat.c: Use string.h, not gdb_string.h.
* inf-child.c: Use string.h, not gdb_string.h.
* inf-ptrace.c: Use string.h, not gdb_string.h.
* inf-ttrace.c: Use string.h, not gdb_string.h.
* infcall.c: Use string.h, not gdb_string.h.
* infcmd.c: Use string.h, not gdb_string.h.
* inflow.c: Use string.h, not gdb_string.h.
* infrun.c: Use string.h, not gdb_string.h.
* interps.c: Use string.h, not gdb_string.h.
* iq2000-tdep.c: Use string.h, not gdb_string.h.
* irix5-nat.c: Use string.h, not gdb_string.h.
* jv-exp.y: Use string.h, not gdb_string.h.
* jv-lang.c: Use string.h, not gdb_string.h.
* jv-typeprint.c: Use string.h, not gdb_string.h.
* jv-valprint.c: Use string.h, not gdb_string.h.
* language.c: Use string.h, not gdb_string.h.
* linux-fork.c: Use string.h, not gdb_string.h.
* linux-nat.c: Use string.h, not gdb_string.h.
* lm32-tdep.c: Use string.h, not gdb_string.h.
* m2-exp.y: Use string.h, not gdb_string.h.
* m2-typeprint.c: Use string.h, not gdb_string.h.
* m32c-tdep.c: Use string.h, not gdb_string.h.
* m32r-linux-nat.c: Use string.h, not gdb_string.h.
* m32r-linux-tdep.c: Use string.h, not gdb_string.h.
* m32r-rom.c: Use string.h, not gdb_string.h.
* m32r-tdep.c: Use string.h, not gdb_string.h.
* m68hc11-tdep.c: Use string.h, not gdb_string.h.
* m68k-tdep.c: Use string.h, not gdb_string.h.
* m68kbsd-tdep.c: Use string.h, not gdb_string.h.
* m68klinux-nat.c: Use string.h, not gdb_string.h.
* m68klinux-tdep.c: Use string.h, not gdb_string.h.
* m88k-tdep.c: Use string.h, not gdb_string.h.
* macrocmd.c: Use string.h, not gdb_string.h.
* main.c: Use string.h, not gdb_string.h.
* mdebugread.c: Use string.h, not gdb_string.h.
* mem-break.c: Use string.h, not gdb_string.h.
* memattr.c: Use string.h, not gdb_string.h.
* memory-map.c: Use string.h, not gdb_string.h.
* mep-tdep.c: Use string.h, not gdb_string.h.
* mi/mi-cmd-break.c: Use string.h, not gdb_string.h.
* mi/mi-cmd-disas.c: Use string.h, not gdb_string.h.
* mi/mi-cmd-env.c: Use string.h, not gdb_string.h.
* mi/mi-cmd-stack.c: Use string.h, not gdb_string.h.
* mi/mi-cmd-var.c: Use string.h, not gdb_string.h.
* mi/mi-cmds.c: Use string.h, not gdb_string.h.
* mi/mi-console.c: Use string.h, not gdb_string.h.
* mi/mi-getopt.c: Use string.h, not gdb_string.h.
* mi/mi-interp.c: Use string.h, not gdb_string.h.
* mi/mi-main.c: Use string.h, not gdb_string.h.
* mi/mi-parse.c: Use string.h, not gdb_string.h.
* microblaze-rom.c: Use string.h, not gdb_string.h.
* microblaze-tdep.c: Use string.h, not gdb_string.h.
* mingw-hdep.c: Use string.h, not gdb_string.h.
* minidebug.c: Use string.h, not gdb_string.h.
* minsyms.c: Use string.h, not gdb_string.h.
* mips-irix-tdep.c: Use string.h, not gdb_string.h.
* mips-linux-tdep.c: Use string.h, not gdb_string.h.
* mips-tdep.c: Use string.h, not gdb_string.h.
* mips64obsd-tdep.c: Use string.h, not gdb_string.h.
* mipsnbsd-tdep.c: Use string.h, not gdb_string.h.
* mipsread.c: Use string.h, not gdb_string.h.
* mn10300-linux-tdep.c: Use string.h, not gdb_string.h.
* mn10300-tdep.c: Use string.h, not gdb_string.h.
* monitor.c: Use string.h, not gdb_string.h.
* moxie-tdep.c: Use string.h, not gdb_string.h.
* mt-tdep.c: Use string.h, not gdb_string.h.
* nbsd-tdep.c: Use string.h, not gdb_string.h.
* nios2-linux-tdep.c: Use string.h, not gdb_string.h.
* nto-procfs.c: Use string.h, not gdb_string.h.
* nto-tdep.c: Use string.h, not gdb_string.h.
* objc-lang.c: Use string.h, not gdb_string.h.
* objfiles.c: Use string.h, not gdb_string.h.
* opencl-lang.c: Use string.h, not gdb_string.h.
* osabi.c: Use string.h, not gdb_string.h.
* osdata.c: Use string.h, not gdb_string.h.
* p-exp.y: Use string.h, not gdb_string.h.
* p-lang.c: Use string.h, not gdb_string.h.
* p-typeprint.c: Use string.h, not gdb_string.h.
* parse.c: Use string.h, not gdb_string.h.
* posix-hdep.c: Use string.h, not gdb_string.h.
* ppc-linux-nat.c: Use string.h, not gdb_string.h.
* ppc-sysv-tdep.c: Use string.h, not gdb_string.h.
* ppcfbsd-tdep.c: Use string.h, not gdb_string.h.
* ppcnbsd-tdep.c: Use string.h, not gdb_string.h.
* ppcobsd-tdep.c: Use string.h, not gdb_string.h.
* printcmd.c: Use string.h, not gdb_string.h.
* procfs.c: Use string.h, not gdb_string.h.
* prologue-value.c: Use string.h, not gdb_string.h.
* python/py-auto-load.c: Use string.h, not gdb_string.h.
* python/py-gdb-readline.c: Use string.h, not gdb_string.h.
* ravenscar-thread.c: Use string.h, not gdb_string.h.
* regcache.c: Use string.h, not gdb_string.h.
* registry.c: Use string.h, not gdb_string.h.
* remote-fileio.c: Use string.h, not gdb_string.h.
* remote-m32r-sdi.c: Use string.h, not gdb_string.h.
* remote-mips.c: Use string.h, not gdb_string.h.
* remote-sim.c: Use string.h, not gdb_string.h.
* remote.c: Use string.h, not gdb_string.h.
* reverse.c: Use string.h, not gdb_string.h.
* rs6000-aix-tdep.c: Use string.h, not gdb_string.h.
* ser-base.c: Use string.h, not gdb_string.h.
* ser-go32.c: Use string.h, not gdb_string.h.
* ser-mingw.c: Use string.h, not gdb_string.h.
* ser-pipe.c: Use string.h, not gdb_string.h.
* ser-tcp.c: Use string.h, not gdb_string.h.
* ser-unix.c: Use string.h, not gdb_string.h.
* serial.c: Use string.h, not gdb_string.h.
* sh-tdep.c: Use string.h, not gdb_string.h.
* sh64-tdep.c: Use string.h, not gdb_string.h.
* shnbsd-tdep.c: Use string.h, not gdb_string.h.
* skip.c: Use string.h, not gdb_string.h.
* sol-thread.c: Use string.h, not gdb_string.h.
* solib-dsbt.c: Use string.h, not gdb_string.h.
* solib-frv.c: Use string.h, not gdb_string.h.
* solib-osf.c: Use string.h, not gdb_string.h.
* solib-spu.c: Use string.h, not gdb_string.h.
* solib-target.c: Use string.h, not gdb_string.h.
* solib.c: Use string.h, not gdb_string.h.
* somread.c: Use string.h, not gdb_string.h.
* source.c: Use string.h, not gdb_string.h.
* sparc-nat.c: Use string.h, not gdb_string.h.
* sparc-sol2-tdep.c: Use string.h, not gdb_string.h.
* sparc-tdep.c: Use string.h, not gdb_string.h.
* sparc64-tdep.c: Use string.h, not gdb_string.h.
* sparc64fbsd-tdep.c: Use string.h, not gdb_string.h.
* sparc64nbsd-tdep.c: Use string.h, not gdb_string.h.
* sparcnbsd-tdep.c: Use string.h, not gdb_string.h.
* spu-linux-nat.c: Use string.h, not gdb_string.h.
* spu-multiarch.c: Use string.h, not gdb_string.h.
* spu-tdep.c: Use string.h, not gdb_string.h.
* stabsread.c: Use string.h, not gdb_string.h.
* stack.c: Use string.h, not gdb_string.h.
* std-regs.c: Use string.h, not gdb_string.h.
* symfile.c: Use string.h, not gdb_string.h.
* symmisc.c: Use string.h, not gdb_string.h.
* symtab.c: Use string.h, not gdb_string.h.
* target.c: Use string.h, not gdb_string.h.
* thread.c: Use string.h, not gdb_string.h.
* tilegx-linux-nat.c: Use string.h, not gdb_string.h.
* tilegx-tdep.c: Use string.h, not gdb_string.h.
* top.c: Use string.h, not gdb_string.h.
* tracepoint.c: Use string.h, not gdb_string.h.
* tui/tui-command.c: Use string.h, not gdb_string.h.
* tui/tui-data.c: Use string.h, not gdb_string.h.
* tui/tui-disasm.c: Use string.h, not gdb_string.h.
* tui/tui-file.c: Use string.h, not gdb_string.h.
* tui/tui-layout.c: Use string.h, not gdb_string.h.
* tui/tui-out.c: Use string.h, not gdb_string.h.
* tui/tui-regs.c: Use string.h, not gdb_string.h.
* tui/tui-source.c: Use string.h, not gdb_string.h.
* tui/tui-stack.c: Use string.h, not gdb_string.h.
* tui/tui-win.c: Use string.h, not gdb_string.h.
* tui/tui-windata.c: Use string.h, not gdb_string.h.
* tui/tui-winsource.c: Use string.h, not gdb_string.h.
* typeprint.c: Use string.h, not gdb_string.h.
* ui-file.c: Use string.h, not gdb_string.h.
* ui-out.c: Use string.h, not gdb_string.h.
* user-regs.c: Use string.h, not gdb_string.h.
* utils.c: Use string.h, not gdb_string.h.
* v850-tdep.c: Use string.h, not gdb_string.h.
* valarith.c: Use string.h, not gdb_string.h.
* valops.c: Use string.h, not gdb_string.h.
* valprint.c: Use string.h, not gdb_string.h.
* value.c: Use string.h, not gdb_string.h.
* varobj.c: Use string.h, not gdb_string.h.
* vax-tdep.c: Use string.h, not gdb_string.h.
* vaxnbsd-tdep.c: Use string.h, not gdb_string.h.
* vaxobsd-tdep.c: Use string.h, not gdb_string.h.
* windows-nat.c: Use string.h, not gdb_string.h.
* xcoffread.c: Use string.h, not gdb_string.h.
* xml-support.c: Use string.h, not gdb_string.h.
* xstormy16-tdep.c: Use string.h, not gdb_string.h.
* xtensa-linux-nat.c: Use string.h, not gdb_string.h.
2013-11-06 14:14:23 +00:00
|
|
|
#include <string.h>
|
2012-05-30 19:31:44 +00:00
|
|
|
#include "gdb_assert.h"
|
|
|
|
|
#include "arch-utils.h"
|
|
|
|
|
#include "floatformat.h"
|
|
|
|
|
#include "regcache.h"
|
|
|
|
|
#include "regset.h"
|
|
|
|
|
#include "doublest.h"
|
|
|
|
|
#include "osabi.h"
|
|
|
|
|
#include "linux-tdep.h"
|
|
|
|
|
#include "objfiles.h"
|
|
|
|
|
#include "solib-svr4.h"
|
|
|
|
|
#include "tilegx-tdep.h"
|
|
|
|
|
#include "opcode/tilegx.h"
|
|
|
|
|
|
|
|
|
|
struct tilegx_frame_cache
|
|
|
|
|
{
|
|
|
|
|
/* Base address. */
|
|
|
|
|
CORE_ADDR base;
|
|
|
|
|
/* Function start. */
|
|
|
|
|
CORE_ADDR start_pc;
|
|
|
|
|
|
|
|
|
|
/* Table of saved registers. */
|
|
|
|
|
struct trad_frame_saved_reg *saved_regs;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* Register state values used by analyze_prologue. */
|
|
|
|
|
enum reverse_state
|
|
|
|
|
{
|
|
|
|
|
REVERSE_STATE_REGISTER,
|
|
|
|
|
REVERSE_STATE_VALUE,
|
|
|
|
|
REVERSE_STATE_UNKNOWN
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* Register state used by analyze_prologue(). */
|
|
|
|
|
struct tilegx_reverse_regs
|
|
|
|
|
{
|
|
|
|
|
LONGEST value;
|
|
|
|
|
enum reverse_state state;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static const struct tilegx_reverse_regs
|
|
|
|
|
template_reverse_regs[TILEGX_NUM_PHYS_REGS] =
|
|
|
|
|
{
|
|
|
|
|
{ TILEGX_R0_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R1_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R2_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R3_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R4_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R5_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R6_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R7_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R8_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R9_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R10_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R11_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R12_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R13_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R14_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R15_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R16_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R17_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R18_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R19_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R20_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R21_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R22_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R23_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R24_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R25_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R26_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R27_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R28_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R29_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R30_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R31_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R32_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R33_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R34_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R35_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R36_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R37_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R38_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R39_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R40_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R41_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R42_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R43_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R44_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R45_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R46_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R47_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R48_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R49_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R50_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R51_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_R52_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_TP_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_SP_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ TILEGX_LR_REGNUM, REVERSE_STATE_REGISTER },
|
|
|
|
|
{ 0, REVERSE_STATE_UNKNOWN },
|
|
|
|
|
{ 0, REVERSE_STATE_UNKNOWN },
|
|
|
|
|
{ 0, REVERSE_STATE_UNKNOWN },
|
|
|
|
|
{ 0, REVERSE_STATE_UNKNOWN },
|
|
|
|
|
{ 0, REVERSE_STATE_UNKNOWN },
|
|
|
|
|
{ 0, REVERSE_STATE_UNKNOWN },
|
|
|
|
|
{ 0, REVERSE_STATE_UNKNOWN },
|
|
|
|
|
{ TILEGX_ZERO_REGNUM, REVERSE_STATE_VALUE }
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* Implement the "register_name" gdbarch method. */
|
|
|
|
|
|
|
|
|
|
static const char *
|
|
|
|
|
tilegx_register_name (struct gdbarch *gdbarch, int regnum)
|
|
|
|
|
{
|
|
|
|
|
static const char *const register_names[TILEGX_NUM_REGS] =
|
|
|
|
|
{
|
|
|
|
|
"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
|
|
|
|
|
"r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
|
|
|
|
|
"r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
|
|
|
|
|
"r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
|
|
|
|
|
"r32", "r33", "r34", "r35", "r36", "r37", "r38", "r39",
|
|
|
|
|
"r40", "r41", "r42", "r43", "r44", "r45", "r46", "r47",
|
|
|
|
|
"r48", "r49", "r50", "r51", "r52", "tp", "sp", "lr",
|
|
|
|
|
"sn", "idn0", "idn1", "udn0", "udn1", "udn2", "udn3", "zero",
|
2013-02-19 16:19:33 +00:00
|
|
|
"pc", "faultnum",
|
2012-05-30 19:31:44 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
if (regnum < 0 || regnum >= TILEGX_NUM_REGS)
|
|
|
|
|
internal_error (__FILE__, __LINE__,
|
|
|
|
|
"tilegx_register_name: invalid register number %d",
|
|
|
|
|
regnum);
|
|
|
|
|
|
|
|
|
|
return register_names[regnum];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* This is the implementation of gdbarch method register_type. */
|
|
|
|
|
|
|
|
|
|
static struct type *
|
|
|
|
|
tilegx_register_type (struct gdbarch *gdbarch, int regnum)
|
|
|
|
|
{
|
|
|
|
|
if (regnum == TILEGX_PC_REGNUM)
|
|
|
|
|
return builtin_type (gdbarch)->builtin_func_ptr;
|
|
|
|
|
else
|
|
|
|
|
return builtin_type (gdbarch)->builtin_uint64;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* This is the implementation of gdbarch method dwarf2_reg_to_regnum. */
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
tilegx_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, int num)
|
|
|
|
|
{
|
|
|
|
|
return num;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Makes the decision of whether a given type is a scalar type.
|
|
|
|
|
Scalar types are returned in the registers r2-r11 as they fit. */
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
tilegx_type_is_scalar (struct type *t)
|
|
|
|
|
{
|
|
|
|
|
return (TYPE_CODE(t) != TYPE_CODE_STRUCT
|
|
|
|
|
&& TYPE_CODE(t) != TYPE_CODE_UNION
|
|
|
|
|
&& TYPE_CODE(t) != TYPE_CODE_ARRAY);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Returns non-zero if the given struct type will be returned using
|
|
|
|
|
a special convention, rather than the normal function return method.
|
|
|
|
|
Used in the context of the "return" command, and target function
|
|
|
|
|
calls from the debugger. */
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
tilegx_use_struct_convention (struct type *type)
|
|
|
|
|
{
|
|
|
|
|
/* Only scalars which fit in R0 - R9 can be returned in registers.
|
|
|
|
|
Otherwise, they are returned via a pointer passed in R0. */
|
|
|
|
|
return (!tilegx_type_is_scalar (type)
|
|
|
|
|
&& (TYPE_LENGTH (type) > (1 + TILEGX_R9_REGNUM - TILEGX_R0_REGNUM)
|
|
|
|
|
* tilegx_reg_size));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Find a function's return value in the appropriate registers (in
|
|
|
|
|
REGCACHE), and copy it into VALBUF. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
tilegx_extract_return_value (struct type *type, struct regcache *regcache,
|
|
|
|
|
gdb_byte *valbuf)
|
|
|
|
|
{
|
|
|
|
|
int len = TYPE_LENGTH (type);
|
|
|
|
|
int i, regnum = TILEGX_R0_REGNUM;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < len; i += tilegx_reg_size)
|
|
|
|
|
regcache_raw_read (regcache, regnum++, valbuf + i);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Copy the function return value from VALBUF into the proper
|
|
|
|
|
location for a function return.
|
|
|
|
|
Called only in the context of the "return" command. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
tilegx_store_return_value (struct type *type, struct regcache *regcache,
|
|
|
|
|
const void *valbuf)
|
|
|
|
|
{
|
|
|
|
|
if (TYPE_LENGTH (type) < tilegx_reg_size)
|
|
|
|
|
{
|
|
|
|
|
/* Add leading zeros to the (little-endian) value. */
|
|
|
|
|
gdb_byte buf[tilegx_reg_size] = { 0 };
|
|
|
|
|
|
|
|
|
|
memcpy (buf, valbuf, TYPE_LENGTH (type));
|
|
|
|
|
regcache_raw_write (regcache, TILEGX_R0_REGNUM, buf);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
int len = TYPE_LENGTH (type);
|
|
|
|
|
int i, regnum = TILEGX_R0_REGNUM;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < len; i += tilegx_reg_size)
|
|
|
|
|
regcache_raw_write (regcache, regnum++, (gdb_byte *) valbuf + i);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* This is the implementation of gdbarch method return_value. */
|
|
|
|
|
|
|
|
|
|
static enum return_value_convention
|
|
|
|
|
tilegx_return_value (struct gdbarch *gdbarch, struct value *function,
|
|
|
|
|
struct type *type, struct regcache *regcache,
|
|
|
|
|
gdb_byte *readbuf, const gdb_byte *writebuf)
|
|
|
|
|
{
|
|
|
|
|
if (tilegx_use_struct_convention (type))
|
|
|
|
|
return RETURN_VALUE_STRUCT_CONVENTION;
|
|
|
|
|
if (writebuf)
|
|
|
|
|
tilegx_store_return_value (type, regcache, writebuf);
|
|
|
|
|
else if (readbuf)
|
|
|
|
|
tilegx_extract_return_value (type, regcache, readbuf);
|
|
|
|
|
return RETURN_VALUE_REGISTER_CONVENTION;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* This is the implementation of gdbarch method frame_align. */
|
|
|
|
|
|
|
|
|
|
static CORE_ADDR
|
|
|
|
|
tilegx_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
|
|
|
|
|
{
|
|
|
|
|
return addr & -8;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Implement the "push_dummy_call" gdbarch method. */
|
|
|
|
|
|
|
|
|
|
static CORE_ADDR
|
|
|
|
|
tilegx_push_dummy_call (struct gdbarch *gdbarch,
|
|
|
|
|
struct value *function,
|
|
|
|
|
struct regcache *regcache,
|
|
|
|
|
CORE_ADDR bp_addr, int nargs,
|
|
|
|
|
struct value **args,
|
|
|
|
|
CORE_ADDR sp, int struct_return,
|
|
|
|
|
CORE_ADDR struct_addr)
|
|
|
|
|
{
|
|
|
|
|
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
|
|
|
|
|
CORE_ADDR stack_dest = sp;
|
|
|
|
|
int argreg = TILEGX_R0_REGNUM;
|
|
|
|
|
int i, j;
|
|
|
|
|
int typelen, slacklen, alignlen;
|
2013-02-19 16:09:13 +00:00
|
|
|
static const gdb_byte four_zero_words[16] = { 0 };
|
2012-05-30 19:31:44 +00:00
|
|
|
|
|
|
|
|
/* If struct_return is 1, then the struct return address will
|
|
|
|
|
consume one argument-passing register. */
|
|
|
|
|
if (struct_return)
|
|
|
|
|
regcache_cooked_write_unsigned (regcache, argreg++, struct_addr);
|
|
|
|
|
|
|
|
|
|
/* Arguments are passed in R0 - R9, and as soon as an argument
|
|
|
|
|
will not fit completely in the remaining registers, then it,
|
|
|
|
|
and all remaining arguments, are put on the stack. */
|
|
|
|
|
for (i = 0; i < nargs && argreg <= TILEGX_R9_REGNUM; i++)
|
|
|
|
|
{
|
|
|
|
|
const gdb_byte *val;
|
|
|
|
|
typelen = TYPE_LENGTH (value_enclosing_type (args[i]));
|
|
|
|
|
|
|
|
|
|
if (typelen > (TILEGX_R9_REGNUM - argreg + 1) * tilegx_reg_size)
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
/* Put argument into registers wordwise. */
|
|
|
|
|
val = value_contents (args[i]);
|
|
|
|
|
for (j = 0; j < typelen; j += tilegx_reg_size)
|
|
|
|
|
{
|
|
|
|
|
/* ISSUE: Why special handling for "typelen = 4x + 1"?
|
|
|
|
|
I don't ever see "typelen" values except 4 and 8. */
|
|
|
|
|
int n = (typelen - j == 1) ? 1 : tilegx_reg_size;
|
|
|
|
|
ULONGEST w = extract_unsigned_integer (val + j, n, byte_order);
|
|
|
|
|
|
|
|
|
|
regcache_cooked_write_unsigned (regcache, argreg++, w);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Align SP. */
|
|
|
|
|
stack_dest = tilegx_frame_align (gdbarch, stack_dest);
|
|
|
|
|
|
|
|
|
|
/* Loop backwards through remaining arguments and push them on
|
|
|
|
|
the stack, word aligned. */
|
|
|
|
|
for (j = nargs - 1; j >= i; j--)
|
|
|
|
|
{
|
|
|
|
|
gdb_byte *val;
|
2012-08-24 03:57:22 +00:00
|
|
|
struct cleanup *back_to;
|
|
|
|
|
const gdb_byte *contents = value_contents (args[j]);
|
2012-05-30 19:31:44 +00:00
|
|
|
|
|
|
|
|
typelen = TYPE_LENGTH (value_enclosing_type (args[j]));
|
2013-02-19 16:09:13 +00:00
|
|
|
slacklen = align_up (typelen, 8) - typelen;
|
2012-08-24 03:57:22 +00:00
|
|
|
val = xmalloc (typelen + slacklen);
|
|
|
|
|
back_to = make_cleanup (xfree, val);
|
|
|
|
|
memcpy (val, contents, typelen);
|
2012-05-30 19:31:44 +00:00
|
|
|
memset (val + typelen, 0, slacklen);
|
|
|
|
|
|
|
|
|
|
/* Now write data to the stack. The stack grows downwards. */
|
|
|
|
|
stack_dest -= typelen + slacklen;
|
|
|
|
|
write_memory (stack_dest, val, typelen + slacklen);
|
2012-08-24 03:57:22 +00:00
|
|
|
do_cleanups (back_to);
|
2012-05-30 19:31:44 +00:00
|
|
|
}
|
|
|
|
|
|
2013-02-19 16:09:13 +00:00
|
|
|
/* Add 16 bytes for linkage space to the stack. */
|
|
|
|
|
stack_dest = stack_dest - 16;
|
|
|
|
|
write_memory (stack_dest, four_zero_words, 16);
|
2012-05-30 19:31:44 +00:00
|
|
|
|
|
|
|
|
/* Update stack pointer. */
|
|
|
|
|
regcache_cooked_write_unsigned (regcache, TILEGX_SP_REGNUM, stack_dest);
|
|
|
|
|
|
|
|
|
|
/* Set the return address register to point to the entry point of
|
|
|
|
|
the program, where a breakpoint lies in wait. */
|
|
|
|
|
regcache_cooked_write_unsigned (regcache, TILEGX_LR_REGNUM, bp_addr);
|
|
|
|
|
|
|
|
|
|
return stack_dest;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Decode the instructions within the given address range.
|
|
|
|
|
Decide when we must have reached the end of the function prologue.
|
|
|
|
|
If a frame_info pointer is provided, fill in its saved_regs etc.
|
|
|
|
|
Returns the address of the first instruction after the prologue.
|
|
|
|
|
NOTE: This is often called with start_addr being the start of some
|
|
|
|
|
function, and end_addr being the current PC. */
|
|
|
|
|
|
|
|
|
|
static CORE_ADDR
|
|
|
|
|
tilegx_analyze_prologue (struct gdbarch* gdbarch,
|
|
|
|
|
CORE_ADDR start_addr, CORE_ADDR end_addr,
|
|
|
|
|
struct tilegx_frame_cache *cache,
|
|
|
|
|
struct frame_info *next_frame)
|
|
|
|
|
{
|
|
|
|
|
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
|
|
|
|
|
CORE_ADDR next_addr;
|
|
|
|
|
CORE_ADDR prolog_end = end_addr;
|
|
|
|
|
ULONGEST inst, inst2;
|
|
|
|
|
LONGEST offset;
|
|
|
|
|
int regnum;
|
|
|
|
|
gdb_byte instbuf[32 * TILEGX_BUNDLE_SIZE_IN_BYTES];
|
|
|
|
|
CORE_ADDR instbuf_start;
|
|
|
|
|
unsigned int instbuf_size;
|
|
|
|
|
int status;
|
|
|
|
|
bfd_uint64_t bundle;
|
|
|
|
|
struct tilegx_decoded_instruction
|
|
|
|
|
decoded[TILEGX_MAX_INSTRUCTIONS_PER_BUNDLE];
|
|
|
|
|
int num_insns;
|
|
|
|
|
struct tilegx_reverse_regs reverse_frame[TILEGX_NUM_PHYS_REGS];
|
|
|
|
|
struct tilegx_reverse_regs
|
|
|
|
|
new_reverse_frame[TILEGX_MAX_INSTRUCTIONS_PER_BUNDLE];
|
|
|
|
|
int dest_regs[TILEGX_MAX_INSTRUCTIONS_PER_BUNDLE];
|
2013-02-19 16:22:42 +00:00
|
|
|
int reverse_frame_valid, prolog_done, branch_seen, lr_saved_on_stack_p;
|
2012-05-30 19:31:44 +00:00
|
|
|
LONGEST prev_sp_value;
|
|
|
|
|
int i, j;
|
|
|
|
|
|
|
|
|
|
if (start_addr >= end_addr
|
|
|
|
|
|| (start_addr % TILEGX_BUNDLE_ALIGNMENT_IN_BYTES) != 0)
|
|
|
|
|
return end_addr;
|
|
|
|
|
|
|
|
|
|
/* Initialize the reverse frame. This maps the CURRENT frame's
|
|
|
|
|
registers to the outer frame's registers (the frame on the
|
|
|
|
|
stack goes the other way). */
|
|
|
|
|
memcpy (&reverse_frame, &template_reverse_regs, sizeof (reverse_frame));
|
|
|
|
|
|
|
|
|
|
prolog_done = 0;
|
|
|
|
|
branch_seen = 0;
|
|
|
|
|
prev_sp_value = 0;
|
2013-02-19 16:22:42 +00:00
|
|
|
lr_saved_on_stack_p = 0;
|
2012-05-30 19:31:44 +00:00
|
|
|
|
|
|
|
|
/* To cut down on round-trip overhead, we fetch multiple bundles
|
|
|
|
|
at once. These variables describe the range of memory we have
|
|
|
|
|
prefetched. */
|
|
|
|
|
instbuf_start = 0;
|
|
|
|
|
instbuf_size = 0;
|
|
|
|
|
|
|
|
|
|
for (next_addr = start_addr;
|
|
|
|
|
next_addr < end_addr;
|
|
|
|
|
next_addr += TILEGX_BUNDLE_SIZE_IN_BYTES)
|
|
|
|
|
{
|
|
|
|
|
/* Retrieve the next instruction. */
|
|
|
|
|
if (next_addr - instbuf_start >= instbuf_size)
|
|
|
|
|
{
|
|
|
|
|
/* Figure out how many bytes to fetch. Don't span a page
|
|
|
|
|
boundary since that might cause an unnecessary memory
|
|
|
|
|
error. */
|
|
|
|
|
unsigned int size_on_same_page = 4096 - (next_addr & 4095);
|
|
|
|
|
|
|
|
|
|
instbuf_size = sizeof instbuf;
|
|
|
|
|
|
|
|
|
|
if (instbuf_size > size_on_same_page)
|
|
|
|
|
instbuf_size = size_on_same_page;
|
2013-03-02 01:34:40 +00:00
|
|
|
|
|
|
|
|
instbuf_size = min (instbuf_size, (end_addr - next_addr));
|
2012-05-30 19:31:44 +00:00
|
|
|
instbuf_start = next_addr;
|
|
|
|
|
|
|
|
|
|
status = safe_frame_unwind_memory (next_frame, instbuf_start,
|
|
|
|
|
instbuf, instbuf_size);
|
|
|
|
|
if (status == 0)
|
|
|
|
|
memory_error (status, next_addr);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
reverse_frame_valid = 0;
|
|
|
|
|
|
|
|
|
|
bundle = extract_unsigned_integer (&instbuf[next_addr - instbuf_start],
|
|
|
|
|
8, byte_order);
|
|
|
|
|
|
|
|
|
|
num_insns = parse_insn_tilegx (bundle, next_addr, decoded);
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < num_insns; i++)
|
|
|
|
|
{
|
|
|
|
|
struct tilegx_decoded_instruction *this_insn = &decoded[i];
|
|
|
|
|
int64_t *operands = (int64_t *) this_insn->operand_values;
|
|
|
|
|
const struct tilegx_opcode *opcode = this_insn->opcode;
|
|
|
|
|
|
|
|
|
|
switch (opcode->mnemonic)
|
|
|
|
|
{
|
|
|
|
|
case TILEGX_OPC_ST:
|
|
|
|
|
if (cache
|
|
|
|
|
&& reverse_frame[operands[0]].state == REVERSE_STATE_VALUE
|
|
|
|
|
&& reverse_frame[operands[1]].state
|
|
|
|
|
== REVERSE_STATE_REGISTER)
|
|
|
|
|
{
|
|
|
|
|
LONGEST saved_address = reverse_frame[operands[0]].value;
|
|
|
|
|
unsigned saved_register
|
|
|
|
|
= (unsigned) reverse_frame[operands[1]].value;
|
|
|
|
|
|
|
|
|
|
/* realreg >= 0 and addr != -1 indicates that the
|
|
|
|
|
value of saved_register is in memory location
|
|
|
|
|
saved_address. The value of realreg is not
|
|
|
|
|
meaningful in this case but it must be >= 0.
|
|
|
|
|
See trad-frame.h. */
|
|
|
|
|
cache->saved_regs[saved_register].realreg = saved_register;
|
|
|
|
|
cache->saved_regs[saved_register].addr = saved_address;
|
2013-02-19 16:22:42 +00:00
|
|
|
}
|
|
|
|
|
else if (cache
|
|
|
|
|
&& (operands[0] == TILEGX_SP_REGNUM)
|
|
|
|
|
&& (operands[1] == TILEGX_LR_REGNUM))
|
|
|
|
|
lr_saved_on_stack_p = 1;
|
2012-05-30 19:31:44 +00:00
|
|
|
break;
|
|
|
|
|
case TILEGX_OPC_ADDI:
|
|
|
|
|
case TILEGX_OPC_ADDLI:
|
|
|
|
|
if (cache
|
|
|
|
|
&& operands[0] == TILEGX_SP_REGNUM
|
|
|
|
|
&& operands[1] == TILEGX_SP_REGNUM
|
|
|
|
|
&& reverse_frame[operands[1]].state == REVERSE_STATE_REGISTER)
|
|
|
|
|
{
|
|
|
|
|
/* Special case. We're fixing up the stack frame. */
|
|
|
|
|
uint64_t hopefully_sp
|
|
|
|
|
= (unsigned) reverse_frame[operands[1]].value;
|
|
|
|
|
short op2_as_short = (short) operands[2];
|
|
|
|
|
signed char op2_as_char = (signed char) operands[2];
|
|
|
|
|
|
|
|
|
|
/* Fix up the sign-extension. */
|
|
|
|
|
if (opcode->mnemonic == TILEGX_OPC_ADDI)
|
|
|
|
|
op2_as_short = op2_as_char;
|
|
|
|
|
prev_sp_value = (cache->saved_regs[hopefully_sp].addr
|
|
|
|
|
- op2_as_short);
|
|
|
|
|
|
|
|
|
|
new_reverse_frame[i].state = REVERSE_STATE_VALUE;
|
|
|
|
|
new_reverse_frame[i].value
|
|
|
|
|
= cache->saved_regs[hopefully_sp].addr;
|
|
|
|
|
trad_frame_set_value (cache->saved_regs,
|
|
|
|
|
hopefully_sp, prev_sp_value);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
short op2_as_short = (short) operands[2];
|
|
|
|
|
signed char op2_as_char = (signed char) operands[2];
|
|
|
|
|
|
|
|
|
|
/* Fix up the sign-extension. */
|
|
|
|
|
if (opcode->mnemonic == TILEGX_OPC_ADDI)
|
|
|
|
|
op2_as_short = op2_as_char;
|
|
|
|
|
|
|
|
|
|
new_reverse_frame[i] = reverse_frame[operands[1]];
|
|
|
|
|
if (new_reverse_frame[i].state == REVERSE_STATE_VALUE)
|
|
|
|
|
new_reverse_frame[i].value += op2_as_short;
|
|
|
|
|
else
|
|
|
|
|
new_reverse_frame[i].state = REVERSE_STATE_UNKNOWN;
|
|
|
|
|
}
|
|
|
|
|
reverse_frame_valid |= 1 << i;
|
|
|
|
|
dest_regs[i] = operands[0];
|
|
|
|
|
break;
|
|
|
|
|
case TILEGX_OPC_ADD:
|
|
|
|
|
if (reverse_frame[operands[1]].state == REVERSE_STATE_VALUE
|
|
|
|
|
&& reverse_frame[operands[2]].state == REVERSE_STATE_VALUE)
|
|
|
|
|
{
|
|
|
|
|
/* We have values -- we can do this. */
|
|
|
|
|
new_reverse_frame[i] = reverse_frame[operands[2]];
|
|
|
|
|
new_reverse_frame[i].value
|
|
|
|
|
+= reverse_frame[operands[i]].value;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* We don't know anything about the values. Punt. */
|
|
|
|
|
new_reverse_frame[i].state = REVERSE_STATE_UNKNOWN;
|
|
|
|
|
}
|
|
|
|
|
reverse_frame_valid |= 1 << i;
|
|
|
|
|
dest_regs[i] = operands[0];
|
|
|
|
|
break;
|
|
|
|
|
case TILEGX_OPC_MOVE:
|
|
|
|
|
new_reverse_frame[i] = reverse_frame[operands[1]];
|
|
|
|
|
reverse_frame_valid |= 1 << i;
|
|
|
|
|
dest_regs[i] = operands[0];
|
|
|
|
|
break;
|
|
|
|
|
case TILEGX_OPC_MOVEI:
|
|
|
|
|
case TILEGX_OPC_MOVELI:
|
|
|
|
|
new_reverse_frame[i].state = REVERSE_STATE_VALUE;
|
|
|
|
|
new_reverse_frame[i].value = operands[1];
|
|
|
|
|
reverse_frame_valid |= 1 << i;
|
|
|
|
|
dest_regs[i] = operands[0];
|
|
|
|
|
break;
|
|
|
|
|
case TILEGX_OPC_ORI:
|
|
|
|
|
if (reverse_frame[operands[1]].state == REVERSE_STATE_VALUE)
|
|
|
|
|
{
|
|
|
|
|
/* We have a value in A -- we can do this. */
|
|
|
|
|
new_reverse_frame[i] = reverse_frame[operands[1]];
|
|
|
|
|
new_reverse_frame[i].value
|
|
|
|
|
= reverse_frame[operands[1]].value | operands[2];
|
|
|
|
|
}
|
|
|
|
|
else if (operands[2] == 0)
|
|
|
|
|
{
|
|
|
|
|
/* This is a move. */
|
|
|
|
|
new_reverse_frame[i] = reverse_frame[operands[1]];
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* We don't know anything about the values. Punt. */
|
|
|
|
|
new_reverse_frame[i].state = REVERSE_STATE_UNKNOWN;
|
|
|
|
|
}
|
|
|
|
|
reverse_frame_valid |= 1 << i;
|
|
|
|
|
dest_regs[i] = operands[0];
|
|
|
|
|
break;
|
|
|
|
|
case TILEGX_OPC_OR:
|
|
|
|
|
if (reverse_frame[operands[1]].state == REVERSE_STATE_VALUE
|
|
|
|
|
&& reverse_frame[operands[1]].value == 0)
|
|
|
|
|
{
|
|
|
|
|
/* This is a move. */
|
|
|
|
|
new_reverse_frame[i] = reverse_frame[operands[2]];
|
|
|
|
|
}
|
|
|
|
|
else if (reverse_frame[operands[2]].state == REVERSE_STATE_VALUE
|
|
|
|
|
&& reverse_frame[operands[2]].value == 0)
|
|
|
|
|
{
|
|
|
|
|
/* This is a move. */
|
|
|
|
|
new_reverse_frame[i] = reverse_frame[operands[1]];
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* We don't know anything about the values. Punt. */
|
|
|
|
|
new_reverse_frame[i].state = REVERSE_STATE_UNKNOWN;
|
|
|
|
|
}
|
|
|
|
|
reverse_frame_valid |= 1 << i;
|
|
|
|
|
dest_regs[i] = operands[0];
|
|
|
|
|
break;
|
|
|
|
|
case TILEGX_OPC_SUB:
|
|
|
|
|
if (reverse_frame[operands[1]].state == REVERSE_STATE_VALUE
|
|
|
|
|
&& reverse_frame[operands[2]].state == REVERSE_STATE_VALUE)
|
|
|
|
|
{
|
|
|
|
|
/* We have values -- we can do this. */
|
|
|
|
|
new_reverse_frame[i] = reverse_frame[operands[1]];
|
|
|
|
|
new_reverse_frame[i].value
|
|
|
|
|
-= reverse_frame[operands[2]].value;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* We don't know anything about the values. Punt. */
|
|
|
|
|
new_reverse_frame[i].state = REVERSE_STATE_UNKNOWN;
|
|
|
|
|
}
|
|
|
|
|
reverse_frame_valid |= 1 << i;
|
|
|
|
|
dest_regs[i] = operands[0];
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case TILEGX_OPC_FNOP:
|
|
|
|
|
case TILEGX_OPC_INFO:
|
|
|
|
|
case TILEGX_OPC_INFOL:
|
|
|
|
|
/* Nothing to see here, move on.
|
|
|
|
|
Note that real NOP is treated as a 'real' instruction
|
|
|
|
|
because someone must have intended that it be there.
|
|
|
|
|
It therefore terminates the prolog. */
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case TILEGX_OPC_J:
|
|
|
|
|
case TILEGX_OPC_JAL:
|
|
|
|
|
|
|
|
|
|
case TILEGX_OPC_BEQZ:
|
|
|
|
|
case TILEGX_OPC_BEQZT:
|
|
|
|
|
case TILEGX_OPC_BGEZ:
|
|
|
|
|
case TILEGX_OPC_BGEZT:
|
|
|
|
|
case TILEGX_OPC_BGTZ:
|
|
|
|
|
case TILEGX_OPC_BGTZT:
|
|
|
|
|
case TILEGX_OPC_BLBC:
|
|
|
|
|
case TILEGX_OPC_BLBCT:
|
|
|
|
|
case TILEGX_OPC_BLBS:
|
|
|
|
|
case TILEGX_OPC_BLBST:
|
|
|
|
|
case TILEGX_OPC_BLEZ:
|
|
|
|
|
case TILEGX_OPC_BLEZT:
|
|
|
|
|
case TILEGX_OPC_BLTZ:
|
|
|
|
|
case TILEGX_OPC_BLTZT:
|
|
|
|
|
case TILEGX_OPC_BNEZ:
|
|
|
|
|
case TILEGX_OPC_BNEZT:
|
|
|
|
|
|
|
|
|
|
case TILEGX_OPC_IRET:
|
|
|
|
|
case TILEGX_OPC_JALR:
|
|
|
|
|
case TILEGX_OPC_JALRP:
|
|
|
|
|
case TILEGX_OPC_JR:
|
|
|
|
|
case TILEGX_OPC_JRP:
|
|
|
|
|
case TILEGX_OPC_SWINT0:
|
|
|
|
|
case TILEGX_OPC_SWINT1:
|
|
|
|
|
case TILEGX_OPC_SWINT2:
|
|
|
|
|
case TILEGX_OPC_SWINT3:
|
|
|
|
|
/* We're really done -- this is a branch. */
|
|
|
|
|
branch_seen = 1;
|
|
|
|
|
prolog_done = 1;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
/* We don't know or care what this instruction is.
|
|
|
|
|
All we know is that it isn't part of a prolog, and if
|
|
|
|
|
there's a destination register, we're trashing it. */
|
|
|
|
|
prolog_done = 1;
|
|
|
|
|
for (j = 0; j < opcode->num_operands; j++)
|
|
|
|
|
{
|
|
|
|
|
if (this_insn->operands[j]->is_dest_reg)
|
|
|
|
|
{
|
|
|
|
|
dest_regs[i] = operands[j];
|
|
|
|
|
new_reverse_frame[i].state = REVERSE_STATE_UNKNOWN;
|
|
|
|
|
reverse_frame_valid |= 1 << i;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Now update the reverse frames. */
|
|
|
|
|
for (i = 0; i < num_insns; i++)
|
|
|
|
|
{
|
|
|
|
|
/* ISSUE: Does this properly handle "network" registers? */
|
|
|
|
|
if ((reverse_frame_valid & (1 << i))
|
|
|
|
|
&& dest_regs[i] != TILEGX_ZERO_REGNUM)
|
|
|
|
|
reverse_frame[dest_regs[i]] = new_reverse_frame[i];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (prev_sp_value != 0)
|
|
|
|
|
{
|
|
|
|
|
/* GCC uses R52 as a frame pointer. Have we seen "move r52, sp"? */
|
|
|
|
|
if (reverse_frame[TILEGX_R52_REGNUM].state == REVERSE_STATE_REGISTER
|
|
|
|
|
&& reverse_frame[TILEGX_R52_REGNUM].value == TILEGX_SP_REGNUM)
|
|
|
|
|
{
|
|
|
|
|
reverse_frame[TILEGX_R52_REGNUM].state = REVERSE_STATE_VALUE;
|
|
|
|
|
reverse_frame[TILEGX_R52_REGNUM].value = prev_sp_value;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
prev_sp_value = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (prolog_done && prolog_end == end_addr)
|
|
|
|
|
{
|
|
|
|
|
/* We found non-prolog code. As such, _this_ instruction
|
|
|
|
|
is the one after the prolog. We keep processing, because
|
|
|
|
|
there may be more prolog code in there, but this is what
|
|
|
|
|
we'll return. */
|
|
|
|
|
/* ISSUE: There may not have actually been a prologue, and
|
|
|
|
|
we may have simply skipped some random instructions. */
|
|
|
|
|
prolog_end = next_addr;
|
|
|
|
|
}
|
|
|
|
|
if (branch_seen)
|
|
|
|
|
{
|
|
|
|
|
/* We saw a branch. The prolog absolutely must be over. */
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (prolog_end == end_addr && cache)
|
|
|
|
|
{
|
|
|
|
|
/* We may have terminated the prolog early, and we're certainly
|
|
|
|
|
at THIS point right now. It's possible that the values of
|
|
|
|
|
registers we need are currently actually in other registers
|
|
|
|
|
(and haven't been written to memory yet). Go find them. */
|
|
|
|
|
for (i = 0; i < TILEGX_NUM_PHYS_REGS; i++)
|
|
|
|
|
{
|
|
|
|
|
if (reverse_frame[i].state == REVERSE_STATE_REGISTER
|
|
|
|
|
&& reverse_frame[i].value != i)
|
|
|
|
|
{
|
|
|
|
|
unsigned saved_register = (unsigned) reverse_frame[i].value;
|
|
|
|
|
|
|
|
|
|
cache->saved_regs[saved_register].realreg = i;
|
|
|
|
|
cache->saved_regs[saved_register].addr = (LONGEST) -1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2013-02-19 16:22:42 +00:00
|
|
|
if (lr_saved_on_stack_p)
|
|
|
|
|
{
|
|
|
|
|
cache->saved_regs[TILEGX_LR_REGNUM].realreg = TILEGX_LR_REGNUM;
|
|
|
|
|
cache->saved_regs[TILEGX_LR_REGNUM].addr =
|
|
|
|
|
cache->saved_regs[TILEGX_SP_REGNUM].addr;
|
|
|
|
|
}
|
|
|
|
|
|
2012-05-30 19:31:44 +00:00
|
|
|
return prolog_end;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* This is the implementation of gdbarch method skip_prologue. */
|
|
|
|
|
|
|
|
|
|
static CORE_ADDR
|
2013-02-19 16:20:47 +00:00
|
|
|
tilegx_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR start_pc)
|
2012-05-30 19:31:44 +00:00
|
|
|
{
|
2013-03-02 01:34:40 +00:00
|
|
|
CORE_ADDR func_start, end_pc;
|
|
|
|
|
struct obj_section *s;
|
2012-05-30 19:31:44 +00:00
|
|
|
|
|
|
|
|
/* This is the preferred method, find the end of the prologue by
|
|
|
|
|
using the debugging information. */
|
2013-02-19 16:20:47 +00:00
|
|
|
if (find_pc_partial_function (start_pc, NULL, &func_start, NULL))
|
2012-05-30 19:31:44 +00:00
|
|
|
{
|
2013-02-19 16:20:47 +00:00
|
|
|
CORE_ADDR post_prologue_pc
|
|
|
|
|
= skip_prologue_using_sal (gdbarch, func_start);
|
2012-05-30 19:31:44 +00:00
|
|
|
|
2013-02-19 16:20:47 +00:00
|
|
|
if (post_prologue_pc != 0)
|
|
|
|
|
return max (start_pc, post_prologue_pc);
|
2012-05-30 19:31:44 +00:00
|
|
|
}
|
|
|
|
|
|
2013-03-02 01:34:40 +00:00
|
|
|
/* Don't straddle a section boundary. */
|
|
|
|
|
s = find_pc_section (start_pc);
|
|
|
|
|
end_pc = start_pc + 8 * TILEGX_BUNDLE_SIZE_IN_BYTES;
|
|
|
|
|
if (s != NULL)
|
|
|
|
|
end_pc = min (end_pc, obj_section_endaddr (s));
|
|
|
|
|
|
2012-05-30 19:31:44 +00:00
|
|
|
/* Otherwise, try to skip prologue the hard way. */
|
|
|
|
|
return tilegx_analyze_prologue (gdbarch,
|
2013-02-19 16:20:47 +00:00
|
|
|
start_pc,
|
2013-03-02 01:34:40 +00:00
|
|
|
end_pc,
|
2012-05-30 19:31:44 +00:00
|
|
|
NULL, NULL);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* This is the implementation of gdbarch method in_function_epilogue_p. */
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
tilegx_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
|
|
|
|
|
{
|
|
|
|
|
CORE_ADDR func_addr = 0, func_end = 0;
|
|
|
|
|
|
|
|
|
|
if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
|
|
|
|
|
{
|
|
|
|
|
ULONGEST inst, inst2;
|
|
|
|
|
CORE_ADDR addr = func_end - TILEGX_BUNDLE_SIZE_IN_BYTES;
|
|
|
|
|
|
|
|
|
|
/* FIXME: Find the actual epilogue. */
|
|
|
|
|
/* HACK: Just assume the final bundle is the "ret" instruction". */
|
|
|
|
|
if (pc > addr)
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2013-03-01 10:45:28 +00:00
|
|
|
/* This is the implementation of gdbarch method get_longjmp_target. */
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
tilegx_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
|
|
|
|
|
{
|
|
|
|
|
struct gdbarch *gdbarch = get_frame_arch (frame);
|
|
|
|
|
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
|
|
|
|
|
CORE_ADDR jb_addr;
|
|
|
|
|
gdb_byte buf[8];
|
|
|
|
|
|
|
|
|
|
jb_addr = get_frame_register_unsigned (frame, TILEGX_R0_REGNUM);
|
|
|
|
|
|
|
|
|
|
/* TileGX jmp_buf contains 32 elements of type __uint_reg_t which
|
|
|
|
|
has a size of 8 bytes. The return address is stored in the 25th
|
|
|
|
|
slot. */
|
|
|
|
|
if (target_read_memory (jb_addr + 25 * 8, buf, 8))
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
*pc = extract_unsigned_integer (buf, 8, byte_order);
|
|
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
2013-02-19 16:19:33 +00:00
|
|
|
/* by assigning the 'faultnum' reg in kernel pt_regs with this value,
|
|
|
|
|
kernel do_signal will not check r0. see tilegx kernel/signal.c
|
|
|
|
|
for details. */
|
|
|
|
|
#define INT_SWINT_1_SIGRETURN (~0)
|
|
|
|
|
|
|
|
|
|
/* Implement the "write_pc" gdbarch method. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
tilegx_write_pc (struct regcache *regcache, CORE_ADDR pc)
|
|
|
|
|
{
|
|
|
|
|
regcache_cooked_write_unsigned (regcache, TILEGX_PC_REGNUM, pc);
|
|
|
|
|
|
|
|
|
|
/* We must be careful with modifying the program counter. If we
|
|
|
|
|
just interrupted a system call, the kernel might try to restart
|
|
|
|
|
it when we resume the inferior. On restarting the system call,
|
|
|
|
|
the kernel will try backing up the program counter even though it
|
|
|
|
|
no longer points at the system call. This typically results in a
|
|
|
|
|
SIGSEGV or SIGILL. We can prevent this by writing INT_SWINT_1_SIGRETURN
|
|
|
|
|
in the "faultnum" pseudo-register.
|
|
|
|
|
|
|
|
|
|
Note that "faultnum" is saved when setting up a dummy call frame.
|
|
|
|
|
This means that it is properly restored when that frame is
|
|
|
|
|
popped, and that the interrupted system call will be restarted
|
|
|
|
|
when we resume the inferior on return from a function call from
|
|
|
|
|
within GDB. In all other cases the system call will not be
|
|
|
|
|
restarted. */
|
|
|
|
|
regcache_cooked_write_unsigned (regcache, TILEGX_FAULTNUM_REGNUM,
|
|
|
|
|
INT_SWINT_1_SIGRETURN);
|
|
|
|
|
}
|
|
|
|
|
|
2012-05-30 19:31:44 +00:00
|
|
|
/* This is the implementation of gdbarch method breakpoint_from_pc. */
|
|
|
|
|
|
|
|
|
|
static const unsigned char *
|
|
|
|
|
tilegx_breakpoint_from_pc (struct gdbarch *gdbarch,
|
|
|
|
|
CORE_ADDR *pcptr, int *lenptr)
|
|
|
|
|
{
|
|
|
|
|
/* 64-bit pattern for a { bpt ; nop } bundle. */
|
|
|
|
|
static const unsigned char breakpoint[] =
|
|
|
|
|
{ 0x00, 0x50, 0x48, 0x51, 0xae, 0x44, 0x6a, 0x28 };
|
|
|
|
|
|
|
|
|
|
*lenptr = sizeof (breakpoint);
|
|
|
|
|
return breakpoint;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Normal frames. */
|
|
|
|
|
|
|
|
|
|
static struct tilegx_frame_cache *
|
|
|
|
|
tilegx_frame_cache (struct frame_info *this_frame, void **this_cache)
|
|
|
|
|
{
|
|
|
|
|
struct gdbarch *gdbarch = get_frame_arch (this_frame);
|
|
|
|
|
struct tilegx_frame_cache *cache;
|
|
|
|
|
CORE_ADDR current_pc;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
if (*this_cache)
|
|
|
|
|
return *this_cache;
|
|
|
|
|
|
|
|
|
|
cache = FRAME_OBSTACK_ZALLOC (struct tilegx_frame_cache);
|
|
|
|
|
*this_cache = cache;
|
|
|
|
|
cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
|
|
|
|
|
cache->base = 0;
|
|
|
|
|
cache->start_pc = get_frame_func (this_frame);
|
|
|
|
|
current_pc = get_frame_pc (this_frame);
|
|
|
|
|
|
|
|
|
|
cache->base = get_frame_register_unsigned (this_frame, TILEGX_SP_REGNUM);
|
|
|
|
|
trad_frame_set_value (cache->saved_regs, TILEGX_SP_REGNUM, cache->base);
|
|
|
|
|
|
|
|
|
|
if (cache->start_pc)
|
|
|
|
|
tilegx_analyze_prologue (gdbarch, cache->start_pc, current_pc,
|
|
|
|
|
cache, this_frame);
|
|
|
|
|
|
2013-02-19 16:22:42 +00:00
|
|
|
cache->saved_regs[TILEGX_PC_REGNUM] = cache->saved_regs[TILEGX_LR_REGNUM];
|
|
|
|
|
|
2012-05-30 19:31:44 +00:00
|
|
|
return cache;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Retrieve the value of REGNUM in FRAME. */
|
|
|
|
|
|
|
|
|
|
static struct value*
|
|
|
|
|
tilegx_frame_prev_register (struct frame_info *this_frame,
|
|
|
|
|
void **this_cache,
|
|
|
|
|
int regnum)
|
|
|
|
|
{
|
|
|
|
|
struct tilegx_frame_cache *info =
|
|
|
|
|
tilegx_frame_cache (this_frame, this_cache);
|
|
|
|
|
|
|
|
|
|
return trad_frame_get_prev_register (this_frame, info->saved_regs,
|
|
|
|
|
regnum);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Build frame id. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
tilegx_frame_this_id (struct frame_info *this_frame, void **this_cache,
|
|
|
|
|
struct frame_id *this_id)
|
|
|
|
|
{
|
|
|
|
|
struct tilegx_frame_cache *info =
|
|
|
|
|
tilegx_frame_cache (this_frame, this_cache);
|
|
|
|
|
|
|
|
|
|
/* This marks the outermost frame. */
|
|
|
|
|
if (info->base == 0)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
(*this_id) = frame_id_build (info->base, info->start_pc);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static CORE_ADDR
|
|
|
|
|
tilegx_frame_base_address (struct frame_info *this_frame, void **this_cache)
|
|
|
|
|
{
|
|
|
|
|
struct tilegx_frame_cache *cache =
|
|
|
|
|
tilegx_frame_cache (this_frame, this_cache);
|
|
|
|
|
|
|
|
|
|
return cache->base;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static const struct frame_unwind tilegx_frame_unwind = {
|
|
|
|
|
NORMAL_FRAME,
|
|
|
|
|
default_frame_unwind_stop_reason,
|
|
|
|
|
tilegx_frame_this_id,
|
|
|
|
|
tilegx_frame_prev_register,
|
|
|
|
|
NULL, /* const struct frame_data *unwind_data */
|
|
|
|
|
default_frame_sniffer, /* frame_sniffer_ftype *sniffer */
|
|
|
|
|
NULL /* frame_prev_pc_ftype *prev_pc */
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static const struct frame_base tilegx_frame_base = {
|
|
|
|
|
&tilegx_frame_unwind,
|
|
|
|
|
tilegx_frame_base_address,
|
|
|
|
|
tilegx_frame_base_address,
|
|
|
|
|
tilegx_frame_base_address
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static CORE_ADDR
|
|
|
|
|
tilegx_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
|
|
|
|
|
{
|
|
|
|
|
return frame_unwind_register_unsigned (next_frame, TILEGX_SP_REGNUM);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static CORE_ADDR
|
|
|
|
|
tilegx_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
|
|
|
|
|
{
|
|
|
|
|
return frame_unwind_register_unsigned (next_frame, TILEGX_PC_REGNUM);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static struct frame_id
|
|
|
|
|
tilegx_unwind_dummy_id (struct gdbarch *gdbarch,
|
|
|
|
|
struct frame_info *this_frame)
|
|
|
|
|
{
|
|
|
|
|
CORE_ADDR sp;
|
|
|
|
|
|
|
|
|
|
sp = get_frame_register_unsigned (this_frame, TILEGX_SP_REGNUM);
|
|
|
|
|
return frame_id_build (sp, get_frame_pc (this_frame));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* We cannot read/write the "special" registers. */
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
tilegx_cannot_reference_register (struct gdbarch *gdbarch, int regno)
|
|
|
|
|
{
|
|
|
|
|
if (regno >= 0 && regno < TILEGX_NUM_EASY_REGS)
|
|
|
|
|
return 0;
|
2013-02-19 16:19:33 +00:00
|
|
|
else if (regno == TILEGX_PC_REGNUM
|
|
|
|
|
|| regno == TILEGX_FAULTNUM_REGNUM)
|
2012-05-30 19:31:44 +00:00
|
|
|
return 0;
|
|
|
|
|
else
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static struct gdbarch *
|
|
|
|
|
tilegx_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
|
|
|
|
|
{
|
|
|
|
|
struct gdbarch *gdbarch;
|
|
|
|
|
int arch_size = 64;
|
|
|
|
|
|
|
|
|
|
/* Handle arch_size == 32 or 64. Default to 64. */
|
|
|
|
|
if (info.abfd)
|
|
|
|
|
arch_size = bfd_get_arch_size (info.abfd);
|
|
|
|
|
|
|
|
|
|
/* Try to find a pre-existing architecture. */
|
|
|
|
|
for (arches = gdbarch_list_lookup_by_info (arches, &info);
|
|
|
|
|
arches != NULL;
|
|
|
|
|
arches = gdbarch_list_lookup_by_info (arches->next, &info))
|
|
|
|
|
{
|
|
|
|
|
/* We only have two flavors -- just make sure arch_size matches. */
|
|
|
|
|
if (gdbarch_ptr_bit (arches->gdbarch) == arch_size)
|
|
|
|
|
return (arches->gdbarch);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
gdbarch = gdbarch_alloc (&info, NULL);
|
|
|
|
|
|
|
|
|
|
/* Basic register fields and methods, datatype sizes and stuff. */
|
|
|
|
|
|
|
|
|
|
/* There are 64 physical registers which can be referenced by
|
|
|
|
|
instructions (although only 56 of them can actually be
|
|
|
|
|
debugged) and 1 magic register (the PC). The other three
|
|
|
|
|
magic registers (ex1, syscall, orig_r0) which are known to
|
|
|
|
|
"ptrace" are ignored by "gdb". Note that we simply pretend
|
|
|
|
|
that there are 65 registers, and no "pseudo registers". */
|
|
|
|
|
set_gdbarch_num_regs (gdbarch, TILEGX_NUM_REGS);
|
|
|
|
|
set_gdbarch_num_pseudo_regs (gdbarch, 0);
|
|
|
|
|
|
|
|
|
|
set_gdbarch_sp_regnum (gdbarch, TILEGX_SP_REGNUM);
|
|
|
|
|
set_gdbarch_pc_regnum (gdbarch, TILEGX_PC_REGNUM);
|
|
|
|
|
|
|
|
|
|
set_gdbarch_register_name (gdbarch, tilegx_register_name);
|
|
|
|
|
set_gdbarch_register_type (gdbarch, tilegx_register_type);
|
|
|
|
|
|
|
|
|
|
set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
|
|
|
|
|
set_gdbarch_int_bit (gdbarch, 4 * TARGET_CHAR_BIT);
|
|
|
|
|
set_gdbarch_long_bit (gdbarch, arch_size);
|
|
|
|
|
set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
|
|
|
|
|
|
|
|
|
|
set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
|
|
|
|
|
set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
|
|
|
|
|
set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
|
|
|
|
|
|
|
|
|
|
set_gdbarch_ptr_bit (gdbarch, arch_size);
|
|
|
|
|
set_gdbarch_addr_bit (gdbarch, arch_size);
|
|
|
|
|
|
|
|
|
|
set_gdbarch_cannot_fetch_register (gdbarch,
|
|
|
|
|
tilegx_cannot_reference_register);
|
|
|
|
|
set_gdbarch_cannot_store_register (gdbarch,
|
|
|
|
|
tilegx_cannot_reference_register);
|
|
|
|
|
|
|
|
|
|
/* Stack grows down. */
|
|
|
|
|
set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
|
|
|
|
|
|
|
|
|
|
/* Frame Info. */
|
|
|
|
|
set_gdbarch_unwind_sp (gdbarch, tilegx_unwind_sp);
|
|
|
|
|
set_gdbarch_unwind_pc (gdbarch, tilegx_unwind_pc);
|
|
|
|
|
set_gdbarch_dummy_id (gdbarch, tilegx_unwind_dummy_id);
|
|
|
|
|
set_gdbarch_frame_align (gdbarch, tilegx_frame_align);
|
|
|
|
|
frame_base_set_default (gdbarch, &tilegx_frame_base);
|
|
|
|
|
|
|
|
|
|
set_gdbarch_skip_prologue (gdbarch, tilegx_skip_prologue);
|
|
|
|
|
|
|
|
|
|
set_gdbarch_in_function_epilogue_p (gdbarch,
|
|
|
|
|
tilegx_in_function_epilogue_p);
|
|
|
|
|
|
|
|
|
|
/* Map debug registers into internal register numbers. */
|
|
|
|
|
set_gdbarch_dwarf2_reg_to_regnum (gdbarch, tilegx_dwarf2_reg_to_regnum);
|
|
|
|
|
|
|
|
|
|
/* These values and methods are used when gdb calls a target function. */
|
|
|
|
|
set_gdbarch_push_dummy_call (gdbarch, tilegx_push_dummy_call);
|
2013-03-01 10:45:28 +00:00
|
|
|
set_gdbarch_get_longjmp_target (gdbarch, tilegx_get_longjmp_target);
|
2013-02-19 16:19:33 +00:00
|
|
|
set_gdbarch_write_pc (gdbarch, tilegx_write_pc);
|
2012-05-30 19:31:44 +00:00
|
|
|
set_gdbarch_breakpoint_from_pc (gdbarch, tilegx_breakpoint_from_pc);
|
|
|
|
|
set_gdbarch_return_value (gdbarch, tilegx_return_value);
|
|
|
|
|
|
|
|
|
|
set_gdbarch_print_insn (gdbarch, print_insn_tilegx);
|
|
|
|
|
|
|
|
|
|
gdbarch_init_osabi (info, gdbarch);
|
|
|
|
|
|
|
|
|
|
dwarf2_append_unwinders (gdbarch);
|
|
|
|
|
frame_unwind_append_unwinder (gdbarch, &tilegx_frame_unwind);
|
|
|
|
|
|
|
|
|
|
return gdbarch;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Provide a prototype to silence -Wmissing-prototypes. */
|
|
|
|
|
extern initialize_file_ftype _initialize_tilegx_tdep;
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
_initialize_tilegx_tdep (void)
|
|
|
|
|
{
|
|
|
|
|
register_gdbarch_init (bfd_arch_tilegx, tilegx_gdbarch_init);
|
|
|
|
|
}
|
