fuquan/allwinner_a64
1
1
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

upload android base code part8

Browse source
This commit is contained in:
August 2018-08-08 20:10:12 +08:00
parent 841ae54672
commit 5425409085
57075 changed files with 9846578 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

288
android/toolchain/binutils/binutils-2.25/include/gdb/ChangeLog Normal file
View file

@ -0,0 +1,288 @@
2014-03-10 Mike Frysinger <vapier@gentoo.org>
* remote-sim.h (sim_do_command): Add const to cmd.
2014-03-05 Alan Modra <amodra@gmail.com>
Update copyright notice.
2014-03-05 Mike Frysinger <vapier@gentoo.org>
* remote-sim.h (sim_load): Add const to prog.
2014-02-09 Doug Evans <xdje42@gmail.com>
* section-scripts.h: New file.
2013-03-15 Steve Ellcey <sellcey@mips.com>
* gdb/remote-sim.h (sim_command_completer): Make char arguments const.
2013-01-01 Joel Brobecker <brobecker@adacore.com>
Update year range in copyright notice of all files.
2012-06-23 Doug Evans <dje@google.com>
* gdb-index.h: New file.
2012-05-24 Pedro Alves <palves@redhat.com>
PR gdb/7205
Replace TARGET_SIGNAL_ with GDB_SIGNAL_ throughout.
2012-05-24 Pedro Alves <palves@redhat.com>
PR gdb/7205
Replace target_signal with gdb_signal throughout.
2012-04-12 Mike Frysinger <vapier@gentoo.org>
* callback.h (CB_SYS_argc, CB_SYS_argnlen, CB_SYS_argn): Define.
2012-02-03 Kevin Buettner <kevinb@redhat.com>
* sim-rl78.h: New file.
2011-12-03 Mike Frysinger <vapier@gentoo.org>
* callback.h (cb_get_string): New prototype.
2011-04-14 Mike Frysinger <vapier@gentoo.org>
* remote-sim.h (sim_complete_command): New prototype.
2011-03-05 Mike Frysinger <vapier@gentoo.org>
* sim-bfin.h: New file.
2011-01-11 Andrew Burgess <aburgess@broadcom.com>
* remote-sim.h (sim_store_register): Update the API
documentation for this function.
2010-09-06 Pedro Alves <pedro@codesourcery.com>
* signals.def: Replace all ANY uses by SET with specific numbers.
* signals.h (ANY): Remove.
2010-07-31 Jan Kratochvil <jan.kratochvil@redhat.com>
* signals.h (enum target_signal): Move the content to signals.def.
Include it.
* signals.def: New file.
2010-06-24 Kevin Buettner <kevinb@redhat.com>
* sim-rx.h (sim_rx_regnum): Add sim_rx_acc_regnum. Adjust
register order.
2010-04-13 Mike Frysinger <vapier@gentoo.org>
* callback.h: Strip PARAMS from prototypes.
* remote-sim.h: Likewise.
2010-04-13 Mike Frysinger <vapier@gentoo.org>
* remote-sim.h (sim_write): Add const to buf arg.
2009-11-24 DJ Delorie <dj@redhat.com>
* sim-rx.h: New.
2009-05-18 Jon Beniston <jon@beniston.com>
* sim-lm32.h: New file.
2009-01-07 Hans-Peter Nilsson <hp@axis.com>
* callback.h (struct host_callback_struct): Mark member error as
pointing to a noreturn function.
2008-02-12 M Ranga Swami Reddy <MR.Swami.Reddy@nsc.com>
* sim-cr16.h: New file.
2008-01-01 Daniel Jacobowitz <dan@codesourcery.com>
Updated copyright notices for most files.
2007-10-15 Daniel Jacobowitz <dan@codesourcery.com>
* sim-ppc.h (sim_spr_register_name): New prototype.
2007-10-11 Jesper Nilsson <jesper.nilsson@axis.com>
* callback.h (cb_is_stdin, cb_is_stdout, cb_is_stderr): Add prototypes.
2007-08-23 Joel Brobecker <brobecker@adacore.com>
Switch the license of all .h files to GPLv3.
2007-01-09 Daniel Jacobowitz <dan@codesourcery.com>
Updated copyright notices for most files.
2005-07-08 Ben Elliston <bje@au.ibm.com>
* callback.h: Remove ANSI_PROTOTYPES conditional code.
2005-01-28 Hans-Peter Nilsson <hp@axis.com>
* callback.h (struct host_callback_struct): New members pipe,
pipe_empty, pipe_nonempty, ispipe, pipe_buffer and
target_sizeof_int.
(CB_SYS_pipe): New macro.
* callback.h: Include "bfd.h".
(struct host_callback_struct): New member target_endian.
(cb_store_target_endian): Declare.
2004-12-15 Hans-Peter Nilsson <hp@axis.com>
* callback.h (CB_SYS_truncate, CB_SYS_ftruncate): New macros.
2004-12-13 Hans-Peter Nilsson <hp@axis.com>
* callback.h (struct host_callback_struct): New member lstat.
(CB_SYS_lstat): New macro.
(CB_SYS_rename): New macro.
2004-09-08 Michael Snyder <msnyder@redhat.com>
Commited by Corinna Vinschen <vinschen@redhat.com>
* sim-sh.h: Add new sh2a banked registers.
2004-08-04 Andrew Cagney <cagney@gnu.org>
* sim-ppc.h: Add extern "C" wrapper.
(enum sim_ppc_regnum): Add full list of SPRs.
2004-08-04 Jim Blandy <jimb@redhat.com>
* sim-ppc.h: New file.
2004-06-25 J"orn Rennecke <joern.rennecke@superh.com>
* callback.h (host_callback_struct): Replace members fdopen and
alwaysopen with fd_buddy.
[sim/common: * callback.c: Changed all users. ]
2003-10-31 Kevin Buettner <kevin@redhat.com>
* sim-frv.h: New file.
2003-10-15 J"orn Rennecke <joern.rennecke@superh.com>
* callback.h (struct host_callback_struct): New members ftruncate
and truncate.
2003-06-10 Corinna Vinschen <vinschen@redhat.com>
* gdb/fileio.h: New file.
2003-05-07 Andrew Cagney <cagney@redhat.com>
* sim-d10v.h (sim_d10v_translate_addr): Add regcache parameter.
(sim_d10v_translate_imap_addr): Add regcache parameter.
(sim_d10v_translate_dmap_addr): Ditto.
2003-03-27 Nick Clifton <nickc@redhat.com>
* sim-arm.h (sim_arm_regs): Add iWMMXt registers.
2003-03-20 Nick Clifton <nickc@redhat.com>
* sim-arm.h (sim_arm_regs): Add Maverick co-processor
registers.
2003-02-27 Andrew Cagney <cagney@redhat.com>
* remote-sim.h (sim_open, sim_load, sim_create_inferior): Rename
_bfd to bfd.
2003-02-20 Andrew Cagney <ac131313@redhat.com>
* remote-sim.h (SIM_RC): Delete unused SIM_RC_UNKNOWN_BREAKPOINT,
SIM_RC_INSUFFICIENT_RESOURCES and SIM_RC_DUPLICATE_BREAKPOINT.
(sim_set_breakpoint, sim_clear_breakpoint): Delete declarations.
(sim_clear_all_breakpoints, sim_enable_breakpoint): Ditto.
(sim_enable_all_breakpoints, sim_disable_breakpoint): Ditto.
(sim_disable_all_breakpoints): Ditto.
2002-12-26 Kazu Hirata <kazu@cs.umass.edu>
* sim-h8300.h: Remove ^M.
2002-07-29 Andrey Volkov <avolkov@transas.com>
* sim-h8300.h: Rename all enums from H8300_ to SIM_H8300_
prefix.
2002-07-23 Andrey Volkov <avolkov@transas.com>
* sim-h8300.h: New file.
2002-07-17 Andrew Cagney <cagney@redhat.com>
* remote-sim.h: Update copyright.
(sim_set_callbacks, sim_size, sim_trace)
(sim_set_trace, sim_set_profile_size, sim_kill): Delete. Moved to
"sim/common/run-sim.h".
Wed Jul 17 19:36:38 2002 J"orn Rennecke <joern.rennecke@superh.com>
* sim-sh.h: Add enum constants for sh[1-4], sh3e, sh3?-dsp,
renumbering the sh-dsp registers to use distinct numbers.
2002-06-15 Andrew Cagney <ac131313@redhat.com>
* sim-arm.h (enum sim_arm_regs): Rename sim_arm_regnum.
2002-06-12 Andrew Cagney <ac131313@redhat.com>
* sim-arm.h: New file.
2002-06-08 Andrew Cagney <cagney@redhat.com>
* callback.h: Copy to here from directory above.
* remote-sim.h: Copy to here from directory above.
2002-06-01 Andrew Cagney <ac131313@redhat.com>
* sim-d10v.h (sim_d10v_regs): Expand to include all registers.
Update copyright.
2002-05-23 Andrew Cagney <ac131313@redhat.com>
* sim-d10v.h: New file. Moved from include/sim-d10v.h.
2002-05-10 Elena Zannoni <ezannoni@redhat.com>
* sim-sh.h: New file, for sh gdb<->sim interface.
2002-05-09 Daniel Jacobowitz <drow@mvista.com>
* signals.h: Update comments.
(enum target_signal): Remove conditional compilation around
Mach-specific signals. Move them to after TARGET_SIGNAL_DEFAULT.
2002-03-10 Daniel Jacobowitz <drow@mvista.com>
* signals.h: New file, from gdb/defs.h.
Copyright (C) 2002-2014 Free Software Foundation, Inc.
Copying and distribution of this file, with or without modification,
are permitted in any medium without royalty provided the copyright
notice and this notice are preserved.
Local Variables:
mode: change-log
left-margin: 8
fill-column: 74
version-control: never
End:

338
android/toolchain/binutils/binutils-2.25/include/gdb/callback.h Normal file
View file

@ -0,0 +1,338 @@
/* Remote target system call callback support.
Copyright (C) 1997-2014 Free Software Foundation, Inc.
Contributed by Cygnus Solutions.
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/>. */
/* This interface isn't intended to be specific to any particular kind
of remote (hardware, simulator, whatever). As such, support for it
(e.g. sim/common/callback.c) should *not* live in the simulator source
tree, nor should it live in the gdb source tree. */
/* There are various ways to handle system calls:
1) Have a simulator intercept the appropriate trap instruction and
directly perform the system call on behalf of the target program.
This is the typical way of handling system calls for embedded targets.
[Handling system calls for embedded targets isn't that much of an
oxymoron as running compiler testsuites make use of the capability.]
This method of system call handling is done when STATE_ENVIRONMENT
is ENVIRONMENT_USER.
2) Have a simulator emulate the hardware as much as possible.
If the program running on the real hardware communicates with some sort
of target manager, one would want to be able to run this program on the
simulator as well.
This method of system call handling is done when STATE_ENVIRONMENT
is ENVIRONMENT_OPERATING.
*/
#ifndef CALLBACK_H
#define CALLBACK_H
/* ??? The reason why we check for va_start here should be documented. */
#ifndef va_start
#include <ansidecl.h>
#include <stdarg.h>
#endif
/* Needed for enum bfd_endian. */
#include "bfd.h"
/* Mapping of host/target values. */
/* ??? For debugging purposes, one might want to add a string of the
name of the symbol. */
typedef struct {
int host_val;
int target_val;
} CB_TARGET_DEFS_MAP;
#define MAX_CALLBACK_FDS 10
/* Forward decl for stat/fstat. */
struct stat;
typedef struct host_callback_struct host_callback;
struct host_callback_struct
{
int (*close) (host_callback *,int);
int (*get_errno) (host_callback *);
int (*isatty) (host_callback *, int);
int (*lseek) (host_callback *, int, long , int);
int (*open) (host_callback *, const char*, int mode);
int (*read) (host_callback *,int, char *, int);
int (*read_stdin) ( host_callback *, char *, int);
int (*rename) (host_callback *, const char *, const char *);
int (*system) (host_callback *, const char *);
long (*time) (host_callback *, long *);
int (*unlink) (host_callback *, const char *);
int (*write) (host_callback *,int, const char *, int);
int (*write_stdout) (host_callback *, const char *, int);
void (*flush_stdout) (host_callback *);
int (*write_stderr) (host_callback *, const char *, int);
void (*flush_stderr) (host_callback *);
int (*stat) (host_callback *, const char *, struct stat *);
int (*fstat) (host_callback *, int, struct stat *);
int (*lstat) (host_callback *, const char *, struct stat *);
int (*ftruncate) (host_callback *, int, long);
int (*truncate) (host_callback *, const char *, long);
int (*pipe) (host_callback *, int *);
/* Called by the framework when a read call has emptied a pipe buffer. */
void (*pipe_empty) (host_callback *, int read_fd, int write_fd);
/* Called by the framework when a write call makes a pipe buffer
non-empty. */
void (*pipe_nonempty) (host_callback *, int read_fd, int write_fd);
/* When present, call to the client to give it the oportunity to
poll any io devices for a request to quit (indicated by a nonzero
return value). */
int (*poll_quit) (host_callback *);
/* Used when the target has gone away, so we can close open
handles and free memory etc etc. */
int (*shutdown) (host_callback *);
int (*init) (host_callback *);
/* depreciated, use vprintf_filtered - Talk to the user on a console. */
void (*printf_filtered) (host_callback *, const char *, ...);
/* Talk to the user on a console. */
void (*vprintf_filtered) (host_callback *, const char *, va_list);
/* Same as vprintf_filtered but to stderr. */
void (*evprintf_filtered) (host_callback *, const char *, va_list);
/* Print an error message and "exit".
In the case of gdb "exiting" means doing a longjmp back to the main
command loop. */
void (*error) (host_callback *, const char *, ...)
#ifdef __GNUC__
__attribute__ ((__noreturn__))
#endif
;
int last_errno; /* host format */
int fdmap[MAX_CALLBACK_FDS];
/* fd_buddy is used to contruct circular lists of target fds that point to
the same host fd. A uniquely mapped fd points to itself; for a closed
one, fd_buddy has the value -1. The host file descriptors for stdin /
stdout / stderr are never closed by the simulators, so they are put
in a special fd_buddy circular list which also has MAX_CALLBACK_FDS
as a member. */
/* ??? We don't have a callback entry for dup, although it is trival to
implement now. */
short fd_buddy[MAX_CALLBACK_FDS+1];
/* 0 = none, >0 = reader (index of writer),
<0 = writer (negative index of reader).
If abs (ispipe[N]) == N, then N is an end of a pipe whose other
end is closed. */
short ispipe[MAX_CALLBACK_FDS];
/* A writer stores the buffer at its index. Consecutive writes
realloc the buffer and add to the size. The reader indicates the
read part in its .size, until it has consumed it all, at which
point it deallocates the buffer and zeroes out both sizes. */
struct pipe_write_buffer
{
int size;
char *buffer;
} pipe_buffer[MAX_CALLBACK_FDS];
/* System call numbers. */
CB_TARGET_DEFS_MAP *syscall_map;
/* Errno values. */
CB_TARGET_DEFS_MAP *errno_map;
/* Flags to the open system call. */
CB_TARGET_DEFS_MAP *open_map;
/* Signal numbers. */
CB_TARGET_DEFS_MAP *signal_map;
/* Layout of `stat' struct.
The format is a series of "name,length" pairs separated by colons.
Empty space is indicated with a `name' of "space".
All padding must be explicitly mentioned.
Lengths are in bytes. If this needs to be extended to bits,
use "name.bits".
Example: "st_dev,4:st_ino,4:st_mode,4:..." */
const char *stat_map;
enum bfd_endian target_endian;
/* Size of an "int" on the target (for syscalls whose ABI uses "int").
This must include padding, and only padding-at-higher-address is
supported. For example, a 64-bit target with 32-bit int:s which
are padded to 64 bits when in an array, should supposedly set this
to 8. The default is 4 which matches ILP32 targets and 64-bit
targets with 32-bit ints and no padding. */
int target_sizeof_int;
/* Marker for those wanting to do sanity checks.
This should remain the last member of this struct to help catch
miscompilation errors. */
#define HOST_CALLBACK_MAGIC 4705 /* teds constant */
int magic;
};
extern host_callback default_callback;
/* Canonical versions of system call numbers.
It's not intended to willy-nilly throw every system call ever heard
of in here. Only include those that have an important use.
??? One can certainly start a discussion over the ones that are currently
here, but that will always be true. */
/* These are used by the ANSI C support of libc. */
#define CB_SYS_exit 1
#define CB_SYS_open 2
#define CB_SYS_close 3
#define CB_SYS_read 4
#define CB_SYS_write 5
#define CB_SYS_lseek 6
#define CB_SYS_unlink 7
#define CB_SYS_getpid 8
#define CB_SYS_kill 9
#define CB_SYS_fstat 10
/*#define CB_SYS_sbrk 11 - not currently a system call, but reserved. */
/* ARGV support. */
#define CB_SYS_argvlen 12
#define CB_SYS_argv 13
/* These are extras added for one reason or another. */
#define CB_SYS_chdir 14
#define CB_SYS_stat 15
#define CB_SYS_chmod 16
#define CB_SYS_utime 17
#define CB_SYS_time 18
/* More standard syscalls. */
#define CB_SYS_lstat 19
#define CB_SYS_rename 20
#define CB_SYS_truncate 21
#define CB_SYS_ftruncate 22
#define CB_SYS_pipe 23
/* New ARGV support. */
#define CB_SYS_argc 24
#define CB_SYS_argnlen 25
#define CB_SYS_argn 26
/* Struct use to pass and return information necessary to perform a
system call. */
/* FIXME: Need to consider target word size. */
typedef struct cb_syscall {
/* The target's value of what system call to perform. */
int func;
/* The arguments to the syscall. */
long arg1, arg2, arg3, arg4;
/* The result. */
long result;
/* Some system calls have two results. */
long result2;
/* The target's errno value, or 0 if success.
This is converted to the target's value with host_to_target_errno. */
int errcode;
/* Working space to be used by memory read/write callbacks. */
PTR p1;
PTR p2;
long x1,x2;
/* Callbacks for reading/writing memory (e.g. for read/write syscalls).
??? long or unsigned long might be better to use for the `count'
argument here. We mimic sim_{read,write} for now. Be careful to
test any changes with -Wall -Werror, mixed signed comparisons
will get you. */
int (*read_mem) (host_callback * /*cb*/, struct cb_syscall * /*sc*/,
unsigned long /*taddr*/, char * /*buf*/,
int /*bytes*/);
int (*write_mem) (host_callback * /*cb*/, struct cb_syscall * /*sc*/,
unsigned long /*taddr*/, const char * /*buf*/,
int /*bytes*/);
/* For sanity checking, should be last entry. */
int magic;
} CB_SYSCALL;
/* Magic number sanity checker. */
#define CB_SYSCALL_MAGIC 0x12344321
/* Macro to initialize CB_SYSCALL. Called first, before filling in
any fields. */
#define CB_SYSCALL_INIT(sc) \
do { \
memset ((sc), 0, sizeof (*(sc))); \
(sc)->magic = CB_SYSCALL_MAGIC; \
} while (0)
/* Return codes for various interface routines. */
typedef enum {
CB_RC_OK = 0,
/* generic error */
CB_RC_ERR,
/* either file not found or no read access */
CB_RC_ACCESS,
CB_RC_NO_MEM
} CB_RC;
/* Read in target values for system call numbers, errno values, signals. */
CB_RC cb_read_target_syscall_maps (host_callback *, const char *);
/* Translate target to host syscall function numbers. */
int cb_target_to_host_syscall (host_callback *, int);
/* Translate host to target errno value. */
int cb_host_to_target_errno (host_callback *, int);
/* Translate target to host open flags. */
int cb_target_to_host_open (host_callback *, int);
/* Translate target signal number to host. */
int cb_target_to_host_signal (host_callback *, int);
/* Translate host signal number to target. */
int cb_host_to_gdb_signal (host_callback *, int);
/* Translate host stat struct to target.
If stat struct ptr is NULL, just compute target stat struct size.
Result is size of target stat struct or 0 if error. */
int cb_host_to_target_stat (host_callback *, const struct stat *, PTR);
/* Translate a value to target endian. */
void cb_store_target_endian (host_callback *, char *, int, long);
/* Tests for special fds. */
int cb_is_stdin (host_callback *, int);
int cb_is_stdout (host_callback *, int);
int cb_is_stderr (host_callback *, int);
/* Read a string out of the target. */
int cb_get_string (host_callback *, CB_SYSCALL *, char *, int, unsigned long);
/* Perform a system call. */
CB_RC cb_syscall (host_callback *, CB_SYSCALL *);
#endif

144
android/toolchain/binutils/binutils-2.25/include/gdb/fileio.h Normal file
View file

@ -0,0 +1,144 @@
/* Hosted File I/O interface definitions, for GDB, the GNU Debugger.
Copyright (C) 2003-2014 Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 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/>. */
#ifndef GDB_FILEIO_H_
#define GDB_FILEIO_H_
/* The following flags are defined to be independent of the host
as well as the target side implementation of these constants.
All constants are defined with a leading FILEIO_ in the name
to allow the usage of these constants together with the
corresponding implementation dependent constants in one module. */
/* open(2) flags */
#define FILEIO_O_RDONLY 0x0
#define FILEIO_O_WRONLY 0x1
#define FILEIO_O_RDWR 0x2
#define FILEIO_O_APPEND 0x8
#define FILEIO_O_CREAT 0x200
#define FILEIO_O_TRUNC 0x400
#define FILEIO_O_EXCL 0x800
#define FILEIO_O_SUPPORTED (FILEIO_O_RDONLY | FILEIO_O_WRONLY| \
FILEIO_O_RDWR | FILEIO_O_APPEND| \
FILEIO_O_CREAT | FILEIO_O_TRUNC| \
FILEIO_O_EXCL)
/* mode_t bits */
#define FILEIO_S_IFREG 0100000
#define FILEIO_S_IFDIR 040000
#define FILEIO_S_IFCHR 020000
#define FILEIO_S_IRUSR 0400
#define FILEIO_S_IWUSR 0200
#define FILEIO_S_IXUSR 0100
#define FILEIO_S_IRWXU 0700
#define FILEIO_S_IRGRP 040
#define FILEIO_S_IWGRP 020
#define FILEIO_S_IXGRP 010
#define FILEIO_S_IRWXG 070
#define FILEIO_S_IROTH 04
#define FILEIO_S_IWOTH 02
#define FILEIO_S_IXOTH 01
#define FILEIO_S_IRWXO 07
#define FILEIO_S_SUPPORTED (FILEIO_S_IFREG|FILEIO_S_IFDIR| \
FILEIO_S_IRWXU|FILEIO_S_IRWXG| \
FILEIO_S_IRWXO)
/* lseek(2) flags */
#define FILEIO_SEEK_SET 0
#define FILEIO_SEEK_CUR 1
#define FILEIO_SEEK_END 2
/* errno values */
#define FILEIO_EPERM 1
#define FILEIO_ENOENT 2
#define FILEIO_EINTR 4
#define FILEIO_EIO 5
#define FILEIO_EBADF 9
#define FILEIO_EACCES 13
#define FILEIO_EFAULT 14
#define FILEIO_EBUSY 16
#define FILEIO_EEXIST 17
#define FILEIO_ENODEV 19
#define FILEIO_ENOTDIR 20
#define FILEIO_EISDIR 21
#define FILEIO_EINVAL 22
#define FILEIO_ENFILE 23
#define FILEIO_EMFILE 24
#define FILEIO_EFBIG 27
#define FILEIO_ENOSPC 28
#define FILEIO_ESPIPE 29
#define FILEIO_EROFS 30
#define FILEIO_ENOSYS 88
#define FILEIO_ENAMETOOLONG 91
#define FILEIO_EUNKNOWN 9999
/* limits */
#define FILEIO_INT_MIN -2147483648L
#define FILEIO_INT_MAX 2147483647L
#define FILEIO_UINT_MAX 4294967295UL
#define FILEIO_LONG_MIN -9223372036854775808LL
#define FILEIO_LONG_MAX 9223372036854775807LL
#define FILEIO_ULONG_MAX 18446744073709551615ULL
/* Integral types as used in protocol. */
#if 0
typedef __int32_t fio_int_t;
typedef __uint32_t fio_uint_t, fio_mode_t, fio_time_t;
typedef __int64_t fio_long_t;
typedef __uint64_t fio_ulong_t;
#endif
#define FIO_INT_LEN 4
#define FIO_UINT_LEN 4
#define FIO_MODE_LEN 4
#define FIO_TIME_LEN 4
#define FIO_LONG_LEN 8
#define FIO_ULONG_LEN 8
typedef char fio_int_t[FIO_INT_LEN];
typedef char fio_uint_t[FIO_UINT_LEN];
typedef char fio_mode_t[FIO_MODE_LEN];
typedef char fio_time_t[FIO_TIME_LEN];
typedef char fio_long_t[FIO_LONG_LEN];
typedef char fio_ulong_t[FIO_ULONG_LEN];
/* Struct stat as used in protocol. For complete independence
of host/target systems, it's defined as an array with offsets
to the members. */
struct fio_stat {
fio_uint_t fst_dev;
fio_uint_t fst_ino;
fio_mode_t fst_mode;
fio_uint_t fst_nlink;
fio_uint_t fst_uid;
fio_uint_t fst_gid;
fio_uint_t fst_rdev;
fio_ulong_t fst_size;
fio_ulong_t fst_blksize;
fio_ulong_t fst_blocks;
fio_time_t fst_atime;
fio_time_t fst_mtime;
fio_time_t fst_ctime;
};
struct fio_timeval {
fio_time_t ftv_sec;
fio_long_t ftv_usec;
};
#endif /* GDB_FILEIO_H_ */

99
android/toolchain/binutils/binutils-2.25/include/gdb/gdb-index.h Normal file
View file

@ -0,0 +1,99 @@
/* Public attributes of the .gdb_index section.
Copyright (C) 2012-2014 Free Software Foundation, Inc.
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/>. */
/* This file contains values for understanding the .gdb_index section
needed by more than just GDB, e.g. readelf. */
#ifndef GDB_INDEX_H
#define GDB_INDEX_H
/* Each symbol in .gdb_index refers to a set of CUs that defines the symbol.
Each CU is represented by a 32 bit number that is the index of the CU in
the CU table, plus some attributes of the use of the symbol in that CU.
The values are defined such that if all the bits are zero, then no
special meaning is assigned to any of them. This is done to preserve
compatibility with older indices. The way this is done is to specify
that if the GDB_INDEX_SYMBOL_KIND value is zero then all other attribute
bits must be zero.
0-23 CU index
24-27 reserved
28-30 symbol kind
31 0 == global, 1 == static
Bits 24-27 are reserved because it's easier to relax restrictions than
it is to impose them after the fact. At present 24 bits to represent
the CU index is plenty. If we need more bits for the CU index or for
attributes then we have them. */
/* Whether the symbol is in GLOBAL_BLOCK (== 0) or STATIC_BLOCK (== 1). */
#define GDB_INDEX_SYMBOL_STATIC_SHIFT 31
#define GDB_INDEX_SYMBOL_STATIC_MASK 1
#define GDB_INDEX_SYMBOL_STATIC_VALUE(cu_index) \
(((cu_index) >> GDB_INDEX_SYMBOL_STATIC_SHIFT) & GDB_INDEX_SYMBOL_STATIC_MASK)
#define GDB_INDEX_SYMBOL_STATIC_SET_VALUE(cu_index, value) \
do { \
(cu_index) |= (((value) & GDB_INDEX_SYMBOL_STATIC_MASK) \
<< GDB_INDEX_SYMBOL_STATIC_SHIFT); \
} while (0)
/* The kind of the symbol.
We don't use GDB's internal values as these numbers are published
so that other tools can build and read .gdb_index. */
typedef enum {
/* Special value to indicate no attributes are present. */
GDB_INDEX_SYMBOL_KIND_NONE = 0,
GDB_INDEX_SYMBOL_KIND_TYPE = 1,
GDB_INDEX_SYMBOL_KIND_VARIABLE = 2,
GDB_INDEX_SYMBOL_KIND_FUNCTION = 3,
GDB_INDEX_SYMBOL_KIND_OTHER = 4,
/* We currently allocate 3 bits to record the symbol kind.
Give the unused bits a value so gdb will print them sensibly. */
GDB_INDEX_SYMBOL_KIND_UNUSED5 = 5,
GDB_INDEX_SYMBOL_KIND_UNUSED6 = 6,
GDB_INDEX_SYMBOL_KIND_UNUSED7 = 7
} gdb_index_symbol_kind;
#define GDB_INDEX_SYMBOL_KIND_SHIFT 28
#define GDB_INDEX_SYMBOL_KIND_MASK 7
#define GDB_INDEX_SYMBOL_KIND_VALUE(cu_index) \
((gdb_index_symbol_kind) (((cu_index) >> GDB_INDEX_SYMBOL_KIND_SHIFT) \
& GDB_INDEX_SYMBOL_KIND_MASK))
#define GDB_INDEX_SYMBOL_KIND_SET_VALUE(cu_index, value) \
do { \
(cu_index) |= (((value) & GDB_INDEX_SYMBOL_KIND_MASK) \
<< GDB_INDEX_SYMBOL_KIND_SHIFT); \
} while (0)
#define GDB_INDEX_RESERVED_SHIFT 24
#define GDB_INDEX_RESERVED_MASK 15
#define GDB_INDEX_RESERVED_VALUE(cu_index) \
(((cu_index) >> GDB_INDEX_RESERVED_SHIFT) & GDB_INDEX_RESERVED_MASK)
/* CU index. */
#define GDB_INDEX_CU_BITSIZE 24
#define GDB_INDEX_CU_MASK ((1 << GDB_INDEX_CU_BITSIZE) - 1)
#define GDB_INDEX_CU_VALUE(cu_index) ((cu_index) & GDB_INDEX_CU_MASK)
#define GDB_INDEX_CU_SET_VALUE(cu_index, value) \
do { \
(cu_index) |= (value) & GDB_INDEX_CU_MASK; \
} while (0)
#endif /* GDB_INDEX_H */

287
android/toolchain/binutils/binutils-2.25/include/gdb/remote-sim.h Normal file
View file

@ -0,0 +1,287 @@
/* This file defines the interface between the simulator and gdb.
Copyright (C) 1993-2014 Free Software Foundation, Inc.
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/>. */
#if !defined (REMOTE_SIM_H)
#define REMOTE_SIM_H 1
#ifdef __cplusplus
extern "C" {
#endif
/* This file is used when building stand-alone simulators, so isolate this
file from gdb. */
/* Pick up CORE_ADDR_TYPE if defined (from gdb), otherwise use same value as
gdb does (unsigned int - from defs.h). */
#ifndef CORE_ADDR_TYPE
typedef unsigned int SIM_ADDR;
#else
typedef CORE_ADDR_TYPE SIM_ADDR;
#endif
/* Semi-opaque type used as result of sim_open and passed back to all
other routines. "desc" is short for "descriptor".
It is up to each simulator to define `sim_state'. */
typedef struct sim_state *SIM_DESC;
/* Values for `kind' arg to sim_open. */
typedef enum {
SIM_OPEN_STANDALONE, /* simulator used standalone (run.c) */
SIM_OPEN_DEBUG /* simulator used by debugger (gdb) */
} SIM_OPEN_KIND;
/* Return codes from various functions. */
typedef enum {
SIM_RC_FAIL = 0,
SIM_RC_OK = 1
} SIM_RC;
/* The bfd struct, as an opaque type. */
struct bfd;
/* Main simulator entry points. */
/* Create a fully initialized simulator instance.
(This function is called when the simulator is selected from the
gdb command line.)
KIND specifies how the simulator shall be used. Currently there
are only two kinds: stand-alone and debug.
CALLBACK specifies a standard host callback (defined in callback.h).
ABFD, when non NULL, designates a target program. The program is
not loaded.
ARGV is a standard ARGV pointer such as that passed from the
command line. The syntax of the argument list is is assumed to be
``SIM-PROG { SIM-OPTION } [ TARGET-PROGRAM { TARGET-OPTION } ]''.
The trailing TARGET-PROGRAM and args are only valid for a
stand-alone simulator.
On success, the result is a non NULL descriptor that shall be
passed to the other sim_foo functions. While the simulator
configuration can be parameterized by (in decreasing precedence)
ARGV's SIM-OPTION, ARGV's TARGET-PROGRAM and the ABFD argument, the
successful creation of the simulator shall not dependent on the
presence of any of these arguments/options.
Hardware simulator: The created simulator shall be sufficiently
initialized to handle, with out restrictions any client requests
(including memory reads/writes, register fetch/stores and a
resume).
Process simulator: that process is not created until a call to
sim_create_inferior. FIXME: What should the state of the simulator
be? */
SIM_DESC sim_open (SIM_OPEN_KIND kind, struct host_callback_struct *callback, struct bfd *abfd, char **argv);
/* Destory a simulator instance.
QUITTING is non-zero if we cannot hang on errors.
This may involve freeing target memory and closing any open files
and mmap'd areas. You cannot assume sim_kill has already been
called. */
void sim_close (SIM_DESC sd, int quitting);
/* Load program PROG into the simulators memory.
If ABFD is non-NULL, the bfd for the file has already been opened.
The result is a return code indicating success.
Hardware simulator: Normally, each program section is written into
memory according to that sections LMA using physical (direct)
addressing. The exception being systems, such as PPC/CHRP, which
support more complicated program loaders. A call to this function
should not effect the state of the processor registers. Multiple
calls to this function are permitted and have an accumulative
effect.
Process simulator: Calls to this function may be ignored.
FIXME: Most hardware simulators load the image at the VMA using
virtual addressing.
FIXME: For some hardware targets, before a loaded program can be
executed, it requires the manipulation of VM registers and tables.
Such manipulation should probably (?) occure in
sim_create_inferior. */
SIM_RC sim_load (SIM_DESC sd, const char *prog, struct bfd *abfd, int from_tty);
/* Prepare to run the simulated program.
ABFD, if not NULL, provides initial processor state information.
ARGV and ENV, if non NULL, are NULL terminated lists of pointers.
Hardware simulator: This function shall initialize the processor
registers to a known value. The program counter and possibly stack
pointer shall be set using information obtained from ABFD (or
hardware reset defaults). ARGV and ENV, dependant on the target
ABI, may be written to memory.
Process simulator: After a call to this function, a new process
instance shall exist. The TEXT, DATA, BSS and stack regions shall
all be initialized, ARGV and ENV shall be written to process
address space (according to the applicable ABI) and the program
counter and stack pointer set accordingly. */
SIM_RC sim_create_inferior (SIM_DESC sd, struct bfd *abfd, char **argv, char **env);
/* Fetch LENGTH bytes of the simulated program's memory. Start fetch
at virtual address MEM and store in BUF. Result is number of bytes
read, or zero if error. */
int sim_read (SIM_DESC sd, SIM_ADDR mem, unsigned char *buf, int length);
/* Store LENGTH bytes from BUF into the simulated program's
memory. Store bytes starting at virtual address MEM. Result is
number of bytes write, or zero if error. */
int sim_write (SIM_DESC sd, SIM_ADDR mem, const unsigned char *buf, int length);
/* Fetch register REGNO storing its raw (target endian) value in the
LENGTH byte buffer BUF. Return the actual size of the register or
zero if REGNO is not applicable.
Legacy implementations ignore LENGTH and always return -1.
If LENGTH does not match the size of REGNO no data is transfered
(the actual register size is still returned). */
int sim_fetch_register (SIM_DESC sd, int regno, unsigned char *buf, int length);
/* Store register REGNO from the raw (target endian) value in BUF.
Return the actual size of the register, any size not equal to
LENGTH indicates the register was not updated correctly.
Return a LENGTH of -1 to indicate the register was not updated
and an error has occurred.
Return a LENGTH of 0 to indicate the register was not updated
but no error has occurred. */
int sim_store_register (SIM_DESC sd, int regno, unsigned char *buf, int length);
/* Print whatever statistics the simulator has collected.
VERBOSE is currently unused and must always be zero. */
void sim_info (SIM_DESC sd, int verbose);
/* Run (or resume) the simulated program.
STEP, when non-zero indicates that only a single simulator cycle
should be emulated.
SIGGNAL, if non-zero is a (HOST) SIGRC value indicating the type of
event (hardware interrupt, signal) to be delivered to the simulated
program.
Hardware simulator: If the SIGRC value returned by
sim_stop_reason() is passed back to the simulator via SIGGNAL then
the hardware simulator shall correctly deliver the hardware event
indicated by that signal. If a value of zero is passed in then the
simulation will continue as if there were no outstanding signal.
The effect of any other SIGGNAL value is is implementation
dependant.
Process simulator: If SIGRC is non-zero then the corresponding
signal is delivered to the simulated program and execution is then
continued. A zero SIGRC value indicates that the program should
continue as normal. */
void sim_resume (SIM_DESC sd, int step, int siggnal);
/* Asynchronous request to stop the simulation.
A nonzero return indicates that the simulator is able to handle
the request */
int sim_stop (SIM_DESC sd);
/* Fetch the REASON why the program stopped.
SIM_EXITED: The program has terminated. SIGRC indicates the target
dependant exit status.
SIM_STOPPED: The program has stopped. SIGRC uses the host's signal
numbering as a way of identifying the reaon: program interrupted by
user via a sim_stop request (SIGINT); a breakpoint instruction
(SIGTRAP); a completed single step (SIGTRAP); an internal error
condition (SIGABRT); an illegal instruction (SIGILL); Access to an
undefined memory region (SIGSEGV); Mis-aligned memory access
(SIGBUS). For some signals information in addition to the signal
number may be retained by the simulator (e.g. offending address),
that information is not directly accessable via this interface.
SIM_SIGNALLED: The program has been terminated by a signal. The
simulator has encountered target code that causes the the program
to exit with signal SIGRC.
SIM_RUNNING, SIM_POLLING: The return of one of these values
indicates a problem internal to the simulator. */
enum sim_stop { sim_running, sim_polling, sim_exited, sim_stopped, sim_signalled };
void sim_stop_reason (SIM_DESC sd, enum sim_stop *reason, int *sigrc);
/* Passthru for other commands that the simulator might support.
Simulators should be prepared to deal with any combination of NULL
or empty CMD. */
void sim_do_command (SIM_DESC sd, const char *cmd);
/* Complete a command based on the available sim commands. Returns an
array of possible matches. */
char **sim_complete_command (SIM_DESC sd, const char *text, const char *word);
#ifdef __cplusplus
}
#endif
#endif /* !defined (REMOTE_SIM_H) */

50
android/toolchain/binutils/binutils-2.25/include/gdb/section-scripts.h Normal file
View file

@ -0,0 +1,50 @@
/* Definition of kinds of records in section .debug_gdb_scripts.
Copyright (C) 2014 Free Software Foundation, Inc.
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/>. */
#ifndef GDB_SECTION_SCRIPTS_H
#define GDB_SECTION_SCRIPTS_H
/* Each entry in section .debug_gdb_scripts begins with a byte that is used to
identify the entry. This byte is to use as we choose.
0 is reserved so that it is never used (to catch errors).
It is recommended to avoid ASCII values 32-127 to help catch (most) cases
of forgetting to include this byte.
Other unused values needn't specify different scripting languages,
but we have no need for anything else at the moment.
Future extension: Include the contents of the script in the section.
These values are defined as macros so that they can be used in embedded
asms and assembler source files. */
/* Reserved. */
#define SECTION_SCRIPT_ID_NEVER_USE 0
/* The record is a nul-terminated file name to load as a python file. */
#define SECTION_SCRIPT_ID_PYTHON_FILE 1
/* Native GDB scripts are not currently supported in .debug_gdb_scripts,
but we reserve a value for it. */
/*#define SECTION_SCRIPT_ID_GDB_FILE 2*/
/* The record is a nul-terminated file name to load as a guile(scheme)
file. */
#define SECTION_SCRIPT_ID_SCHEME_FILE 3
#endif /* GDB_SECTION_SCRIPTS_H */

200
android/toolchain/binutils/binutils-2.25/include/gdb/signals.def Normal file
View file

@ -0,0 +1,200 @@
/* Target signal numbers for GDB and the GDB remote protocol.
Copyright (C) 2010-2014 Free Software Foundation, Inc.
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/>. */
/* Used some places (e.g. stop_signal) to record the concept that
there is no signal. */
SET (GDB_SIGNAL_0, 0, "0", "Signal 0")
#define GDB_SIGNAL_FIRST GDB_SIGNAL_0
SET (GDB_SIGNAL_HUP, 1, "SIGHUP", "Hangup")
SET (GDB_SIGNAL_INT, 2, "SIGINT", "Interrupt")
SET (GDB_SIGNAL_QUIT, 3, "SIGQUIT", "Quit")
SET (GDB_SIGNAL_ILL, 4, "SIGILL", "Illegal instruction")
SET (GDB_SIGNAL_TRAP, 5, "SIGTRAP", "Trace/breakpoint trap")
SET (GDB_SIGNAL_ABRT, 6, "SIGABRT", "Aborted")
SET (GDB_SIGNAL_EMT, 7, "SIGEMT", "Emulation trap")
SET (GDB_SIGNAL_FPE, 8, "SIGFPE", "Arithmetic exception")
SET (GDB_SIGNAL_KILL, 9, "SIGKILL", "Killed")
SET (GDB_SIGNAL_BUS, 10, "SIGBUS", "Bus error")
SET (GDB_SIGNAL_SEGV, 11, "SIGSEGV", "Segmentation fault")
SET (GDB_SIGNAL_SYS, 12, "SIGSYS", "Bad system call")
SET (GDB_SIGNAL_PIPE, 13, "SIGPIPE", "Broken pipe")
SET (GDB_SIGNAL_ALRM, 14, "SIGALRM", "Alarm clock")
SET (GDB_SIGNAL_TERM, 15, "SIGTERM", "Terminated")
SET (GDB_SIGNAL_URG, 16, "SIGURG", "Urgent I/O condition")
SET (GDB_SIGNAL_STOP, 17, "SIGSTOP", "Stopped (signal)")
SET (GDB_SIGNAL_TSTP, 18, "SIGTSTP", "Stopped (user)")
SET (GDB_SIGNAL_CONT, 19, "SIGCONT", "Continued")
SET (GDB_SIGNAL_CHLD, 20, "SIGCHLD", "Child status changed")
SET (GDB_SIGNAL_TTIN, 21, "SIGTTIN", "Stopped (tty input)")
SET (GDB_SIGNAL_TTOU, 22, "SIGTTOU", "Stopped (tty output)")
SET (GDB_SIGNAL_IO, 23, "SIGIO", "I/O possible")
SET (GDB_SIGNAL_XCPU, 24, "SIGXCPU", "CPU time limit exceeded")
SET (GDB_SIGNAL_XFSZ, 25, "SIGXFSZ", "File size limit exceeded")
SET (GDB_SIGNAL_VTALRM, 26, "SIGVTALRM", "Virtual timer expired")
SET (GDB_SIGNAL_PROF, 27, "SIGPROF", "Profiling timer expired")
SET (GDB_SIGNAL_WINCH, 28, "SIGWINCH", "Window size changed")
SET (GDB_SIGNAL_LOST, 29, "SIGLOST", "Resource lost")
SET (GDB_SIGNAL_USR1, 30, "SIGUSR1", "User defined signal 1")
SET (GDB_SIGNAL_USR2, 31, "SIGUSR2", "User defined signal 2")
SET (GDB_SIGNAL_PWR, 32, "SIGPWR", "Power fail/restart")
/* Similar to SIGIO. Perhaps they should have the same number. */
SET (GDB_SIGNAL_POLL, 33, "SIGPOLL", "Pollable event occurred")
SET (GDB_SIGNAL_WIND, 34, "SIGWIND", "SIGWIND")
SET (GDB_SIGNAL_PHONE, 35, "SIGPHONE", "SIGPHONE")
SET (GDB_SIGNAL_WAITING, 36, "SIGWAITING", "Process's LWPs are blocked")
SET (GDB_SIGNAL_LWP, 37, "SIGLWP", "Signal LWP")
SET (GDB_SIGNAL_DANGER, 38, "SIGDANGER", "Swap space dangerously low")
SET (GDB_SIGNAL_GRANT, 39, "SIGGRANT", "Monitor mode granted")
SET (GDB_SIGNAL_RETRACT, 40, "SIGRETRACT",
"Need to relinquish monitor mode")
SET (GDB_SIGNAL_MSG, 41, "SIGMSG", "Monitor mode data available")
SET (GDB_SIGNAL_SOUND, 42, "SIGSOUND", "Sound completed")
SET (GDB_SIGNAL_SAK, 43, "SIGSAK", "Secure attention")
SET (GDB_SIGNAL_PRIO, 44, "SIGPRIO", "SIGPRIO")
SET (GDB_SIGNAL_REALTIME_33, 45, "SIG33", "Real-time event 33")
SET (GDB_SIGNAL_REALTIME_34, 46, "SIG34", "Real-time event 34")
SET (GDB_SIGNAL_REALTIME_35, 47, "SIG35", "Real-time event 35")
SET (GDB_SIGNAL_REALTIME_36, 48, "SIG36", "Real-time event 36")
SET (GDB_SIGNAL_REALTIME_37, 49, "SIG37", "Real-time event 37")
SET (GDB_SIGNAL_REALTIME_38, 50, "SIG38", "Real-time event 38")
SET (GDB_SIGNAL_REALTIME_39, 51, "SIG39", "Real-time event 39")
SET (GDB_SIGNAL_REALTIME_40, 52, "SIG40", "Real-time event 40")
SET (GDB_SIGNAL_REALTIME_41, 53, "SIG41", "Real-time event 41")
SET (GDB_SIGNAL_REALTIME_42, 54, "SIG42", "Real-time event 42")
SET (GDB_SIGNAL_REALTIME_43, 55, "SIG43", "Real-time event 43")
SET (GDB_SIGNAL_REALTIME_44, 56, "SIG44", "Real-time event 44")
SET (GDB_SIGNAL_REALTIME_45, 57, "SIG45", "Real-time event 45")
SET (GDB_SIGNAL_REALTIME_46, 58, "SIG46", "Real-time event 46")
SET (GDB_SIGNAL_REALTIME_47, 59, "SIG47", "Real-time event 47")
SET (GDB_SIGNAL_REALTIME_48, 60, "SIG48", "Real-time event 48")
SET (GDB_SIGNAL_REALTIME_49, 61, "SIG49", "Real-time event 49")
SET (GDB_SIGNAL_REALTIME_50, 62, "SIG50", "Real-time event 50")
SET (GDB_SIGNAL_REALTIME_51, 63, "SIG51", "Real-time event 51")
SET (GDB_SIGNAL_REALTIME_52, 64, "SIG52", "Real-time event 52")
SET (GDB_SIGNAL_REALTIME_53, 65, "SIG53", "Real-time event 53")
SET (GDB_SIGNAL_REALTIME_54, 66, "SIG54", "Real-time event 54")
SET (GDB_SIGNAL_REALTIME_55, 67, "SIG55", "Real-time event 55")
SET (GDB_SIGNAL_REALTIME_56, 68, "SIG56", "Real-time event 56")
SET (GDB_SIGNAL_REALTIME_57, 69, "SIG57", "Real-time event 57")
SET (GDB_SIGNAL_REALTIME_58, 70, "SIG58", "Real-time event 58")
SET (GDB_SIGNAL_REALTIME_59, 71, "SIG59", "Real-time event 59")
SET (GDB_SIGNAL_REALTIME_60, 72, "SIG60", "Real-time event 60")
SET (GDB_SIGNAL_REALTIME_61, 73, "SIG61", "Real-time event 61")
SET (GDB_SIGNAL_REALTIME_62, 74, "SIG62", "Real-time event 62")
SET (GDB_SIGNAL_REALTIME_63, 75, "SIG63", "Real-time event 63")
/* Used internally by Solaris threads. See signal(5) on Solaris. */
SET (GDB_SIGNAL_CANCEL, 76, "SIGCANCEL", "LWP internal signal")
/* Yes, this pains me, too. But LynxOS didn't have SIG32, and now
GNU/Linux does, and we can't disturb the numbering, since it's
part of the remote protocol. Note that in some GDB's
GDB_SIGNAL_REALTIME_32 is number 76. */
SET (GDB_SIGNAL_REALTIME_32, 77, "SIG32", "Real-time event 32")
/* Yet another pain, IRIX 6 has SIG64. */
SET (GDB_SIGNAL_REALTIME_64, 78, "SIG64", "Real-time event 64")
/* Yet another pain, GNU/Linux MIPS might go up to 128. */
SET (GDB_SIGNAL_REALTIME_65, 79, "SIG65", "Real-time event 65")
SET (GDB_SIGNAL_REALTIME_66, 80, "SIG66", "Real-time event 66")
SET (GDB_SIGNAL_REALTIME_67, 81, "SIG67", "Real-time event 67")
SET (GDB_SIGNAL_REALTIME_68, 82, "SIG68", "Real-time event 68")
SET (GDB_SIGNAL_REALTIME_69, 83, "SIG69", "Real-time event 69")
SET (GDB_SIGNAL_REALTIME_70, 84, "SIG70", "Real-time event 70")
SET (GDB_SIGNAL_REALTIME_71, 85, "SIG71", "Real-time event 71")
SET (GDB_SIGNAL_REALTIME_72, 86, "SIG72", "Real-time event 72")
SET (GDB_SIGNAL_REALTIME_73, 87, "SIG73", "Real-time event 73")
SET (GDB_SIGNAL_REALTIME_74, 88, "SIG74", "Real-time event 74")
SET (GDB_SIGNAL_REALTIME_75, 89, "SIG75", "Real-time event 75")
SET (GDB_SIGNAL_REALTIME_76, 90, "SIG76", "Real-time event 76")
SET (GDB_SIGNAL_REALTIME_77, 91, "SIG77", "Real-time event 77")
SET (GDB_SIGNAL_REALTIME_78, 92, "SIG78", "Real-time event 78")
SET (GDB_SIGNAL_REALTIME_79, 93, "SIG79", "Real-time event 79")
SET (GDB_SIGNAL_REALTIME_80, 94, "SIG80", "Real-time event 80")
SET (GDB_SIGNAL_REALTIME_81, 95, "SIG81", "Real-time event 81")
SET (GDB_SIGNAL_REALTIME_82, 96, "SIG82", "Real-time event 82")
SET (GDB_SIGNAL_REALTIME_83, 97, "SIG83", "Real-time event 83")
SET (GDB_SIGNAL_REALTIME_84, 98, "SIG84", "Real-time event 84")
SET (GDB_SIGNAL_REALTIME_85, 99, "SIG85", "Real-time event 85")
SET (GDB_SIGNAL_REALTIME_86, 100, "SIG86", "Real-time event 86")
SET (GDB_SIGNAL_REALTIME_87, 101, "SIG87", "Real-time event 87")
SET (GDB_SIGNAL_REALTIME_88, 102, "SIG88", "Real-time event 88")
SET (GDB_SIGNAL_REALTIME_89, 103, "SIG89", "Real-time event 89")
SET (GDB_SIGNAL_REALTIME_90, 104, "SIG90", "Real-time event 90")
SET (GDB_SIGNAL_REALTIME_91, 105, "SIG91", "Real-time event 91")
SET (GDB_SIGNAL_REALTIME_92, 106, "SIG92", "Real-time event 92")
SET (GDB_SIGNAL_REALTIME_93, 107, "SIG93", "Real-time event 93")
SET (GDB_SIGNAL_REALTIME_94, 108, "SIG94", "Real-time event 94")
SET (GDB_SIGNAL_REALTIME_95, 109, "SIG95", "Real-time event 95")
SET (GDB_SIGNAL_REALTIME_96, 110, "SIG96", "Real-time event 96")
SET (GDB_SIGNAL_REALTIME_97, 111, "SIG97", "Real-time event 97")
SET (GDB_SIGNAL_REALTIME_98, 112, "SIG98", "Real-time event 98")
SET (GDB_SIGNAL_REALTIME_99, 113, "SIG99", "Real-time event 99")
SET (GDB_SIGNAL_REALTIME_100, 114, "SIG100", "Real-time event 100")
SET (GDB_SIGNAL_REALTIME_101, 115, "SIG101", "Real-time event 101")
SET (GDB_SIGNAL_REALTIME_102, 116, "SIG102", "Real-time event 102")
SET (GDB_SIGNAL_REALTIME_103, 117, "SIG103", "Real-time event 103")
SET (GDB_SIGNAL_REALTIME_104, 118, "SIG104", "Real-time event 104")
SET (GDB_SIGNAL_REALTIME_105, 119, "SIG105", "Real-time event 105")
SET (GDB_SIGNAL_REALTIME_106, 120, "SIG106", "Real-time event 106")
SET (GDB_SIGNAL_REALTIME_107, 121, "SIG107", "Real-time event 107")
SET (GDB_SIGNAL_REALTIME_108, 122, "SIG108", "Real-time event 108")
SET (GDB_SIGNAL_REALTIME_109, 123, "SIG109", "Real-time event 109")
SET (GDB_SIGNAL_REALTIME_110, 124, "SIG110", "Real-time event 110")
SET (GDB_SIGNAL_REALTIME_111, 125, "SIG111", "Real-time event 111")
SET (GDB_SIGNAL_REALTIME_112, 126, "SIG112", "Real-time event 112")
SET (GDB_SIGNAL_REALTIME_113, 127, "SIG113", "Real-time event 113")
SET (GDB_SIGNAL_REALTIME_114, 128, "SIG114", "Real-time event 114")
SET (GDB_SIGNAL_REALTIME_115, 129, "SIG115", "Real-time event 115")
SET (GDB_SIGNAL_REALTIME_116, 130, "SIG116", "Real-time event 116")
SET (GDB_SIGNAL_REALTIME_117, 131, "SIG117", "Real-time event 117")
SET (GDB_SIGNAL_REALTIME_118, 132, "SIG118", "Real-time event 118")
SET (GDB_SIGNAL_REALTIME_119, 133, "SIG119", "Real-time event 119")
SET (GDB_SIGNAL_REALTIME_120, 134, "SIG120", "Real-time event 120")
SET (GDB_SIGNAL_REALTIME_121, 135, "SIG121", "Real-time event 121")
SET (GDB_SIGNAL_REALTIME_122, 136, "SIG122", "Real-time event 122")
SET (GDB_SIGNAL_REALTIME_123, 137, "SIG123", "Real-time event 123")
SET (GDB_SIGNAL_REALTIME_124, 138, "SIG124", "Real-time event 124")
SET (GDB_SIGNAL_REALTIME_125, 139, "SIG125", "Real-time event 125")
SET (GDB_SIGNAL_REALTIME_126, 140, "SIG126", "Real-time event 126")
SET (GDB_SIGNAL_REALTIME_127, 141, "SIG127", "Real-time event 127")
SET (GDB_SIGNAL_INFO, 142, "SIGINFO", "Information request")
/* Some signal we don't know about. */
SET (GDB_SIGNAL_UNKNOWN, 143, NULL, "Unknown signal")
/* Use whatever signal we use when one is not specifically specified
(for passing to proceed and so on). */
SET (GDB_SIGNAL_DEFAULT, 144, NULL,
"Internal error: printing GDB_SIGNAL_DEFAULT")
/* Mach exceptions. In versions of GDB before 5.2, these were just before
GDB_SIGNAL_INFO if you were compiling on a Mach host (and missing
otherwise). */
SET (GDB_EXC_BAD_ACCESS, 145, "EXC_BAD_ACCESS", "Could not access memory")
SET (GDB_EXC_BAD_INSTRUCTION, 146, "EXC_BAD_INSTRUCTION",
"Illegal instruction/operand")
SET (GDB_EXC_ARITHMETIC, 147, "EXC_ARITHMETIC", "Arithmetic exception")
SET (GDB_EXC_EMULATION, 148, "EXC_EMULATION", "Emulation instruction")
SET (GDB_EXC_SOFTWARE, 149, "EXC_SOFTWARE", "Software generated exception")
SET (GDB_EXC_BREAKPOINT, 150, "EXC_BREAKPOINT", "Breakpoint")
/* If you are adding a new signal, add it just above this comment. */
/* Last and unused enum value, for sizing arrays, etc. */
SET (GDB_SIGNAL_LAST, 151, NULL, "GDB_SIGNAL_LAST")

58
android/toolchain/binutils/binutils-2.25/include/gdb/signals.h Normal file
View file

@ -0,0 +1,58 @@
/* Target signal numbers for GDB and the GDB remote protocol.
Copyright (C) 1986-2014 Free Software Foundation, Inc.
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/>. */
#ifndef GDB_SIGNALS_H
#define GDB_SIGNALS_H
/* The numbering of these signals is chosen to match traditional unix
signals (insofar as various unices use the same numbers, anyway).
It is also the numbering of the GDB remote protocol. Other remote
protocols, if they use a different numbering, should make sure to
translate appropriately.
Since these numbers have actually made it out into other software
(stubs, etc.), you mustn't disturb the assigned numbering. If you
need to add new signals here, add them to the end of the explicitly
numbered signals, at the comment marker. Add them unconditionally,
not within any #if or #ifdef.
This is based strongly on Unix/POSIX signals for several reasons:
(1) This set of signals represents a widely-accepted attempt to
represent events of this sort in a portable fashion, (2) we want a
signal to make it from wait to child_wait to the user intact, (3) many
remote protocols use a similar encoding. However, it is
recognized that this set of signals has limitations (such as not
distinguishing between various kinds of SIGSEGV, or not
distinguishing hitting a breakpoint from finishing a single step).
So in the future we may get around this either by adding additional
signals for breakpoint, single-step, etc., or by adding signal
codes; the latter seems more in the spirit of what BSD, System V,
etc. are doing to address these issues. */
/* For an explanation of what each signal means, see
gdb_signal_to_string. */
enum gdb_signal
{
#define SET(symbol, constant, name, string) \
symbol = constant,
#include "gdb/signals.def"
#undef SET
};
#endif /* #ifndef GDB_SIGNALS_H */

112
android/toolchain/binutils/binutils-2.25/include/gdb/sim-arm.h Normal file
View file

@ -0,0 +1,112 @@
/* This file defines the interface between the Arm simulator and GDB.
Copyright (C) 2002-2014 Free Software Foundation, Inc.
Contributed by Red Hat.
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/>. */
#if !defined (SIM_ARM_H)
#define SIM_ARM_H
#ifdef __cplusplus
extern "C" { // }
#endif
enum sim_arm_regs
{
SIM_ARM_R0_REGNUM,
SIM_ARM_R1_REGNUM,
SIM_ARM_R2_REGNUM,
SIM_ARM_R3_REGNUM,
SIM_ARM_R4_REGNUM,
SIM_ARM_R5_REGNUM,
SIM_ARM_R6_REGNUM,
SIM_ARM_R7_REGNUM,
SIM_ARM_R8_REGNUM,
SIM_ARM_R9_REGNUM,
SIM_ARM_R10_REGNUM,
SIM_ARM_R11_REGNUM,
SIM_ARM_R12_REGNUM,
SIM_ARM_R13_REGNUM,
SIM_ARM_R14_REGNUM,
SIM_ARM_R15_REGNUM, /* PC */
SIM_ARM_FP0_REGNUM,
SIM_ARM_FP1_REGNUM,
SIM_ARM_FP2_REGNUM,
SIM_ARM_FP3_REGNUM,
SIM_ARM_FP4_REGNUM,
SIM_ARM_FP5_REGNUM,
SIM_ARM_FP6_REGNUM,
SIM_ARM_FP7_REGNUM,
SIM_ARM_FPS_REGNUM,
SIM_ARM_PS_REGNUM,
SIM_ARM_MAVERIC_COP0R0_REGNUM,
SIM_ARM_MAVERIC_COP0R1_REGNUM,
SIM_ARM_MAVERIC_COP0R2_REGNUM,
SIM_ARM_MAVERIC_COP0R3_REGNUM,
SIM_ARM_MAVERIC_COP0R4_REGNUM,
SIM_ARM_MAVERIC_COP0R5_REGNUM,
SIM_ARM_MAVERIC_COP0R6_REGNUM,
SIM_ARM_MAVERIC_COP0R7_REGNUM,
SIM_ARM_MAVERIC_COP0R8_REGNUM,
SIM_ARM_MAVERIC_COP0R9_REGNUM,
SIM_ARM_MAVERIC_COP0R10_REGNUM,
SIM_ARM_MAVERIC_COP0R11_REGNUM,
SIM_ARM_MAVERIC_COP0R12_REGNUM,
SIM_ARM_MAVERIC_COP0R13_REGNUM,
SIM_ARM_MAVERIC_COP0R14_REGNUM,
SIM_ARM_MAVERIC_COP0R15_REGNUM,
SIM_ARM_MAVERIC_DSPSC_REGNUM,
SIM_ARM_IWMMXT_COP0R0_REGNUM,
SIM_ARM_IWMMXT_COP0R1_REGNUM,
SIM_ARM_IWMMXT_COP0R2_REGNUM,
SIM_ARM_IWMMXT_COP0R3_REGNUM,
SIM_ARM_IWMMXT_COP0R4_REGNUM,
SIM_ARM_IWMMXT_COP0R5_REGNUM,
SIM_ARM_IWMMXT_COP0R6_REGNUM,
SIM_ARM_IWMMXT_COP0R7_REGNUM,
SIM_ARM_IWMMXT_COP0R8_REGNUM,
SIM_ARM_IWMMXT_COP0R9_REGNUM,
SIM_ARM_IWMMXT_COP0R10_REGNUM,
SIM_ARM_IWMMXT_COP0R11_REGNUM,
SIM_ARM_IWMMXT_COP0R12_REGNUM,
SIM_ARM_IWMMXT_COP0R13_REGNUM,
SIM_ARM_IWMMXT_COP0R14_REGNUM,
SIM_ARM_IWMMXT_COP0R15_REGNUM,
SIM_ARM_IWMMXT_COP1R0_REGNUM,
SIM_ARM_IWMMXT_COP1R1_REGNUM,
SIM_ARM_IWMMXT_COP1R2_REGNUM,
SIM_ARM_IWMMXT_COP1R3_REGNUM,
SIM_ARM_IWMMXT_COP1R4_REGNUM,
SIM_ARM_IWMMXT_COP1R5_REGNUM,
SIM_ARM_IWMMXT_COP1R6_REGNUM,
SIM_ARM_IWMMXT_COP1R7_REGNUM,
SIM_ARM_IWMMXT_COP1R8_REGNUM,
SIM_ARM_IWMMXT_COP1R9_REGNUM,
SIM_ARM_IWMMXT_COP1R10_REGNUM,
SIM_ARM_IWMMXT_COP1R11_REGNUM,
SIM_ARM_IWMMXT_COP1R12_REGNUM,
SIM_ARM_IWMMXT_COP1R13_REGNUM,
SIM_ARM_IWMMXT_COP1R14_REGNUM,
SIM_ARM_IWMMXT_COP1R15_REGNUM
};
#ifdef __cplusplus
}
#endif
#endif

82
android/toolchain/binutils/binutils-2.25/include/gdb/sim-bfin.h Normal file
View file

@ -0,0 +1,82 @@
/* This file defines the interface between the Blackfin simulator and GDB.
Copyright (C) 2005-2014 Free Software Foundation, Inc.
Contributed by Analog Devices.
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/>. */
enum sim_bfin_regnum {
SIM_BFIN_R0_REGNUM = 0,
SIM_BFIN_R1_REGNUM,
SIM_BFIN_R2_REGNUM,
SIM_BFIN_R3_REGNUM,
SIM_BFIN_R4_REGNUM,
SIM_BFIN_R5_REGNUM,
SIM_BFIN_R6_REGNUM,
SIM_BFIN_R7_REGNUM,
SIM_BFIN_P0_REGNUM,
SIM_BFIN_P1_REGNUM,
SIM_BFIN_P2_REGNUM,
SIM_BFIN_P3_REGNUM,
SIM_BFIN_P4_REGNUM,
SIM_BFIN_P5_REGNUM,
SIM_BFIN_SP_REGNUM,
SIM_BFIN_FP_REGNUM,
SIM_BFIN_I0_REGNUM,
SIM_BFIN_I1_REGNUM,
SIM_BFIN_I2_REGNUM,
SIM_BFIN_I3_REGNUM,
SIM_BFIN_M0_REGNUM,
SIM_BFIN_M1_REGNUM,
SIM_BFIN_M2_REGNUM,
SIM_BFIN_M3_REGNUM,
SIM_BFIN_B0_REGNUM,
SIM_BFIN_B1_REGNUM,
SIM_BFIN_B2_REGNUM,
SIM_BFIN_B3_REGNUM,
SIM_BFIN_L0_REGNUM,
SIM_BFIN_L1_REGNUM,
SIM_BFIN_L2_REGNUM,
SIM_BFIN_L3_REGNUM,
SIM_BFIN_A0_DOT_X_REGNUM,
SIM_BFIN_A0_DOT_W_REGNUM,
SIM_BFIN_A1_DOT_X_REGNUM,
SIM_BFIN_A1_DOT_W_REGNUM,
SIM_BFIN_ASTAT_REGNUM,
SIM_BFIN_RETS_REGNUM,
SIM_BFIN_LC0_REGNUM,
SIM_BFIN_LT0_REGNUM,
SIM_BFIN_LB0_REGNUM,
SIM_BFIN_LC1_REGNUM,
SIM_BFIN_LT1_REGNUM,
SIM_BFIN_LB1_REGNUM,
SIM_BFIN_CYCLES_REGNUM,
SIM_BFIN_CYCLES2_REGNUM,
SIM_BFIN_USP_REGNUM,
SIM_BFIN_SEQSTAT_REGNUM,
SIM_BFIN_SYSCFG_REGNUM,
SIM_BFIN_RETI_REGNUM,
SIM_BFIN_RETX_REGNUM,
SIM_BFIN_RETN_REGNUM,
SIM_BFIN_RETE_REGNUM,
SIM_BFIN_PC_REGNUM,
SIM_BFIN_CC_REGNUM,
SIM_BFIN_TEXT_ADDR,
SIM_BFIN_TEXT_END_ADDR,
SIM_BFIN_DATA_ADDR,
SIM_BFIN_IPEND_REGNUM
};

106
android/toolchain/binutils/binutils-2.25/include/gdb/sim-cr16.h Normal file
View file

@ -0,0 +1,106 @@
/* This file defines the interface between the cr16 simulator and gdb.
Copyright (C) 2008-2014 Free Software Foundation, Inc.
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/>. */
#if !defined (SIM_CR16_H)
#define SIM_CR16_H
#ifdef __cplusplus
extern "C" { // }
#endif
enum
{
SIM_CR16_MEMORY_UNIFIED = 0x00000000,
SIM_CR16_MEMORY_INSN = 0x10000000,
SIM_CR16_MEMORY_DATA = 0x10000000,
SIM_CR16_MEMORY_DMAP = 0x10000000,
SIM_CR16_MEMORY_IMAP = 0x10000000
};
extern unsigned long sim_cr16_translate_dmap_addr
(unsigned long offset,
int nr_bytes,
unsigned long *phys,
void *regcache,
unsigned long (*dmap_register) (void *regcache, int reg_nr));
extern unsigned long sim_cr16_translate_imap_addr
(unsigned long offset,
int nr_bytes,
unsigned long *phys,
void *regcache,
unsigned long (*imap_register) (void *regcache, int reg_nr));
extern unsigned long sim_cr16_translate_addr
(unsigned long vaddr,
int nr_bytes,
unsigned long *phys,
void *regcache,
unsigned long (*dmap_register) (void *regcache, int reg_nr),
unsigned long (*imap_register) (void *regcache, int reg_nr));
/* The simulator makes use of the following register information. */
enum sim_cr16_regs
{
SIM_CR16_R0_REGNUM,
SIM_CR16_R1_REGNUM,
SIM_CR16_R2_REGNUM,
SIM_CR16_R3_REGNUM,
SIM_CR16_R4_REGNUM,
SIM_CR16_R5_REGNUM,
SIM_CR16_R6_REGNUM,
SIM_CR16_R7_REGNUM,
SIM_CR16_R8_REGNUM,
SIM_CR16_R9_REGNUM,
SIM_CR16_R10_REGNUM,
SIM_CR16_R11_REGNUM,
SIM_CR16_R12_REGNUM,
SIM_CR16_R13_REGNUM,
SIM_CR16_R14_REGNUM,
SIM_CR16_R15_REGNUM,
SIM_CR16_PC_REGNUM,
SIM_CR16_ISP_REGNUM,
SIM_CR16_USP_REGNUM,
SIM_CR16_INTBASE_REGNUM,
SIM_CR16_PSR_REGNUM,
SIM_CR16_CFG_REGNUM,
SIM_CR16_DBS_REGNUM,
SIM_CR16_DCR_REGNUM,
SIM_CR16_DSR_REGNUM,
SIM_CR16_CAR0_REGNUM,
SIM_CR16_CAR1_REGNUM
};
enum
{
SIM_CR16_NR_R_REGS = 16,
SIM_CR16_NR_A_REGS = 2,
SIM_CR16_NR_IMAP_REGS = 2,
SIM_CR16_NR_DMAP_REGS = 4,
SIM_CR16_NR_CR_REGS = 11
};
#ifdef __cplusplus
}
#endif
#endif

141
android/toolchain/binutils/binutils-2.25/include/gdb/sim-d10v.h Normal file
View file

@ -0,0 +1,141 @@
/* This file defines the interface between the d10v simulator and gdb.
Copyright (C) 1999-2014 Free Software Foundation, Inc.
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/>. */
#if !defined (SIM_D10V_H)
#define SIM_D10V_H
#ifdef __cplusplus
extern "C" { // }
#endif
/* GDB interprets addresses as:
0x00xxxxxx: Physical unified memory segment (Unified memory)
0x01xxxxxx: Physical instruction memory segment (On-chip insn memory)
0x02xxxxxx: Physical data memory segment (On-chip data memory)
0x10xxxxxx: Logical data address segment (DMAP translated memory)
0x11xxxxxx: Logical instruction address segment (IMAP translated memory)
The remote d10v board interprets addresses as:
0x00xxxxxx: Physical unified memory segment (Unified memory)
0x01xxxxxx: Physical instruction memory segment (On-chip insn memory)
0x02xxxxxx: Physical data memory segment (On-chip data memory)
The following translate a virtual DMAP/IMAP offset into a physical
memory segment assigning the translated address to PHYS. Since a
memory access may cross a page boundrary the number of bytes for
which the translation is applicable (or 0 for an invalid virtual
offset) is returned. */
enum
{
SIM_D10V_MEMORY_UNIFIED = 0x00000000,
SIM_D10V_MEMORY_INSN = 0x01000000,
SIM_D10V_MEMORY_DATA = 0x02000000,
SIM_D10V_MEMORY_DMAP = 0x10000000,
SIM_D10V_MEMORY_IMAP = 0x11000000
};
extern unsigned long sim_d10v_translate_dmap_addr
(unsigned long offset,
int nr_bytes,
unsigned long *phys,
void *regcache,
unsigned long (*dmap_register) (void *regcache, int reg_nr));
extern unsigned long sim_d10v_translate_imap_addr
(unsigned long offset,
int nr_bytes,
unsigned long *phys,
void *regcache,
unsigned long (*imap_register) (void *regcache, int reg_nr));
extern unsigned long sim_d10v_translate_addr
(unsigned long vaddr,
int nr_bytes,
unsigned long *phys,
void *regcache,
unsigned long (*dmap_register) (void *regcache, int reg_nr),
unsigned long (*imap_register) (void *regcache, int reg_nr));
/* The simulator makes use of the following register information. */
enum sim_d10v_regs
{
SIM_D10V_R0_REGNUM,
SIM_D10V_R1_REGNUM,
SIM_D10V_R2_REGNUM,
SIM_D10V_R3_REGNUM,
SIM_D10V_R4_REGNUM,
SIM_D10V_R5_REGNUM,
SIM_D10V_R6_REGNUM,
SIM_D10V_R7_REGNUM,
SIM_D10V_R8_REGNUM,
SIM_D10V_R9_REGNUM,
SIM_D10V_R10_REGNUM,
SIM_D10V_R11_REGNUM,
SIM_D10V_R12_REGNUM,
SIM_D10V_R13_REGNUM,
SIM_D10V_R14_REGNUM,
SIM_D10V_R15_REGNUM,
SIM_D10V_CR0_REGNUM,
SIM_D10V_CR1_REGNUM,
SIM_D10V_CR2_REGNUM,
SIM_D10V_CR3_REGNUM,
SIM_D10V_CR4_REGNUM,
SIM_D10V_CR5_REGNUM,
SIM_D10V_CR6_REGNUM,
SIM_D10V_CR7_REGNUM,
SIM_D10V_CR8_REGNUM,
SIM_D10V_CR9_REGNUM,
SIM_D10V_CR10_REGNUM,
SIM_D10V_CR11_REGNUM,
SIM_D10V_CR12_REGNUM,
SIM_D10V_CR13_REGNUM,
SIM_D10V_CR14_REGNUM,
SIM_D10V_CR15_REGNUM,
SIM_D10V_A0_REGNUM,
SIM_D10V_A1_REGNUM,
SIM_D10V_SPI_REGNUM,
SIM_D10V_SPU_REGNUM,
SIM_D10V_IMAP0_REGNUM,
SIM_D10V_IMAP1_REGNUM,
SIM_D10V_DMAP0_REGNUM,
SIM_D10V_DMAP1_REGNUM,
SIM_D10V_DMAP2_REGNUM,
SIM_D10V_DMAP3_REGNUM,
SIM_D10V_TS2_DMAP_REGNUM
};
enum
{
SIM_D10V_NR_R_REGS = 16,
SIM_D10V_NR_A_REGS = 2,
SIM_D10V_NR_IMAP_REGS = 2,
SIM_D10V_NR_DMAP_REGS = 4,
SIM_D10V_NR_CR_REGS = 16
};
#ifdef __cplusplus
}
#endif
#endif

51
android/toolchain/binutils/binutils-2.25/include/gdb/sim-frv.h Normal file
View file

@ -0,0 +1,51 @@
/* This file defines the interface between the FR-V simulator and GDB.
Copyright (C) 2003-2014 Free Software Foundation, Inc.
Contributed by Red Hat.
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/>. */
#if !defined (SIM_FRV_H)
#define SIM_FRV_H
#ifdef __cplusplus
extern "C" { // }
#endif
enum sim_frv_regs
{
SIM_FRV_GR0_REGNUM = 0,
SIM_FRV_GR63_REGNUM = 63,
SIM_FRV_FR0_REGNUM = 64,
SIM_FRV_FR63_REGNUM = 127,
SIM_FRV_PC_REGNUM = 128,
/* An FR-V architecture may have up to 4096 special purpose registers
(SPRs). In order to determine a specific constant used to access
a particular SPR, one of the H_SPR_ prefixed offsets defined in
opcodes/frv-desc.h should be added to SIM_FRV_SPR0_REGNUM. So,
for example, the number that GDB uses to fetch the link register
from the simulator is (SIM_FRV_SPR0_REGNUM + H_SPR_LR). */
SIM_FRV_SPR0_REGNUM = 129,
SIM_FRV_SPR4095_REGNUM = SIM_FRV_SPR0_REGNUM + 4095
};
#ifdef __cplusplus
}
#endif
#endif

77
android/toolchain/binutils/binutils-2.25/include/gdb/sim-h8300.h Normal file
View file

@ -0,0 +1,77 @@
/* This file defines the interface between the h8300 simulator and gdb.
Copyright (C) 2002-2014 Free Software Foundation, Inc.
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/>. */
#if !defined (SIM_H8300_H)
#define SIM_H8300_H
#ifdef __cplusplus
extern "C" { //}
#endif
/* The simulator makes use of the following register information. */
enum sim_h8300_regs
{
/* Registers common to all the H8 variants. */
/* Start here: */
SIM_H8300_R0_REGNUM,
SIM_H8300_R1_REGNUM,
SIM_H8300_R2_REGNUM,
SIM_H8300_R3_REGNUM,
SIM_H8300_R4_REGNUM,
SIM_H8300_R5_REGNUM,
SIM_H8300_R6_REGNUM,
SIM_H8300_R7_REGNUM,
SIM_H8300_CCR_REGNUM, /* Contains processor status */
SIM_H8300_PC_REGNUM, /* Contains program counter */
/* End here */
SIM_H8300_EXR_REGNUM, /* Contains extended processor status
H8S and higher */
SIM_H8300_MACL_REGNUM, /* Lower part of MAC register (26xx only)*/
SIM_H8300_MACH_REGNUM, /* High part of MAC register (26xx only) */
SIM_H8300_CYCLE_REGNUM,
SIM_H8300_INST_REGNUM,
SIM_H8300_TICK_REGNUM
};
enum
{
SIM_H8300_ARG_FIRST_REGNUM = SIM_H8300_R0_REGNUM, /* first reg in which an arg
may be passed */
SIM_H8300_ARG_LAST_REGNUM = SIM_H8300_R3_REGNUM, /* last reg in which an arg
may be passed */
SIM_H8300_FP_REGNUM = SIM_H8300_R6_REGNUM, /* Contain address of executing
stack frame */
SIM_H8300_SP_REGNUM = SIM_H8300_R7_REGNUM /* Contains address of top of stack */
};
enum
{
SIM_H8300_NUM_COMMON_REGS = 10,
SIM_H8300_S_NUM_REGS = 13,
SIM_H8300_NUM_REGS = 16
};
#ifdef __cplusplus
}
#endif
#endif /* SIM_H8300_H */

76
android/toolchain/binutils/binutils-2.25/include/gdb/sim-lm32.h Normal file
View file

@ -0,0 +1,76 @@
/* This file defines the interface between the LM32 simulator and GDB.
Contributed by Jon Beniston <jon@beniston.com>
Copyright (C) 2009-2014 Free Software Foundation, Inc.
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/>. */
#ifndef SIM_LM32_H
#define SIM_LM32_H
#ifdef __cplusplus
extern "C" { // }
#endif
enum sim_lm32_regs
{
SIM_LM32_R0_REGNUM,
SIM_LM32_R1_REGNUM,
SIM_LM32_R2_REGNUM,
SIM_LM32_R3_REGNUM,
SIM_LM32_R4_REGNUM,
SIM_LM32_R5_REGNUM,
SIM_LM32_R6_REGNUM,
SIM_LM32_R7_REGNUM,
SIM_LM32_R8_REGNUM,
SIM_LM32_R9_REGNUM,
SIM_LM32_R10_REGNUM,
SIM_LM32_R11_REGNUM,
SIM_LM32_R12_REGNUM,
SIM_LM32_R13_REGNUM,
SIM_LM32_R14_REGNUM,
SIM_LM32_R15_REGNUM,
SIM_LM32_R16_REGNUM,
SIM_LM32_R17_REGNUM,
SIM_LM32_R18_REGNUM,
SIM_LM32_R19_REGNUM,
SIM_LM32_R20_REGNUM,
SIM_LM32_R21_REGNUM,
SIM_LM32_R22_REGNUM,
SIM_LM32_R23_REGNUM,
SIM_LM32_R24_REGNUM,
SIM_LM32_R25_REGNUM,
SIM_LM32_GP_REGNUM,
SIM_LM32_FP_REGNUM,
SIM_LM32_SP_REGNUM,
SIM_LM32_RA_REGNUM,
SIM_LM32_BA_REGNUM,
SIM_LM32_EA_REGNUM,
SIM_LM32_PC_REGNUM,
SIM_LM32_EID_REGNUM,
SIM_LM32_EBA_REGNUM,
SIM_LM32_DEBA_REGNUM,
SIM_LM32_IE_REGNUM,
SIM_LM32_IM_REGNUM,
SIM_LM32_IP_REGNUM,
SIM_LM32_NUM_REGS
};
#ifdef __cplusplus
}
#endif
#endif

62
android/toolchain/binutils/binutils-2.25/include/gdb/sim-m32c.h Normal file
View file

@ -0,0 +1,62 @@
/* This file defines the interface between the m32c simulator and gdb.
Copyright (C) 2005-2014 Free Software Foundation, Inc.
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/>. */
#ifndef SIM_M32C_H
#define SIM_M32C_H
enum m32c_sim_reg {
m32c_sim_reg_r0_bank0,
m32c_sim_reg_r1_bank0,
m32c_sim_reg_r2_bank0,
m32c_sim_reg_r3_bank0,
m32c_sim_reg_a0_bank0,
m32c_sim_reg_a1_bank0,
m32c_sim_reg_fb_bank0,
m32c_sim_reg_sb_bank0,
m32c_sim_reg_r0_bank1,
m32c_sim_reg_r1_bank1,
m32c_sim_reg_r2_bank1,
m32c_sim_reg_r3_bank1,
m32c_sim_reg_a0_bank1,
m32c_sim_reg_a1_bank1,
m32c_sim_reg_fb_bank1,
m32c_sim_reg_sb_bank1,
m32c_sim_reg_usp,
m32c_sim_reg_isp,
m32c_sim_reg_pc,
m32c_sim_reg_intb,
m32c_sim_reg_flg,
m32c_sim_reg_svf,
m32c_sim_reg_svp,
m32c_sim_reg_vct,
m32c_sim_reg_dmd0,
m32c_sim_reg_dmd1,
m32c_sim_reg_dct0,
m32c_sim_reg_dct1,
m32c_sim_reg_drc0,
m32c_sim_reg_drc1,
m32c_sim_reg_dma0,
m32c_sim_reg_dma1,
m32c_sim_reg_dsa0,
m32c_sim_reg_dsa1,
m32c_sim_reg_dra0,
m32c_sim_reg_dra1,
m32c_sim_reg_num_regs
};
#endif /* SIM_M32C_H */

773
android/toolchain/binutils/binutils-2.25/include/gdb/sim-ppc.h Normal file
View file

@ -0,0 +1,773 @@
/* sim-ppc.h --- interface between PowerPC simulator and GDB.
Copyright (C) 2004-2014 Free Software Foundation, Inc.
Contributed by Red Hat.
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/>. */
#if !defined (SIM_PPC_H)
#define SIM_PPC_H
#ifdef __cplusplus
extern "C" {
#endif
/* The register access functions, sim_fetch_register and
sim_store_register, use the following numbering for PowerPC
registers. */
enum sim_ppc_regnum
{
/* General-purpose registers, r0 -- r31. */
sim_ppc_r0_regnum,
sim_ppc_r1_regnum,
sim_ppc_r2_regnum,
sim_ppc_r3_regnum,
sim_ppc_r4_regnum,
sim_ppc_r5_regnum,
sim_ppc_r6_regnum,
sim_ppc_r7_regnum,
sim_ppc_r8_regnum,
sim_ppc_r9_regnum,
sim_ppc_r10_regnum,
sim_ppc_r11_regnum,
sim_ppc_r12_regnum,
sim_ppc_r13_regnum,
sim_ppc_r14_regnum,
sim_ppc_r15_regnum,
sim_ppc_r16_regnum,
sim_ppc_r17_regnum,
sim_ppc_r18_regnum,
sim_ppc_r19_regnum,
sim_ppc_r20_regnum,
sim_ppc_r21_regnum,
sim_ppc_r22_regnum,
sim_ppc_r23_regnum,
sim_ppc_r24_regnum,
sim_ppc_r25_regnum,
sim_ppc_r26_regnum,
sim_ppc_r27_regnum,
sim_ppc_r28_regnum,
sim_ppc_r29_regnum,
sim_ppc_r30_regnum,
sim_ppc_r31_regnum,
/* Floating-point registers, f0 -- f31. */
sim_ppc_f0_regnum,
sim_ppc_f1_regnum,
sim_ppc_f2_regnum,
sim_ppc_f3_regnum,
sim_ppc_f4_regnum,
sim_ppc_f5_regnum,
sim_ppc_f6_regnum,
sim_ppc_f7_regnum,
sim_ppc_f8_regnum,
sim_ppc_f9_regnum,
sim_ppc_f10_regnum,
sim_ppc_f11_regnum,
sim_ppc_f12_regnum,
sim_ppc_f13_regnum,
sim_ppc_f14_regnum,
sim_ppc_f15_regnum,
sim_ppc_f16_regnum,
sim_ppc_f17_regnum,
sim_ppc_f18_regnum,
sim_ppc_f19_regnum,
sim_ppc_f20_regnum,
sim_ppc_f21_regnum,
sim_ppc_f22_regnum,
sim_ppc_f23_regnum,
sim_ppc_f24_regnum,
sim_ppc_f25_regnum,
sim_ppc_f26_regnum,
sim_ppc_f27_regnum,
sim_ppc_f28_regnum,
sim_ppc_f29_regnum,
sim_ppc_f30_regnum,
sim_ppc_f31_regnum,
/* Altivec vector registers, vr0 -- vr31. */
sim_ppc_vr0_regnum,
sim_ppc_vr1_regnum,
sim_ppc_vr2_regnum,
sim_ppc_vr3_regnum,
sim_ppc_vr4_regnum,
sim_ppc_vr5_regnum,
sim_ppc_vr6_regnum,
sim_ppc_vr7_regnum,
sim_ppc_vr8_regnum,
sim_ppc_vr9_regnum,
sim_ppc_vr10_regnum,
sim_ppc_vr11_regnum,
sim_ppc_vr12_regnum,
sim_ppc_vr13_regnum,
sim_ppc_vr14_regnum,
sim_ppc_vr15_regnum,
sim_ppc_vr16_regnum,
sim_ppc_vr17_regnum,
sim_ppc_vr18_regnum,
sim_ppc_vr19_regnum,
sim_ppc_vr20_regnum,
sim_ppc_vr21_regnum,
sim_ppc_vr22_regnum,
sim_ppc_vr23_regnum,
sim_ppc_vr24_regnum,
sim_ppc_vr25_regnum,
sim_ppc_vr26_regnum,
sim_ppc_vr27_regnum,
sim_ppc_vr28_regnum,
sim_ppc_vr29_regnum,
sim_ppc_vr30_regnum,
sim_ppc_vr31_regnum,
/* SPE APU GPR upper halves. These are the upper 32 bits of the
gprs; there is one upper-half register for each gpr, so it is
appropriate to use sim_ppc_num_gprs for iterating through
these. */
sim_ppc_rh0_regnum,
sim_ppc_rh1_regnum,
sim_ppc_rh2_regnum,
sim_ppc_rh3_regnum,
sim_ppc_rh4_regnum,
sim_ppc_rh5_regnum,
sim_ppc_rh6_regnum,
sim_ppc_rh7_regnum,
sim_ppc_rh8_regnum,
sim_ppc_rh9_regnum,
sim_ppc_rh10_regnum,
sim_ppc_rh11_regnum,
sim_ppc_rh12_regnum,
sim_ppc_rh13_regnum,
sim_ppc_rh14_regnum,
sim_ppc_rh15_regnum,
sim_ppc_rh16_regnum,
sim_ppc_rh17_regnum,
sim_ppc_rh18_regnum,
sim_ppc_rh19_regnum,
sim_ppc_rh20_regnum,
sim_ppc_rh21_regnum,
sim_ppc_rh22_regnum,
sim_ppc_rh23_regnum,
sim_ppc_rh24_regnum,
sim_ppc_rh25_regnum,
sim_ppc_rh26_regnum,
sim_ppc_rh27_regnum,
sim_ppc_rh28_regnum,
sim_ppc_rh29_regnum,
sim_ppc_rh30_regnum,
sim_ppc_rh31_regnum,
/* SPE APU GPR full registers. Each of these registers is the
64-bit concatenation of a 32-bit GPR (providing the lower bits)
and a 32-bit upper-half register (providing the higher bits).
As for the upper-half registers, it is appropriate to use
sim_ppc_num_gprs with these. */
sim_ppc_ev0_regnum,
sim_ppc_ev1_regnum,
sim_ppc_ev2_regnum,
sim_ppc_ev3_regnum,
sim_ppc_ev4_regnum,
sim_ppc_ev5_regnum,
sim_ppc_ev6_regnum,
sim_ppc_ev7_regnum,
sim_ppc_ev8_regnum,
sim_ppc_ev9_regnum,
sim_ppc_ev10_regnum,
sim_ppc_ev11_regnum,
sim_ppc_ev12_regnum,
sim_ppc_ev13_regnum,
sim_ppc_ev14_regnum,
sim_ppc_ev15_regnum,
sim_ppc_ev16_regnum,
sim_ppc_ev17_regnum,
sim_ppc_ev18_regnum,
sim_ppc_ev19_regnum,
sim_ppc_ev20_regnum,
sim_ppc_ev21_regnum,
sim_ppc_ev22_regnum,
sim_ppc_ev23_regnum,
sim_ppc_ev24_regnum,
sim_ppc_ev25_regnum,
sim_ppc_ev26_regnum,
sim_ppc_ev27_regnum,
sim_ppc_ev28_regnum,
sim_ppc_ev29_regnum,
sim_ppc_ev30_regnum,
sim_ppc_ev31_regnum,
/* Segment registers, sr0 -- sr15. */
sim_ppc_sr0_regnum,
sim_ppc_sr1_regnum,
sim_ppc_sr2_regnum,
sim_ppc_sr3_regnum,
sim_ppc_sr4_regnum,
sim_ppc_sr5_regnum,
sim_ppc_sr6_regnum,
sim_ppc_sr7_regnum,
sim_ppc_sr8_regnum,
sim_ppc_sr9_regnum,
sim_ppc_sr10_regnum,
sim_ppc_sr11_regnum,
sim_ppc_sr12_regnum,
sim_ppc_sr13_regnum,
sim_ppc_sr14_regnum,
sim_ppc_sr15_regnum,
/* Miscellaneous --- but non-SPR --- registers. */
sim_ppc_pc_regnum,
sim_ppc_ps_regnum,
sim_ppc_cr_regnum,
sim_ppc_fpscr_regnum,
sim_ppc_acc_regnum,
sim_ppc_vscr_regnum,
/* Special-purpose registers. */
sim_ppc_spr0_regnum, sim_ppc_spr1_regnum,
sim_ppc_spr2_regnum, sim_ppc_spr3_regnum,
sim_ppc_spr4_regnum, sim_ppc_spr5_regnum,
sim_ppc_spr6_regnum, sim_ppc_spr7_regnum,
sim_ppc_spr8_regnum, sim_ppc_spr9_regnum,
sim_ppc_spr10_regnum, sim_ppc_spr11_regnum,
sim_ppc_spr12_regnum, sim_ppc_spr13_regnum,
sim_ppc_spr14_regnum, sim_ppc_spr15_regnum,
sim_ppc_spr16_regnum, sim_ppc_spr17_regnum,
sim_ppc_spr18_regnum, sim_ppc_spr19_regnum,
sim_ppc_spr20_regnum, sim_ppc_spr21_regnum,
sim_ppc_spr22_regnum, sim_ppc_spr23_regnum,
sim_ppc_spr24_regnum, sim_ppc_spr25_regnum,
sim_ppc_spr26_regnum, sim_ppc_spr27_regnum,
sim_ppc_spr28_regnum, sim_ppc_spr29_regnum,
sim_ppc_spr30_regnum, sim_ppc_spr31_regnum,
sim_ppc_spr32_regnum, sim_ppc_spr33_regnum,
sim_ppc_spr34_regnum, sim_ppc_spr35_regnum,
sim_ppc_spr36_regnum, sim_ppc_spr37_regnum,
sim_ppc_spr38_regnum, sim_ppc_spr39_regnum,
sim_ppc_spr40_regnum, sim_ppc_spr41_regnum,
sim_ppc_spr42_regnum, sim_ppc_spr43_regnum,
sim_ppc_spr44_regnum, sim_ppc_spr45_regnum,
sim_ppc_spr46_regnum, sim_ppc_spr47_regnum,
sim_ppc_spr48_regnum, sim_ppc_spr49_regnum,
sim_ppc_spr50_regnum, sim_ppc_spr51_regnum,
sim_ppc_spr52_regnum, sim_ppc_spr53_regnum,
sim_ppc_spr54_regnum, sim_ppc_spr55_regnum,
sim_ppc_spr56_regnum, sim_ppc_spr57_regnum,
sim_ppc_spr58_regnum, sim_ppc_spr59_regnum,
sim_ppc_spr60_regnum, sim_ppc_spr61_regnum,
sim_ppc_spr62_regnum, sim_ppc_spr63_regnum,
sim_ppc_spr64_regnum, sim_ppc_spr65_regnum,
sim_ppc_spr66_regnum, sim_ppc_spr67_regnum,
sim_ppc_spr68_regnum, sim_ppc_spr69_regnum,
sim_ppc_spr70_regnum, sim_ppc_spr71_regnum,
sim_ppc_spr72_regnum, sim_ppc_spr73_regnum,
sim_ppc_spr74_regnum, sim_ppc_spr75_regnum,
sim_ppc_spr76_regnum, sim_ppc_spr77_regnum,
sim_ppc_spr78_regnum, sim_ppc_spr79_regnum,
sim_ppc_spr80_regnum, sim_ppc_spr81_regnum,
sim_ppc_spr82_regnum, sim_ppc_spr83_regnum,
sim_ppc_spr84_regnum, sim_ppc_spr85_regnum,
sim_ppc_spr86_regnum, sim_ppc_spr87_regnum,
sim_ppc_spr88_regnum, sim_ppc_spr89_regnum,
sim_ppc_spr90_regnum, sim_ppc_spr91_regnum,
sim_ppc_spr92_regnum, sim_ppc_spr93_regnum,
sim_ppc_spr94_regnum, sim_ppc_spr95_regnum,
sim_ppc_spr96_regnum, sim_ppc_spr97_regnum,
sim_ppc_spr98_regnum, sim_ppc_spr99_regnum,
sim_ppc_spr100_regnum, sim_ppc_spr101_regnum,
sim_ppc_spr102_regnum, sim_ppc_spr103_regnum,
sim_ppc_spr104_regnum, sim_ppc_spr105_regnum,
sim_ppc_spr106_regnum, sim_ppc_spr107_regnum,
sim_ppc_spr108_regnum, sim_ppc_spr109_regnum,
sim_ppc_spr110_regnum, sim_ppc_spr111_regnum,
sim_ppc_spr112_regnum, sim_ppc_spr113_regnum,
sim_ppc_spr114_regnum, sim_ppc_spr115_regnum,
sim_ppc_spr116_regnum, sim_ppc_spr117_regnum,
sim_ppc_spr118_regnum, sim_ppc_spr119_regnum,
sim_ppc_spr120_regnum, sim_ppc_spr121_regnum,
sim_ppc_spr122_regnum, sim_ppc_spr123_regnum,
sim_ppc_spr124_regnum, sim_ppc_spr125_regnum,
sim_ppc_spr126_regnum, sim_ppc_spr127_regnum,
sim_ppc_spr128_regnum, sim_ppc_spr129_regnum,
sim_ppc_spr130_regnum, sim_ppc_spr131_regnum,
sim_ppc_spr132_regnum, sim_ppc_spr133_regnum,
sim_ppc_spr134_regnum, sim_ppc_spr135_regnum,
sim_ppc_spr136_regnum, sim_ppc_spr137_regnum,
sim_ppc_spr138_regnum, sim_ppc_spr139_regnum,
sim_ppc_spr140_regnum, sim_ppc_spr141_regnum,
sim_ppc_spr142_regnum, sim_ppc_spr143_regnum,
sim_ppc_spr144_regnum, sim_ppc_spr145_regnum,
sim_ppc_spr146_regnum, sim_ppc_spr147_regnum,
sim_ppc_spr148_regnum, sim_ppc_spr149_regnum,
sim_ppc_spr150_regnum, sim_ppc_spr151_regnum,
sim_ppc_spr152_regnum, sim_ppc_spr153_regnum,
sim_ppc_spr154_regnum, sim_ppc_spr155_regnum,
sim_ppc_spr156_regnum, sim_ppc_spr157_regnum,
sim_ppc_spr158_regnum, sim_ppc_spr159_regnum,
sim_ppc_spr160_regnum, sim_ppc_spr161_regnum,
sim_ppc_spr162_regnum, sim_ppc_spr163_regnum,
sim_ppc_spr164_regnum, sim_ppc_spr165_regnum,
sim_ppc_spr166_regnum, sim_ppc_spr167_regnum,
sim_ppc_spr168_regnum, sim_ppc_spr169_regnum,
sim_ppc_spr170_regnum, sim_ppc_spr171_regnum,
sim_ppc_spr172_regnum, sim_ppc_spr173_regnum,
sim_ppc_spr174_regnum, sim_ppc_spr175_regnum,
sim_ppc_spr176_regnum, sim_ppc_spr177_regnum,
sim_ppc_spr178_regnum, sim_ppc_spr179_regnum,
sim_ppc_spr180_regnum, sim_ppc_spr181_regnum,
sim_ppc_spr182_regnum, sim_ppc_spr183_regnum,
sim_ppc_spr184_regnum, sim_ppc_spr185_regnum,
sim_ppc_spr186_regnum, sim_ppc_spr187_regnum,
sim_ppc_spr188_regnum, sim_ppc_spr189_regnum,
sim_ppc_spr190_regnum, sim_ppc_spr191_regnum,
sim_ppc_spr192_regnum, sim_ppc_spr193_regnum,
sim_ppc_spr194_regnum, sim_ppc_spr195_regnum,
sim_ppc_spr196_regnum, sim_ppc_spr197_regnum,
sim_ppc_spr198_regnum, sim_ppc_spr199_regnum,
sim_ppc_spr200_regnum, sim_ppc_spr201_regnum,
sim_ppc_spr202_regnum, sim_ppc_spr203_regnum,
sim_ppc_spr204_regnum, sim_ppc_spr205_regnum,
sim_ppc_spr206_regnum, sim_ppc_spr207_regnum,
sim_ppc_spr208_regnum, sim_ppc_spr209_regnum,
sim_ppc_spr210_regnum, sim_ppc_spr211_regnum,
sim_ppc_spr212_regnum, sim_ppc_spr213_regnum,
sim_ppc_spr214_regnum, sim_ppc_spr215_regnum,
sim_ppc_spr216_regnum, sim_ppc_spr217_regnum,
sim_ppc_spr218_regnum, sim_ppc_spr219_regnum,
sim_ppc_spr220_regnum, sim_ppc_spr221_regnum,
sim_ppc_spr222_regnum, sim_ppc_spr223_regnum,
sim_ppc_spr224_regnum, sim_ppc_spr225_regnum,
sim_ppc_spr226_regnum, sim_ppc_spr227_regnum,
sim_ppc_spr228_regnum, sim_ppc_spr229_regnum,
sim_ppc_spr230_regnum, sim_ppc_spr231_regnum,
sim_ppc_spr232_regnum, sim_ppc_spr233_regnum,
sim_ppc_spr234_regnum, sim_ppc_spr235_regnum,
sim_ppc_spr236_regnum, sim_ppc_spr237_regnum,
sim_ppc_spr238_regnum, sim_ppc_spr239_regnum,
sim_ppc_spr240_regnum, sim_ppc_spr241_regnum,
sim_ppc_spr242_regnum, sim_ppc_spr243_regnum,
sim_ppc_spr244_regnum, sim_ppc_spr245_regnum,
sim_ppc_spr246_regnum, sim_ppc_spr247_regnum,
sim_ppc_spr248_regnum, sim_ppc_spr249_regnum,
sim_ppc_spr250_regnum, sim_ppc_spr251_regnum,
sim_ppc_spr252_regnum, sim_ppc_spr253_regnum,
sim_ppc_spr254_regnum, sim_ppc_spr255_regnum,
sim_ppc_spr256_regnum, sim_ppc_spr257_regnum,
sim_ppc_spr258_regnum, sim_ppc_spr259_regnum,
sim_ppc_spr260_regnum, sim_ppc_spr261_regnum,
sim_ppc_spr262_regnum, sim_ppc_spr263_regnum,
sim_ppc_spr264_regnum, sim_ppc_spr265_regnum,
sim_ppc_spr266_regnum, sim_ppc_spr267_regnum,
sim_ppc_spr268_regnum, sim_ppc_spr269_regnum,
sim_ppc_spr270_regnum, sim_ppc_spr271_regnum,
sim_ppc_spr272_regnum, sim_ppc_spr273_regnum,
sim_ppc_spr274_regnum, sim_ppc_spr275_regnum,
sim_ppc_spr276_regnum, sim_ppc_spr277_regnum,
sim_ppc_spr278_regnum, sim_ppc_spr279_regnum,
sim_ppc_spr280_regnum, sim_ppc_spr281_regnum,
sim_ppc_spr282_regnum, sim_ppc_spr283_regnum,
sim_ppc_spr284_regnum, sim_ppc_spr285_regnum,
sim_ppc_spr286_regnum, sim_ppc_spr287_regnum,
sim_ppc_spr288_regnum, sim_ppc_spr289_regnum,
sim_ppc_spr290_regnum, sim_ppc_spr291_regnum,
sim_ppc_spr292_regnum, sim_ppc_spr293_regnum,
sim_ppc_spr294_regnum, sim_ppc_spr295_regnum,
sim_ppc_spr296_regnum, sim_ppc_spr297_regnum,
sim_ppc_spr298_regnum, sim_ppc_spr299_regnum,
sim_ppc_spr300_regnum, sim_ppc_spr301_regnum,
sim_ppc_spr302_regnum, sim_ppc_spr303_regnum,
sim_ppc_spr304_regnum, sim_ppc_spr305_regnum,
sim_ppc_spr306_regnum, sim_ppc_spr307_regnum,
sim_ppc_spr308_regnum, sim_ppc_spr309_regnum,
sim_ppc_spr310_regnum, sim_ppc_spr311_regnum,
sim_ppc_spr312_regnum, sim_ppc_spr313_regnum,
sim_ppc_spr314_regnum, sim_ppc_spr315_regnum,
sim_ppc_spr316_regnum, sim_ppc_spr317_regnum,
sim_ppc_spr318_regnum, sim_ppc_spr319_regnum,
sim_ppc_spr320_regnum, sim_ppc_spr321_regnum,
sim_ppc_spr322_regnum, sim_ppc_spr323_regnum,
sim_ppc_spr324_regnum, sim_ppc_spr325_regnum,
sim_ppc_spr326_regnum, sim_ppc_spr327_regnum,
sim_ppc_spr328_regnum, sim_ppc_spr329_regnum,
sim_ppc_spr330_regnum, sim_ppc_spr331_regnum,
sim_ppc_spr332_regnum, sim_ppc_spr333_regnum,
sim_ppc_spr334_regnum, sim_ppc_spr335_regnum,
sim_ppc_spr336_regnum, sim_ppc_spr337_regnum,
sim_ppc_spr338_regnum, sim_ppc_spr339_regnum,
sim_ppc_spr340_regnum, sim_ppc_spr341_regnum,
sim_ppc_spr342_regnum, sim_ppc_spr343_regnum,
sim_ppc_spr344_regnum, sim_ppc_spr345_regnum,
sim_ppc_spr346_regnum, sim_ppc_spr347_regnum,
sim_ppc_spr348_regnum, sim_ppc_spr349_regnum,
sim_ppc_spr350_regnum, sim_ppc_spr351_regnum,
sim_ppc_spr352_regnum, sim_ppc_spr353_regnum,
sim_ppc_spr354_regnum, sim_ppc_spr355_regnum,
sim_ppc_spr356_regnum, sim_ppc_spr357_regnum,
sim_ppc_spr358_regnum, sim_ppc_spr359_regnum,
sim_ppc_spr360_regnum, sim_ppc_spr361_regnum,
sim_ppc_spr362_regnum, sim_ppc_spr363_regnum,
sim_ppc_spr364_regnum, sim_ppc_spr365_regnum,
sim_ppc_spr366_regnum, sim_ppc_spr367_regnum,
sim_ppc_spr368_regnum, sim_ppc_spr369_regnum,
sim_ppc_spr370_regnum, sim_ppc_spr371_regnum,
sim_ppc_spr372_regnum, sim_ppc_spr373_regnum,
sim_ppc_spr374_regnum, sim_ppc_spr375_regnum,
sim_ppc_spr376_regnum, sim_ppc_spr377_regnum,
sim_ppc_spr378_regnum, sim_ppc_spr379_regnum,
sim_ppc_spr380_regnum, sim_ppc_spr381_regnum,
sim_ppc_spr382_regnum, sim_ppc_spr383_regnum,
sim_ppc_spr384_regnum, sim_ppc_spr385_regnum,
sim_ppc_spr386_regnum, sim_ppc_spr387_regnum,
sim_ppc_spr388_regnum, sim_ppc_spr389_regnum,
sim_ppc_spr390_regnum, sim_ppc_spr391_regnum,
sim_ppc_spr392_regnum, sim_ppc_spr393_regnum,
sim_ppc_spr394_regnum, sim_ppc_spr395_regnum,
sim_ppc_spr396_regnum, sim_ppc_spr397_regnum,
sim_ppc_spr398_regnum, sim_ppc_spr399_regnum,
sim_ppc_spr400_regnum, sim_ppc_spr401_regnum,
sim_ppc_spr402_regnum, sim_ppc_spr403_regnum,
sim_ppc_spr404_regnum, sim_ppc_spr405_regnum,
sim_ppc_spr406_regnum, sim_ppc_spr407_regnum,
sim_ppc_spr408_regnum, sim_ppc_spr409_regnum,
sim_ppc_spr410_regnum, sim_ppc_spr411_regnum,
sim_ppc_spr412_regnum, sim_ppc_spr413_regnum,
sim_ppc_spr414_regnum, sim_ppc_spr415_regnum,
sim_ppc_spr416_regnum, sim_ppc_spr417_regnum,
sim_ppc_spr418_regnum, sim_ppc_spr419_regnum,
sim_ppc_spr420_regnum, sim_ppc_spr421_regnum,
sim_ppc_spr422_regnum, sim_ppc_spr423_regnum,
sim_ppc_spr424_regnum, sim_ppc_spr425_regnum,
sim_ppc_spr426_regnum, sim_ppc_spr427_regnum,
sim_ppc_spr428_regnum, sim_ppc_spr429_regnum,
sim_ppc_spr430_regnum, sim_ppc_spr431_regnum,
sim_ppc_spr432_regnum, sim_ppc_spr433_regnum,
sim_ppc_spr434_regnum, sim_ppc_spr435_regnum,
sim_ppc_spr436_regnum, sim_ppc_spr437_regnum,
sim_ppc_spr438_regnum, sim_ppc_spr439_regnum,
sim_ppc_spr440_regnum, sim_ppc_spr441_regnum,
sim_ppc_spr442_regnum, sim_ppc_spr443_regnum,
sim_ppc_spr444_regnum, sim_ppc_spr445_regnum,
sim_ppc_spr446_regnum, sim_ppc_spr447_regnum,
sim_ppc_spr448_regnum, sim_ppc_spr449_regnum,
sim_ppc_spr450_regnum, sim_ppc_spr451_regnum,
sim_ppc_spr452_regnum, sim_ppc_spr453_regnum,
sim_ppc_spr454_regnum, sim_ppc_spr455_regnum,
sim_ppc_spr456_regnum, sim_ppc_spr457_regnum,
sim_ppc_spr458_regnum, sim_ppc_spr459_regnum,
sim_ppc_spr460_regnum, sim_ppc_spr461_regnum,
sim_ppc_spr462_regnum, sim_ppc_spr463_regnum,
sim_ppc_spr464_regnum, sim_ppc_spr465_regnum,
sim_ppc_spr466_regnum, sim_ppc_spr467_regnum,
sim_ppc_spr468_regnum, sim_ppc_spr469_regnum,
sim_ppc_spr470_regnum, sim_ppc_spr471_regnum,
sim_ppc_spr472_regnum, sim_ppc_spr473_regnum,
sim_ppc_spr474_regnum, sim_ppc_spr475_regnum,
sim_ppc_spr476_regnum, sim_ppc_spr477_regnum,
sim_ppc_spr478_regnum, sim_ppc_spr479_regnum,
sim_ppc_spr480_regnum, sim_ppc_spr481_regnum,
sim_ppc_spr482_regnum, sim_ppc_spr483_regnum,
sim_ppc_spr484_regnum, sim_ppc_spr485_regnum,
sim_ppc_spr486_regnum, sim_ppc_spr487_regnum,
sim_ppc_spr488_regnum, sim_ppc_spr489_regnum,
sim_ppc_spr490_regnum, sim_ppc_spr491_regnum,
sim_ppc_spr492_regnum, sim_ppc_spr493_regnum,
sim_ppc_spr494_regnum, sim_ppc_spr495_regnum,
sim_ppc_spr496_regnum, sim_ppc_spr497_regnum,
sim_ppc_spr498_regnum, sim_ppc_spr499_regnum,
sim_ppc_spr500_regnum, sim_ppc_spr501_regnum,
sim_ppc_spr502_regnum, sim_ppc_spr503_regnum,
sim_ppc_spr504_regnum, sim_ppc_spr505_regnum,
sim_ppc_spr506_regnum, sim_ppc_spr507_regnum,
sim_ppc_spr508_regnum, sim_ppc_spr509_regnum,
sim_ppc_spr510_regnum, sim_ppc_spr511_regnum,
sim_ppc_spr512_regnum, sim_ppc_spr513_regnum,
sim_ppc_spr514_regnum, sim_ppc_spr515_regnum,
sim_ppc_spr516_regnum, sim_ppc_spr517_regnum,
sim_ppc_spr518_regnum, sim_ppc_spr519_regnum,
sim_ppc_spr520_regnum, sim_ppc_spr521_regnum,
sim_ppc_spr522_regnum, sim_ppc_spr523_regnum,
sim_ppc_spr524_regnum, sim_ppc_spr525_regnum,
sim_ppc_spr526_regnum, sim_ppc_spr527_regnum,
sim_ppc_spr528_regnum, sim_ppc_spr529_regnum,
sim_ppc_spr530_regnum, sim_ppc_spr531_regnum,
sim_ppc_spr532_regnum, sim_ppc_spr533_regnum,
sim_ppc_spr534_regnum, sim_ppc_spr535_regnum,
sim_ppc_spr536_regnum, sim_ppc_spr537_regnum,
sim_ppc_spr538_regnum, sim_ppc_spr539_regnum,
sim_ppc_spr540_regnum, sim_ppc_spr541_regnum,
sim_ppc_spr542_regnum, sim_ppc_spr543_regnum,
sim_ppc_spr544_regnum, sim_ppc_spr545_regnum,
sim_ppc_spr546_regnum, sim_ppc_spr547_regnum,
sim_ppc_spr548_regnum, sim_ppc_spr549_regnum,
sim_ppc_spr550_regnum, sim_ppc_spr551_regnum,
sim_ppc_spr552_regnum, sim_ppc_spr553_regnum,
sim_ppc_spr554_regnum, sim_ppc_spr555_regnum,
sim_ppc_spr556_regnum, sim_ppc_spr557_regnum,
sim_ppc_spr558_regnum, sim_ppc_spr559_regnum,
sim_ppc_spr560_regnum, sim_ppc_spr561_regnum,
sim_ppc_spr562_regnum, sim_ppc_spr563_regnum,
sim_ppc_spr564_regnum, sim_ppc_spr565_regnum,
sim_ppc_spr566_regnum, sim_ppc_spr567_regnum,
sim_ppc_spr568_regnum, sim_ppc_spr569_regnum,
sim_ppc_spr570_regnum, sim_ppc_spr571_regnum,
sim_ppc_spr572_regnum, sim_ppc_spr573_regnum,
sim_ppc_spr574_regnum, sim_ppc_spr575_regnum,
sim_ppc_spr576_regnum, sim_ppc_spr577_regnum,
sim_ppc_spr578_regnum, sim_ppc_spr579_regnum,
sim_ppc_spr580_regnum, sim_ppc_spr581_regnum,
sim_ppc_spr582_regnum, sim_ppc_spr583_regnum,
sim_ppc_spr584_regnum, sim_ppc_spr585_regnum,
sim_ppc_spr586_regnum, sim_ppc_spr587_regnum,
sim_ppc_spr588_regnum, sim_ppc_spr589_regnum,
sim_ppc_spr590_regnum, sim_ppc_spr591_regnum,
sim_ppc_spr592_regnum, sim_ppc_spr593_regnum,
sim_ppc_spr594_regnum, sim_ppc_spr595_regnum,
sim_ppc_spr596_regnum, sim_ppc_spr597_regnum,
sim_ppc_spr598_regnum, sim_ppc_spr599_regnum,
sim_ppc_spr600_regnum, sim_ppc_spr601_regnum,
sim_ppc_spr602_regnum, sim_ppc_spr603_regnum,
sim_ppc_spr604_regnum, sim_ppc_spr605_regnum,
sim_ppc_spr606_regnum, sim_ppc_spr607_regnum,
sim_ppc_spr608_regnum, sim_ppc_spr609_regnum,
sim_ppc_spr610_regnum, sim_ppc_spr611_regnum,
sim_ppc_spr612_regnum, sim_ppc_spr613_regnum,
sim_ppc_spr614_regnum, sim_ppc_spr615_regnum,
sim_ppc_spr616_regnum, sim_ppc_spr617_regnum,
sim_ppc_spr618_regnum, sim_ppc_spr619_regnum,
sim_ppc_spr620_regnum, sim_ppc_spr621_regnum,
sim_ppc_spr622_regnum, sim_ppc_spr623_regnum,
sim_ppc_spr624_regnum, sim_ppc_spr625_regnum,
sim_ppc_spr626_regnum, sim_ppc_spr627_regnum,
sim_ppc_spr628_regnum, sim_ppc_spr629_regnum,
sim_ppc_spr630_regnum, sim_ppc_spr631_regnum,
sim_ppc_spr632_regnum, sim_ppc_spr633_regnum,
sim_ppc_spr634_regnum, sim_ppc_spr635_regnum,
sim_ppc_spr636_regnum, sim_ppc_spr637_regnum,
sim_ppc_spr638_regnum, sim_ppc_spr639_regnum,
sim_ppc_spr640_regnum, sim_ppc_spr641_regnum,
sim_ppc_spr642_regnum, sim_ppc_spr643_regnum,
sim_ppc_spr644_regnum, sim_ppc_spr645_regnum,
sim_ppc_spr646_regnum, sim_ppc_spr647_regnum,
sim_ppc_spr648_regnum, sim_ppc_spr649_regnum,
sim_ppc_spr650_regnum, sim_ppc_spr651_regnum,
sim_ppc_spr652_regnum, sim_ppc_spr653_regnum,
sim_ppc_spr654_regnum, sim_ppc_spr655_regnum,
sim_ppc_spr656_regnum, sim_ppc_spr657_regnum,
sim_ppc_spr658_regnum, sim_ppc_spr659_regnum,
sim_ppc_spr660_regnum, sim_ppc_spr661_regnum,
sim_ppc_spr662_regnum, sim_ppc_spr663_regnum,
sim_ppc_spr664_regnum, sim_ppc_spr665_regnum,
sim_ppc_spr666_regnum, sim_ppc_spr667_regnum,
sim_ppc_spr668_regnum, sim_ppc_spr669_regnum,
sim_ppc_spr670_regnum, sim_ppc_spr671_regnum,
sim_ppc_spr672_regnum, sim_ppc_spr673_regnum,
sim_ppc_spr674_regnum, sim_ppc_spr675_regnum,
sim_ppc_spr676_regnum, sim_ppc_spr677_regnum,
sim_ppc_spr678_regnum, sim_ppc_spr679_regnum,
sim_ppc_spr680_regnum, sim_ppc_spr681_regnum,
sim_ppc_spr682_regnum, sim_ppc_spr683_regnum,
sim_ppc_spr684_regnum, sim_ppc_spr685_regnum,
sim_ppc_spr686_regnum, sim_ppc_spr687_regnum,
sim_ppc_spr688_regnum, sim_ppc_spr689_regnum,
sim_ppc_spr690_regnum, sim_ppc_spr691_regnum,
sim_ppc_spr692_regnum, sim_ppc_spr693_regnum,
sim_ppc_spr694_regnum, sim_ppc_spr695_regnum,
sim_ppc_spr696_regnum, sim_ppc_spr697_regnum,
sim_ppc_spr698_regnum, sim_ppc_spr699_regnum,
sim_ppc_spr700_regnum, sim_ppc_spr701_regnum,
sim_ppc_spr702_regnum, sim_ppc_spr703_regnum,
sim_ppc_spr704_regnum, sim_ppc_spr705_regnum,
sim_ppc_spr706_regnum, sim_ppc_spr707_regnum,
sim_ppc_spr708_regnum, sim_ppc_spr709_regnum,
sim_ppc_spr710_regnum, sim_ppc_spr711_regnum,
sim_ppc_spr712_regnum, sim_ppc_spr713_regnum,
sim_ppc_spr714_regnum, sim_ppc_spr715_regnum,
sim_ppc_spr716_regnum, sim_ppc_spr717_regnum,
sim_ppc_spr718_regnum, sim_ppc_spr719_regnum,
sim_ppc_spr720_regnum, sim_ppc_spr721_regnum,
sim_ppc_spr722_regnum, sim_ppc_spr723_regnum,
sim_ppc_spr724_regnum, sim_ppc_spr725_regnum,
sim_ppc_spr726_regnum, sim_ppc_spr727_regnum,
sim_ppc_spr728_regnum, sim_ppc_spr729_regnum,
sim_ppc_spr730_regnum, sim_ppc_spr731_regnum,
sim_ppc_spr732_regnum, sim_ppc_spr733_regnum,
sim_ppc_spr734_regnum, sim_ppc_spr735_regnum,
sim_ppc_spr736_regnum, sim_ppc_spr737_regnum,
sim_ppc_spr738_regnum, sim_ppc_spr739_regnum,
sim_ppc_spr740_regnum, sim_ppc_spr741_regnum,
sim_ppc_spr742_regnum, sim_ppc_spr743_regnum,
sim_ppc_spr744_regnum, sim_ppc_spr745_regnum,
sim_ppc_spr746_regnum, sim_ppc_spr747_regnum,
sim_ppc_spr748_regnum, sim_ppc_spr749_regnum,
sim_ppc_spr750_regnum, sim_ppc_spr751_regnum,
sim_ppc_spr752_regnum, sim_ppc_spr753_regnum,
sim_ppc_spr754_regnum, sim_ppc_spr755_regnum,
sim_ppc_spr756_regnum, sim_ppc_spr757_regnum,
sim_ppc_spr758_regnum, sim_ppc_spr759_regnum,
sim_ppc_spr760_regnum, sim_ppc_spr761_regnum,
sim_ppc_spr762_regnum, sim_ppc_spr763_regnum,
sim_ppc_spr764_regnum, sim_ppc_spr765_regnum,
sim_ppc_spr766_regnum, sim_ppc_spr767_regnum,
sim_ppc_spr768_regnum, sim_ppc_spr769_regnum,
sim_ppc_spr770_regnum, sim_ppc_spr771_regnum,
sim_ppc_spr772_regnum, sim_ppc_spr773_regnum,
sim_ppc_spr774_regnum, sim_ppc_spr775_regnum,
sim_ppc_spr776_regnum, sim_ppc_spr777_regnum,
sim_ppc_spr778_regnum, sim_ppc_spr779_regnum,
sim_ppc_spr780_regnum, sim_ppc_spr781_regnum,
sim_ppc_spr782_regnum, sim_ppc_spr783_regnum,
sim_ppc_spr784_regnum, sim_ppc_spr785_regnum,
sim_ppc_spr786_regnum, sim_ppc_spr787_regnum,
sim_ppc_spr788_regnum, sim_ppc_spr789_regnum,
sim_ppc_spr790_regnum, sim_ppc_spr791_regnum,
sim_ppc_spr792_regnum, sim_ppc_spr793_regnum,
sim_ppc_spr794_regnum, sim_ppc_spr795_regnum,
sim_ppc_spr796_regnum, sim_ppc_spr797_regnum,
sim_ppc_spr798_regnum, sim_ppc_spr799_regnum,
sim_ppc_spr800_regnum, sim_ppc_spr801_regnum,
sim_ppc_spr802_regnum, sim_ppc_spr803_regnum,
sim_ppc_spr804_regnum, sim_ppc_spr805_regnum,
sim_ppc_spr806_regnum, sim_ppc_spr807_regnum,
sim_ppc_spr808_regnum, sim_ppc_spr809_regnum,
sim_ppc_spr810_regnum, sim_ppc_spr811_regnum,
sim_ppc_spr812_regnum, sim_ppc_spr813_regnum,
sim_ppc_spr814_regnum, sim_ppc_spr815_regnum,
sim_ppc_spr816_regnum, sim_ppc_spr817_regnum,
sim_ppc_spr818_regnum, sim_ppc_spr819_regnum,
sim_ppc_spr820_regnum, sim_ppc_spr821_regnum,
sim_ppc_spr822_regnum, sim_ppc_spr823_regnum,
sim_ppc_spr824_regnum, sim_ppc_spr825_regnum,
sim_ppc_spr826_regnum, sim_ppc_spr827_regnum,
sim_ppc_spr828_regnum, sim_ppc_spr829_regnum,
sim_ppc_spr830_regnum, sim_ppc_spr831_regnum,
sim_ppc_spr832_regnum, sim_ppc_spr833_regnum,
sim_ppc_spr834_regnum, sim_ppc_spr835_regnum,
sim_ppc_spr836_regnum, sim_ppc_spr837_regnum,
sim_ppc_spr838_regnum, sim_ppc_spr839_regnum,
sim_ppc_spr840_regnum, sim_ppc_spr841_regnum,
sim_ppc_spr842_regnum, sim_ppc_spr843_regnum,
sim_ppc_spr844_regnum, sim_ppc_spr845_regnum,
sim_ppc_spr846_regnum, sim_ppc_spr847_regnum,
sim_ppc_spr848_regnum, sim_ppc_spr849_regnum,
sim_ppc_spr850_regnum, sim_ppc_spr851_regnum,
sim_ppc_spr852_regnum, sim_ppc_spr853_regnum,
sim_ppc_spr854_regnum, sim_ppc_spr855_regnum,
sim_ppc_spr856_regnum, sim_ppc_spr857_regnum,
sim_ppc_spr858_regnum, sim_ppc_spr859_regnum,
sim_ppc_spr860_regnum, sim_ppc_spr861_regnum,
sim_ppc_spr862_regnum, sim_ppc_spr863_regnum,
sim_ppc_spr864_regnum, sim_ppc_spr865_regnum,
sim_ppc_spr866_regnum, sim_ppc_spr867_regnum,
sim_ppc_spr868_regnum, sim_ppc_spr869_regnum,
sim_ppc_spr870_regnum, sim_ppc_spr871_regnum,
sim_ppc_spr872_regnum, sim_ppc_spr873_regnum,
sim_ppc_spr874_regnum, sim_ppc_spr875_regnum,
sim_ppc_spr876_regnum, sim_ppc_spr877_regnum,
sim_ppc_spr878_regnum, sim_ppc_spr879_regnum,
sim_ppc_spr880_regnum, sim_ppc_spr881_regnum,
sim_ppc_spr882_regnum, sim_ppc_spr883_regnum,
sim_ppc_spr884_regnum, sim_ppc_spr885_regnum,
sim_ppc_spr886_regnum, sim_ppc_spr887_regnum,
sim_ppc_spr888_regnum, sim_ppc_spr889_regnum,
sim_ppc_spr890_regnum, sim_ppc_spr891_regnum,
sim_ppc_spr892_regnum, sim_ppc_spr893_regnum,
sim_ppc_spr894_regnum, sim_ppc_spr895_regnum,
sim_ppc_spr896_regnum, sim_ppc_spr897_regnum,
sim_ppc_spr898_regnum, sim_ppc_spr899_regnum,
sim_ppc_spr900_regnum, sim_ppc_spr901_regnum,
sim_ppc_spr902_regnum, sim_ppc_spr903_regnum,
sim_ppc_spr904_regnum, sim_ppc_spr905_regnum,
sim_ppc_spr906_regnum, sim_ppc_spr907_regnum,
sim_ppc_spr908_regnum, sim_ppc_spr909_regnum,
sim_ppc_spr910_regnum, sim_ppc_spr911_regnum,
sim_ppc_spr912_regnum, sim_ppc_spr913_regnum,
sim_ppc_spr914_regnum, sim_ppc_spr915_regnum,
sim_ppc_spr916_regnum, sim_ppc_spr917_regnum,
sim_ppc_spr918_regnum, sim_ppc_spr919_regnum,
sim_ppc_spr920_regnum, sim_ppc_spr921_regnum,
sim_ppc_spr922_regnum, sim_ppc_spr923_regnum,
sim_ppc_spr924_regnum, sim_ppc_spr925_regnum,
sim_ppc_spr926_regnum, sim_ppc_spr927_regnum,
sim_ppc_spr928_regnum, sim_ppc_spr929_regnum,
sim_ppc_spr930_regnum, sim_ppc_spr931_regnum,
sim_ppc_spr932_regnum, sim_ppc_spr933_regnum,
sim_ppc_spr934_regnum, sim_ppc_spr935_regnum,
sim_ppc_spr936_regnum, sim_ppc_spr937_regnum,
sim_ppc_spr938_regnum, sim_ppc_spr939_regnum,
sim_ppc_spr940_regnum, sim_ppc_spr941_regnum,
sim_ppc_spr942_regnum, sim_ppc_spr943_regnum,
sim_ppc_spr944_regnum, sim_ppc_spr945_regnum,
sim_ppc_spr946_regnum, sim_ppc_spr947_regnum,
sim_ppc_spr948_regnum, sim_ppc_spr949_regnum,
sim_ppc_spr950_regnum, sim_ppc_spr951_regnum,
sim_ppc_spr952_regnum, sim_ppc_spr953_regnum,
sim_ppc_spr954_regnum, sim_ppc_spr955_regnum,
sim_ppc_spr956_regnum, sim_ppc_spr957_regnum,
sim_ppc_spr958_regnum, sim_ppc_spr959_regnum,
sim_ppc_spr960_regnum, sim_ppc_spr961_regnum,
sim_ppc_spr962_regnum, sim_ppc_spr963_regnum,
sim_ppc_spr964_regnum, sim_ppc_spr965_regnum,
sim_ppc_spr966_regnum, sim_ppc_spr967_regnum,
sim_ppc_spr968_regnum, sim_ppc_spr969_regnum,
sim_ppc_spr970_regnum, sim_ppc_spr971_regnum,
sim_ppc_spr972_regnum, sim_ppc_spr973_regnum,
sim_ppc_spr974_regnum, sim_ppc_spr975_regnum,
sim_ppc_spr976_regnum, sim_ppc_spr977_regnum,
sim_ppc_spr978_regnum, sim_ppc_spr979_regnum,
sim_ppc_spr980_regnum, sim_ppc_spr981_regnum,
sim_ppc_spr982_regnum, sim_ppc_spr983_regnum,
sim_ppc_spr984_regnum, sim_ppc_spr985_regnum,
sim_ppc_spr986_regnum, sim_ppc_spr987_regnum,
sim_ppc_spr988_regnum, sim_ppc_spr989_regnum,
sim_ppc_spr990_regnum, sim_ppc_spr991_regnum,
sim_ppc_spr992_regnum, sim_ppc_spr993_regnum,
sim_ppc_spr994_regnum, sim_ppc_spr995_regnum,
sim_ppc_spr996_regnum, sim_ppc_spr997_regnum,
sim_ppc_spr998_regnum, sim_ppc_spr999_regnum,
sim_ppc_spr1000_regnum, sim_ppc_spr1001_regnum,
sim_ppc_spr1002_regnum, sim_ppc_spr1003_regnum,
sim_ppc_spr1004_regnum, sim_ppc_spr1005_regnum,
sim_ppc_spr1006_regnum, sim_ppc_spr1007_regnum,
sim_ppc_spr1008_regnum, sim_ppc_spr1009_regnum,
sim_ppc_spr1010_regnum, sim_ppc_spr1011_regnum,
sim_ppc_spr1012_regnum, sim_ppc_spr1013_regnum,
sim_ppc_spr1014_regnum, sim_ppc_spr1015_regnum,
sim_ppc_spr1016_regnum, sim_ppc_spr1017_regnum,
sim_ppc_spr1018_regnum, sim_ppc_spr1019_regnum,
sim_ppc_spr1020_regnum, sim_ppc_spr1021_regnum,
sim_ppc_spr1022_regnum, sim_ppc_spr1023_regnum
};
/* Sizes of various register sets. */
enum
{
sim_ppc_num_gprs = 32,
sim_ppc_num_fprs = 32,
sim_ppc_num_vrs = 32,
sim_ppc_num_srs = 16,
sim_ppc_num_sprs = 1024,
};
/* Return the register name for the supplied SPR number if any, or
NULL if none. */
extern const char *sim_spr_register_name (int);
#ifdef __cplusplus
}
#endif
#endif /* SIM_PPC_H */

76
android/toolchain/binutils/binutils-2.25/include/gdb/sim-rl78.h Normal file
View file

@ -0,0 +1,76 @@
/* sim-rx.h --- interface between rl78 simulator and GDB.
Copyright (C) 2011-2014 Free Software Foundation, Inc.
Contributed by Red Hat.
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/>. */
#if !defined (SIM_RL78_H)
#define SIM_RL78_H
enum sim_rl78_regnum
{
sim_rl78_bank0_r0_regnum,
sim_rl78_bank0_r1_regnum,
sim_rl78_bank0_r2_regnum,
sim_rl78_bank0_r3_regnum,
sim_rl78_bank0_r4_regnum,
sim_rl78_bank0_r5_regnum,
sim_rl78_bank0_r6_regnum,
sim_rl78_bank0_r7_regnum,
sim_rl78_bank1_r0_regnum,
sim_rl78_bank1_r1_regnum,
sim_rl78_bank1_r2_regnum,
sim_rl78_bank1_r3_regnum,
sim_rl78_bank1_r4_regnum,
sim_rl78_bank1_r5_regnum,
sim_rl78_bank1_r6_regnum,
sim_rl78_bank1_r7_regnum,
sim_rl78_bank2_r0_regnum,
sim_rl78_bank2_r1_regnum,
sim_rl78_bank2_r2_regnum,
sim_rl78_bank2_r3_regnum,
sim_rl78_bank2_r4_regnum,
sim_rl78_bank2_r5_regnum,
sim_rl78_bank2_r6_regnum,
sim_rl78_bank2_r7_regnum,
sim_rl78_bank3_r0_regnum,
sim_rl78_bank3_r1_regnum,
sim_rl78_bank3_r2_regnum,
sim_rl78_bank3_r3_regnum,
sim_rl78_bank3_r4_regnum,
sim_rl78_bank3_r5_regnum,
sim_rl78_bank3_r6_regnum,
sim_rl78_bank3_r7_regnum,
sim_rl78_psw_regnum,
sim_rl78_es_regnum,
sim_rl78_cs_regnum,
sim_rl78_pc_regnum,
sim_rl78_spl_regnum,
sim_rl78_sph_regnum,
sim_rl78_pmc_regnum,
sim_rl78_mem_regnum,
sim_rl78_num_regs
};
#endif /* SIM_RL78_H */

56
android/toolchain/binutils/binutils-2.25/include/gdb/sim-rx.h Normal file
View file

@ -0,0 +1,56 @@
/* sim-rx.h --- interface between RX simulator and GDB.
Copyright (C) 2008-2014 Free Software Foundation, Inc.
Contributed by Red Hat.
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/>. */
#if !defined (SIM_RX_H)
#define SIM_RX_H
enum sim_rx_regnum
{
sim_rx_r0_regnum,
sim_rx_r1_regnum,
sim_rx_r2_regnum,
sim_rx_r3_regnum,
sim_rx_r4_regnum,
sim_rx_r5_regnum,
sim_rx_r6_regnum,
sim_rx_r7_regnum,
sim_rx_r8_regnum,
sim_rx_r9_regnum,
sim_rx_r10_regnum,
sim_rx_r11_regnum,
sim_rx_r12_regnum,
sim_rx_r13_regnum,
sim_rx_r14_regnum,
sim_rx_r15_regnum,
sim_rx_usp_regnum,
sim_rx_isp_regnum,
sim_rx_ps_regnum,
sim_rx_pc_regnum,
sim_rx_intb_regnum,
sim_rx_bpsw_regnum,
sim_rx_bpc_regnum,
sim_rx_fintv_regnum,
sim_rx_fpsw_regnum,
sim_rx_acc_regnum,
sim_rx_num_regs
};
#endif /* SIM_RX_H */

169
android/toolchain/binutils/binutils-2.25/include/gdb/sim-sh.h Normal file
View file

@ -0,0 +1,169 @@
/* This file defines the interface between the sh simulator and gdb.
Copyright (C) 2000-2014 Free Software Foundation, Inc.
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/>. */
#if !defined (SIM_SH_H)
#define SIM_SH_H
#ifdef __cplusplus
extern "C" { // }
#endif
/* The simulator makes use of the following register information. */
enum
{
SIM_SH_R0_REGNUM = 0,
SIM_SH_R1_REGNUM,
SIM_SH_R2_REGNUM,
SIM_SH_R3_REGNUM,
SIM_SH_R4_REGNUM,
SIM_SH_R5_REGNUM,
SIM_SH_R6_REGNUM,
SIM_SH_R7_REGNUM,
SIM_SH_R8_REGNUM,
SIM_SH_R9_REGNUM,
SIM_SH_R10_REGNUM,
SIM_SH_R11_REGNUM,
SIM_SH_R12_REGNUM,
SIM_SH_R13_REGNUM,
SIM_SH_R14_REGNUM,
SIM_SH_R15_REGNUM,
SIM_SH_PC_REGNUM,
SIM_SH_PR_REGNUM,
SIM_SH_GBR_REGNUM,
SIM_SH_VBR_REGNUM,
SIM_SH_MACH_REGNUM,
SIM_SH_MACL_REGNUM,
SIM_SH_SR_REGNUM,
SIM_SH_FPUL_REGNUM,
SIM_SH_FPSCR_REGNUM,
SIM_SH_FR0_REGNUM, /* FRn registers: sh3e / sh4 */
SIM_SH_FR1_REGNUM,
SIM_SH_FR2_REGNUM,
SIM_SH_FR3_REGNUM,
SIM_SH_FR4_REGNUM,
SIM_SH_FR5_REGNUM,
SIM_SH_FR6_REGNUM,
SIM_SH_FR7_REGNUM,
SIM_SH_FR8_REGNUM,
SIM_SH_FR9_REGNUM,
SIM_SH_FR10_REGNUM,
SIM_SH_FR11_REGNUM,
SIM_SH_FR12_REGNUM,
SIM_SH_FR13_REGNUM,
SIM_SH_FR14_REGNUM,
SIM_SH_FR15_REGNUM,
SIM_SH_SSR_REGNUM, /* sh3{,e,-dsp}, sh4 */
SIM_SH_SPC_REGNUM, /* sh3{,e,-dsp}, sh4 */
SIM_SH_R0_BANK0_REGNUM, /* SIM_SH_Rn_BANKm_REGNUM: sh3[e] / sh4 */
SIM_SH_R1_BANK0_REGNUM,
SIM_SH_R2_BANK0_REGNUM,
SIM_SH_R3_BANK0_REGNUM,
SIM_SH_R4_BANK0_REGNUM,
SIM_SH_R5_BANK0_REGNUM,
SIM_SH_R6_BANK0_REGNUM,
SIM_SH_R7_BANK0_REGNUM,
SIM_SH_R0_BANK1_REGNUM,
SIM_SH_R1_BANK1_REGNUM,
SIM_SH_R2_BANK1_REGNUM,
SIM_SH_R3_BANK1_REGNUM,
SIM_SH_R4_BANK1_REGNUM,
SIM_SH_R5_BANK1_REGNUM,
SIM_SH_R6_BANK1_REGNUM,
SIM_SH_R7_BANK1_REGNUM,
SIM_SH_XF0_REGNUM,
SIM_SH_XF1_REGNUM,
SIM_SH_XF2_REGNUM,
SIM_SH_XF3_REGNUM,
SIM_SH_XF4_REGNUM,
SIM_SH_XF5_REGNUM,
SIM_SH_XF6_REGNUM,
SIM_SH_XF7_REGNUM,
SIM_SH_XF8_REGNUM,
SIM_SH_XF9_REGNUM,
SIM_SH_XF10_REGNUM,
SIM_SH_XF11_REGNUM,
SIM_SH_XF12_REGNUM,
SIM_SH_XF13_REGNUM,
SIM_SH_XF14_REGNUM,
SIM_SH_XF15_REGNUM,
SIM_SH_SGR_REGNUM,
SIM_SH_DBR_REGNUM,
SIM_SH4_NUM_REGS, /* 77 */
/* sh[3]-dsp */
SIM_SH_DSR_REGNUM,
SIM_SH_A0G_REGNUM,
SIM_SH_A0_REGNUM,
SIM_SH_A1G_REGNUM,
SIM_SH_A1_REGNUM,
SIM_SH_M0_REGNUM,
SIM_SH_M1_REGNUM,
SIM_SH_X0_REGNUM,
SIM_SH_X1_REGNUM,
SIM_SH_Y0_REGNUM,
SIM_SH_Y1_REGNUM,
SIM_SH_MOD_REGNUM,
SIM_SH_RS_REGNUM,
SIM_SH_RE_REGNUM,
SIM_SH_R0_BANK_REGNUM,
SIM_SH_R1_BANK_REGNUM,
SIM_SH_R2_BANK_REGNUM,
SIM_SH_R3_BANK_REGNUM,
SIM_SH_R4_BANK_REGNUM,
SIM_SH_R5_BANK_REGNUM,
SIM_SH_R6_BANK_REGNUM,
SIM_SH_R7_BANK_REGNUM,
/* 109..127: room for expansion. */
SIM_SH_TBR_REGNUM,
SIM_SH_IBNR_REGNUM,
SIM_SH_IBCR_REGNUM,
SIM_SH_BANK_REGNUM,
SIM_SH_BANK_MACL_REGNUM,
SIM_SH_BANK_GBR_REGNUM,
SIM_SH_BANK_PR_REGNUM,
SIM_SH_BANK_IVN_REGNUM,
SIM_SH_BANK_MACH_REGNUM
};
enum
{
SIM_SH64_R0_REGNUM = 0,
SIM_SH64_SP_REGNUM = 15,
SIM_SH64_PC_REGNUM = 64,
SIM_SH64_SR_REGNUM = 65,
SIM_SH64_SSR_REGNUM = 66,
SIM_SH64_SPC_REGNUM = 67,
SIM_SH64_TR0_REGNUM = 68,
SIM_SH64_FPCSR_REGNUM = 76,
SIM_SH64_FR0_REGNUM = 77
};
enum
{
SIM_SH64_NR_REGS = 141, /* total number of architectural registers */
SIM_SH64_NR_R_REGS = 64, /* number of general registers */
SIM_SH64_NR_TR_REGS = 8, /* number of target registers */
SIM_SH64_NR_FP_REGS = 64 /* number of floating point registers */
};
#ifdef __cplusplus
}
#endif
#endif