/* Target-dependent code for GNU/Linux AArch64.

Copyright (C) 2009-2016 Free Software Foundation, Inc.

Contributed by ARM Ltd.

This file is part of GDB.

This program is free software; you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation; either version 3 of the License, or

(at your option) any later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program. If not, see <http://www.gnu.org/licenses/>. */

#include "defs.h"

#include "gdbarch.h"

#include "arch-utils.h"

#include "glibc-tdep.h"

#include "linux-tdep.h"

#include "aarch64-tdep.h"

#include "aarch64-linux-tdep.h"

#include "osabi.h"

#include "solib-svr4.h"

#include "symtab.h"

#include "tramp-frame.h"

#include "trad-frame.h"

#include "inferior.h"

#include "regcache.h"

#include "regset.h"

#include "cli/cli-utils.h"

#include "stap-probe.h"

#include "parser-defs.h"

#include "user-regs.h"

#include "xml-syscall.h"

#include <ctype.h>

#include "record-full.h"

#include "linux-record.h"

/* Signal frame handling.

+------------+ ^

| saved lr | |

+->| saved fp |--+

| | |

| | |

| +------------+

| | saved lr |

+--| saved fp |

^ | |

| | |

| +------------+

^ | |

| | signal |

| | | SIGTRAMP_FRAME (struct rt_sigframe)

| | saved regs |

+--| saved sp |--> interrupted_sp

| | saved pc |--> interrupted_pc

| | |

| +------------+

| | saved lr |--> default_restorer (movz x8, NR_sys_rt_sigreturn; svc 0)

+--| saved fp |<- FP

| | NORMAL_FRAME

| |<- SP

+------------+

On signal delivery, the kernel will create a signal handler stack

frame and setup the return address in LR to point at restorer stub.

The signal stack frame is defined by:

struct rt_sigframe

{

siginfo_t info;

struct ucontext uc;

};

typedef struct

{

... 128 bytes

} siginfo_t;

The ucontext has the following form:

struct ucontext

{

unsigned long uc_flags;

struct ucontext *uc_link;

stack_t uc_stack;

sigset_t uc_sigmask;

struct sigcontext uc_mcontext;

};

typedef struct sigaltstack

{

void *ss_sp;

int ss_flags;

size_t ss_size;

} stack_t;

struct sigcontext

{

unsigned long fault_address;

unsigned long regs[31];

unsigned long sp; / * 31 * /

unsigned long pc; / * 32 * /

unsigned long pstate; / * 33 * /

__u8 __reserved[4096]

};

The restorer stub will always have the form:

d28015a8 movz x8, #0xad

d4000001 svc #0x0

This is a system call sys_rt_sigreturn.

We detect signal frames by snooping the return code for the restorer

instruction sequence.

The handler then needs to recover the saved register set from

ucontext.uc_mcontext. */

/* These magic numbers need to reflect the layout of the kernel

defined struct rt_sigframe and ucontext. */

#define AARCH64_SIGCONTEXT_REG_SIZE 8

#define AARCH64_RT_SIGFRAME_UCONTEXT_OFFSET 128

#define AARCH64_UCONTEXT_SIGCONTEXT_OFFSET 176

#define AARCH64_SIGCONTEXT_XO_OFFSET 8

/* Implement the "init" method of struct tramp_frame. */

static void

aarch64_linux_sigframe_init (const struct tramp_frame *self,

struct frame_info *this_frame,

struct trad_frame_cache *this_cache,

CORE_ADDR func)

{

CORE_ADDR sp = get_frame_register_unsigned (this_frame, AARCH64_SP_REGNUM);

CORE_ADDR sigcontext_addr =

sp

+ AARCH64_RT_SIGFRAME_UCONTEXT_OFFSET

+ AARCH64_UCONTEXT_SIGCONTEXT_OFFSET;

int i;

for (i = 0; i < 31; i++)

{

trad_frame_set_reg_addr (this_cache,

AARCH64_X0_REGNUM + i,

sigcontext_addr + AARCH64_SIGCONTEXT_XO_OFFSET

+ i * AARCH64_SIGCONTEXT_REG_SIZE);

}

trad_frame_set_reg_addr (this_cache, AARCH64_SP_REGNUM,

sigcontext_addr + AARCH64_SIGCONTEXT_XO_OFFSET

+ 31 * AARCH64_SIGCONTEXT_REG_SIZE);

trad_frame_set_reg_addr (this_cache, AARCH64_PC_REGNUM,

sigcontext_addr + AARCH64_SIGCONTEXT_XO_OFFSET

+ 32 * AARCH64_SIGCONTEXT_REG_SIZE);

trad_frame_set_id (this_cache, frame_id_build (sp, func));

}

static const struct tramp_frame aarch64_linux_rt_sigframe =

{

SIGTRAMP_FRAME,

4,

{

/* movz x8, 0x8b (S=1,o=10,h=0,i=0x8b,r=8)

Soo1 0010 1hhi iiii iiii iiii iiir rrrr */

{0xd2801168, -1},

/* svc 0x0 (o=0, l=1)

1101 0100 oooi iiii iiii iiii iii0 00ll */

{0xd4000001, -1},

{TRAMP_SENTINEL_INSN, -1}

},

aarch64_linux_sigframe_init

};

/* Register maps. */

static const struct regcache_map_entry aarch64_linux_gregmap[] =

{

{ 31, AARCH64_X0_REGNUM, 8 }, /* x0 ... x30 */

{ 1, AARCH64_SP_REGNUM, 8 },

{ 1, AARCH64_PC_REGNUM, 8 },

{ 1, AARCH64_CPSR_REGNUM, 8 },

{ 0 }

};

static const struct regcache_map_entry aarch64_linux_fpregmap[] =

{

{ 32, AARCH64_V0_REGNUM, 16 }, /* v0 ... v31 */

{ 1, AARCH64_FPSR_REGNUM, 4 },

{ 1, AARCH64_FPCR_REGNUM, 4 },

{ 0 }

};

/* Register set definitions. */

const struct regset aarch64_linux_gregset =

{

aarch64_linux_gregmap,

regcache_supply_regset, regcache_collect_regset

};

const struct regset aarch64_linux_fpregset =

{

aarch64_linux_fpregmap,

regcache_supply_regset, regcache_collect_regset

};

/* Implement the "regset_from_core_section" gdbarch method. */

static void

aarch64_linux_iterate_over_regset_sections (struct gdbarch *gdbarch,

iterate_over_regset_sections_cb *cb,

void *cb_data,

const struct regcache *regcache)

{

cb (".reg", AARCH64_LINUX_SIZEOF_GREGSET, &aarch64_linux_gregset,

NULL, cb_data);

cb (".reg2", AARCH64_LINUX_SIZEOF_FPREGSET, &aarch64_linux_fpregset,

NULL, cb_data);

}

/* Implementation of `gdbarch_stap_is_single_operand', as defined in

gdbarch.h. */

static int

aarch64_stap_is_single_operand (struct gdbarch *gdbarch, const char *s)

{

return (*s == '#' || isdigit (*s) /* Literal number. */

|| *s == '[' /* Register indirection. */

|| isalpha (*s)); /* Register value. */

}

/* This routine is used to parse a special token in AArch64's assembly.

The special tokens parsed by it are:

- Register displacement (e.g, [fp, #-8])

It returns one if the special token has been parsed successfully,

or zero if the current token is not considered special. */

static int

aarch64_stap_parse_special_token (struct gdbarch *gdbarch,

struct stap_parse_info *p)

{

if (*p->arg == '[')

{

/* Temporary holder for lookahead. */

const char *tmp = p->arg;

char *endp;

/* Used to save the register name. */

const char *start;

char *regname;

int len;

int got_minus = 0;

long displacement;

struct stoken str;

++tmp;

start = tmp;

/* Register name. */

while (isalnum (*tmp))

++tmp;

if (*tmp != ',')

return 0;

len = tmp - start;

regname = (char *) alloca (len + 2);

strncpy (regname, start, len);

regname[len] = '\0';

if (user_reg_map_name_to_regnum (gdbarch, regname, len) == -1)

error (_("Invalid register name `%s' on expression `%s'."),

regname, p->saved_arg);

++tmp;

tmp = skip_spaces_const (tmp);

/* Now we expect a number. It can begin with '#' or simply

a digit. */

if (*tmp == '#')

++tmp;

if (*tmp == '-')

{

++tmp;

got_minus = 1;

}

else if (*tmp == '+')

++tmp;

if (!isdigit (*tmp))

return 0;

displacement = strtol (tmp, &endp, 10);

tmp = endp;

/* Skipping last `]'. */

if (*tmp++ != ']')

return 0;

/* The displacement. */

write_exp_elt_opcode (&p->pstate, OP_LONG);

write_exp_elt_type (&p->pstate, builtin_type (gdbarch)->builtin_long);

write_exp_elt_longcst (&p->pstate, displacement);

write_exp_elt_opcode (&p->pstate, OP_LONG);

if (got_minus)

write_exp_elt_opcode (&p->pstate, UNOP_NEG);

/* The register name. */

write_exp_elt_opcode (&p->pstate, OP_REGISTER);

str.ptr = regname;

str.length = len;

write_exp_string (&p->pstate, str);

write_exp_elt_opcode (&p->pstate, OP_REGISTER);

write_exp_elt_opcode (&p->pstate, BINOP_ADD);

/* Casting to the expected type. */

write_exp_elt_opcode (&p->pstate, UNOP_CAST);

write_exp_elt_type (&p->pstate, lookup_pointer_type (p->arg_type));

write_exp_elt_opcode (&p->pstate, UNOP_CAST);

write_exp_elt_opcode (&p->pstate, UNOP_IND);

p->arg = tmp;

}

else

return 0;

return 1;

}

/* Implement the "get_syscall_number" gdbarch method. */

static LONGEST

aarch64_linux_get_syscall_number (struct gdbarch *gdbarch,

ptid_t ptid)

{

struct regcache *regs = get_thread_regcache (ptid);

enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);

/* The content of register x8. */

gdb_byte buf[X_REGISTER_SIZE];

/* The result. */

LONGEST ret;

/* Getting the system call number from the register x8. */

regcache_cooked_read (regs, AARCH64_DWARF_X0 + 8, buf);

ret = extract_signed_integer (buf, X_REGISTER_SIZE, byte_order);

return ret;

}

/* AArch64 process record-replay constructs: syscall, signal etc. */

struct linux_record_tdep aarch64_linux_record_tdep;

/* Enum that defines the AArch64 linux specific syscall identifiers used for

process record/replay. */

enum aarch64_syscall {

};

/* aarch64_canonicalize_syscall maps syscall ids from the native AArch64

linux set of syscall ids into a canonical set of syscall ids used by

process record. */

static enum gdb_syscall

aarch64_canonicalize_syscall (enum aarch64_syscall syscall_number)

{

#define SYSCALL_MAP(SYSCALL) case aarch64_sys_##SYSCALL: \

return gdb_sys_##SYSCALL

#define UNSUPPORTED_SYSCALL_MAP(SYSCALL) case aarch64_sys_##SYSCALL: \

return gdb_sys_no_syscall

switch (syscall_number)

{

SYSCALL_MAP (io_setup);

SYSCALL_MAP (io_destroy);

SYSCALL_MAP (io_submit);

SYSCALL_MAP (io_cancel);

SYSCALL_MAP (io_getevents);

SYSCALL_MAP (setxattr);

SYSCALL_MAP (lsetxattr);

SYSCALL_MAP (fsetxattr);

SYSCALL_MAP (getxattr);

SYSCALL_MAP (lgetxattr);

SYSCALL_MAP (fgetxattr);

SYSCALL_MAP (listxattr);

SYSCALL_MAP (llistxattr);

SYSCALL_MAP (flistxattr);

SYSCALL_MAP (removexattr);

SYSCALL_MAP (lremovexattr);

SYSCALL_MAP (fremovexattr);

SYSCALL_MAP (getcwd);

SYSCALL_MAP (lookup_dcookie);

SYSCALL_MAP (eventfd2);

SYSCALL_MAP (epoll_create1);

SYSCALL_MAP (epoll_ctl);

SYSCALL_MAP (epoll_pwait);

SYSCALL_MAP (dup);

SYSCALL_MAP (dup3);

SYSCALL_MAP (fcntl);

SYSCALL_MAP (inotify_init1);

SYSCALL_MAP (inotify_add_watch);

SYSCALL_MAP (inotify_rm_watch);

SYSCALL_MAP (ioctl);

SYSCALL_MAP (ioprio_set);

SYSCALL_MAP (ioprio_get);

SYSCALL_MAP (flock);

SYSCALL_MAP (mknodat);

SYSCALL_MAP (mkdirat);

SYSCALL_MAP (unlinkat);

SYSCALL_MAP (symlinkat);

SYSCALL_MAP (linkat);

SYSCALL_MAP (renameat);

UNSUPPORTED_SYSCALL_MAP (umount2);

SYSCALL_MAP (mount);

SYSCALL_MAP (pivot_root);

SYSCALL_MAP (nfsservctl);

SYSCALL_MAP (statfs);

SYSCALL_MAP (truncate);

SYSCALL_MAP (ftruncate);

SYSCALL_MAP (fallocate);

SYSCALL_MAP (faccessat);

SYSCALL_MAP (fchdir);

SYSCALL_MAP (chroot);

SYSCALL_MAP (fchmod);

SYSCALL_MAP (fchmodat);

SYSCALL_MAP (fchownat);

SYSCALL_MAP (fchown);

SYSCALL_MAP (openat);

SYSCALL_MAP (close);

SYSCALL_MAP (vhangup);

SYSCALL_MAP (pipe2);

SYSCALL_MAP (quotactl);

SYSCALL_MAP (getdents64);

SYSCALL_MAP (lseek);

SYSCALL_MAP (read);

SYSCALL_MAP (write);

SYSCALL_MAP (readv);

SYSCALL_MAP (writev);

SYSCALL_MAP (pread64);

SYSCALL_MAP (pwrite64);

UNSUPPORTED_SYSCALL_MAP (preadv);

UNSUPPORTED_SYSCALL_MAP (pwritev);

SYSCALL_MAP (sendfile);

SYSCALL_MAP (pselect6);

SYSCALL_MAP (ppoll);

UNSUPPORTED_SYSCALL_MAP (signalfd4);

SYSCALL_MAP (vmsplice);

SYSCALL_MAP (splice);

SYSCALL_MAP (tee);

SYSCALL_MAP (readlinkat);

SYSCALL_MAP (newfstatat);

SYSCALL_MAP (fstat);

SYSCALL_MAP (sync);

SYSCALL_MAP (fsync);

SYSCALL_MAP (fdatasync);

SYSCALL_MAP (sync_file_range);

UNSUPPORTED_SYSCALL_MAP (timerfd_create);

UNSUPPORTED_SYSCALL_MAP (timerfd_settime);

UNSUPPORTED_SYSCALL_MAP (timerfd_gettime);

UNSUPPORTED_SYSCALL_MAP (utimensat);

SYSCALL_MAP (acct);

SYSCALL_MAP (capget);

SYSCALL_MAP (capset);

SYSCALL_MAP (personality);

SYSCALL_MAP (exit);

SYSCALL_MAP (exit_group);

SYSCALL_MAP (waitid);

SYSCALL_MAP (set_tid_address);

SYSCALL_MAP (unshare);

SYSCALL_MAP (futex);

SYSCALL_MAP (set_robust_list);

SYSCALL_MAP (get_robust_list);

SYSCALL_MAP (nanosleep);

SYSCALL_MAP (getitimer);

SYSCALL_MAP (setitimer);

SYSCALL_MAP (kexec_load);

SYSCALL_MAP (init_module);

SYSCALL_MAP (delete_module);

SYSCALL_MAP (timer_create);

SYSCALL_MAP (timer_settime);

SYSCALL_MAP (timer_gettime);

SYSCALL_MAP (timer_getoverrun);

SYSCALL_MAP (timer_delete);

SYSCALL_MAP (clock_settime);

SYSCALL_MAP (clock_gettime);

SYSCALL_MAP (clock_getres);

SYSCALL_MAP (clock_nanosleep);

SYSCALL_MAP (syslog);

SYSCALL_MAP (ptrace);

SYSCALL_MAP (sched_setparam);

SYSCALL_MAP (sched_setscheduler);

SYSCALL_MAP (sched_getscheduler);

SYSCALL_MAP (sched_getparam);

SYSCALL_MAP (sched_setaffinity);

SYSCALL_MAP (sched_getaffinity);

SYSCALL_MAP (sched_yield);

SYSCALL_MAP (sched_get_priority_max);

SYSCALL_MAP (sched_get_priority_min);

SYSCALL_MAP (sched_rr_get_interval);

SYSCALL_MAP (kill);

SYSCALL_MAP (tkill);

SYSCALL_MAP (tgkill);

SYSCALL_MAP (sigaltstack);

SYSCALL_MAP (rt_sigsuspend);

SYSCALL_MAP (rt_sigaction);

SYSCALL_MAP (rt_sigprocmask);

SYSCALL_MAP (rt_sigpending);

SYSCALL_MAP (rt_sigtimedwait);

SYSCALL_MAP (rt_sigqueueinfo);

SYSCALL_MAP (rt_sigreturn);

SYSCALL_MAP (setpriority);

SYSCALL_MAP (getpriority);

SYSCALL_MAP (reboot);

SYSCALL_MAP (setregid);

SYSCALL_MAP (setgid);

SYSCALL_MAP (setreuid);

SYSCALL_MAP (setuid);

SYSCALL_MAP (setresuid);

SYSCALL_MAP (getresuid);

SYSCALL_MAP (setresgid);

SYSCALL_MAP (getresgid);

SYSCALL_MAP (setfsuid);

SYSCALL_MAP (setfsgid);

SYSCALL_MAP (times);

SYSCALL_MAP (setpgid);

SYSCALL_MAP (getpgid);

SYSCALL_MAP (getsid);

SYSCALL_MAP (setsid);

SYSCALL_MAP (getgroups);

SYSCALL_MAP (setgroups);

SYSCALL_MAP (uname);

SYSCALL_MAP (sethostname);

SYSCALL_MAP (setdomainname);

SYSCALL_MAP (getrlimit);

SYSCALL_MAP (setrlimit);

SYSCALL_MAP (getrusage);

SYSCALL_MAP (umask);

SYSCALL_MAP (prctl);

SYSCALL_MAP (getcpu);

SYSCALL_MAP (gettimeofday);

SYSCALL_MAP (settimeofday);

SYSCALL_MAP (adjtimex);

SYSCALL_MAP (getpid);

SYSCALL_MAP (getppid);

SYSCALL_MAP (getuid);

SYSCALL_MAP (geteuid);

SYSCALL_MAP (getgid);

SYSCALL_MAP (getegid);

SYSCALL_MAP (gettid);

SYSCALL_MAP (sysinfo);

SYSCALL_MAP (mq_open);

SYSCALL_MAP (mq_unlink);

SYSCALL_MAP (mq_timedsend);

SYSCALL_MAP (mq_timedreceive);

SYSCALL_MAP (mq_notify);

SYSCALL_MAP (mq_getsetattr);

SYSCALL_MAP (msgget);

SYSCALL_MAP (msgctl);

SYSCALL_MAP (msgrcv);

SYSCALL_MAP (msgsnd);

SYSCALL_MAP (semget);

SYSCALL_MAP (semctl);

SYSCALL_MAP (semtimedop);

SYSCALL_MAP (semop);

SYSCALL_MAP (shmget);

SYSCALL_MAP (shmctl);

SYSCALL_MAP (shmat);

SYSCALL_MAP (shmdt);

SYSCALL_MAP (socket);

SYSCALL_MAP (socketpair);

SYSCALL_MAP (bind);

SYSCALL_MAP (listen);

SYSCALL_MAP (accept);

SYSCALL_MAP (connect);

SYSCALL_MAP (getsockname);

SYSCALL_MAP (getpeername);

SYSCALL_MAP (sendto);

SYSCALL_MAP (recvfrom);

SYSCALL_MAP (setsockopt);

SYSCALL_MAP (getsockopt);

SYSCALL_MAP (shutdown);

SYSCALL_MAP (sendmsg);

SYSCALL_MAP (recvmsg);

SYSCALL_MAP (readahead);

SYSCALL_MAP (brk);

SYSCALL_MAP (munmap);

SYSCALL_MAP (mremap);

SYSCALL_MAP (add_key);

SYSCALL_MAP (request_key);

SYSCALL_MAP (keyctl);

SYSCALL_MAP (clone);

SYSCALL_MAP (execve);

case aarch64_sys_mmap:

return gdb_sys_mmap2;

SYSCALL_MAP (fadvise64);

SYSCALL_MAP (swapon);

SYSCALL_MAP (swapoff);

SYSCALL_MAP (mprotect);

SYSCALL_MAP (msync);

SYSCALL_MAP (mlock);

SYSCALL_MAP (munlock);

SYSCALL_MAP (mlockall);

SYSCALL_MAP (munlockall);

SYSCALL_MAP (mincore);

SYSCALL_MAP (madvise);

SYSCALL_MAP (remap_file_pages);

SYSCALL_MAP (mbind);

SYSCALL_MAP (get_mempolicy);

SYSCALL_MAP (set_mempolicy);

SYSCALL_MAP (migrate_pages);

SYSCALL_MAP (move_pages);

UNSUPPORTED_SYSCALL_MAP (rt_tgsigqueueinfo);

UNSUPPORTED_SYSCALL_MAP (perf_event_open);

UNSUPPORTED_SYSCALL_MAP (accept4);

UNSUPPORTED_SYSCALL_MAP (recvmmsg);

SYSCALL_MAP (wait4);

UNSUPPORTED_SYSCALL_MAP (prlimit64);

UNSUPPORTED_SYSCALL_MAP (fanotify_init);

UNSUPPORTED_SYSCALL_MAP (fanotify_mark);

UNSUPPORTED_SYSCALL_MAP (name_to_handle_at);

UNSUPPORTED_SYSCALL_MAP (open_by_handle_at);

UNSUPPORTED_SYSCALL_MAP (clock_adjtime);

UNSUPPORTED_SYSCALL_MAP (syncfs);

UNSUPPORTED_SYSCALL_MAP (setns);

UNSUPPORTED_SYSCALL_MAP (sendmmsg);

UNSUPPORTED_SYSCALL_MAP (process_vm_readv);

UNSUPPORTED_SYSCALL_MAP (process_vm_writev);

UNSUPPORTED_SYSCALL_MAP (kcmp);

UNSUPPORTED_SYSCALL_MAP (finit_module);

UNSUPPORTED_SYSCALL_MAP (sched_setattr);

UNSUPPORTED_SYSCALL_MAP (sched_getattr);

default:

return gdb_sys_no_syscall;

}

}

/* Record all registers but PC register for process-record. */

static int

aarch64_all_but_pc_registers_record (struct regcache *regcache)

{

int i;

for (i = AARCH64_X0_REGNUM; i < AARCH64_PC_REGNUM; i++)

if (record_full_arch_list_add_reg (regcache, i))

return -1;

if (record_full_arch_list_add_reg (regcache, AARCH64_CPSR_REGNUM))

return -1;

return 0;

}

/* Handler for aarch64 system call instruction recording. */

static int

aarch64_linux_syscall_record (struct regcache *regcache,

unsigned long svc_number)

{

int ret = 0;

enum gdb_syscall syscall_gdb;

syscall_gdb =

aarch64_canonicalize_syscall ((enum aarch64_syscall) svc_number);

if (syscall_gdb < 0)

{

printf_unfiltered (_("Process record and replay target doesn't "

"support syscall number %s\n"),

plongest (svc_number));

return -1;

}

if (syscall_gdb == gdb_sys_sigreturn

|| syscall_gdb == gdb_sys_rt_sigreturn)

{

if (aarch64_all_but_pc_registers_record (regcache))

return -1;

return 0;

}

ret = record_linux_system_call (syscall_gdb, regcache,

&aarch64_linux_record_tdep);

if (ret != 0)

return ret;

/* Record the return value of the system call. */

if (record_full_arch_list_add_reg (regcache, AARCH64_X0_REGNUM))

return -1;

/* Record LR. */

if (record_full_arch_list_add_reg (regcache, AARCH64_LR_REGNUM))

return -1;

/* Record CPSR. */

if (record_full_arch_list_add_reg (regcache, AARCH64_CPSR_REGNUM))

return -1;

return 0;

}

static void

aarch64_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)

{

static const char *const stap_integer_prefixes[] = { "#", "", NULL };

static const char *const stap_register_prefixes[] = { "", NULL };

static const char *const stap_register_indirection_prefixes[] = { "[",

NULL };

static const char *const stap_register_indirection_suffixes[] = { "]",

NULL };

struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);

tdep->lowest_pc = 0x8000;