--- /dev/null
+/* GDB stub for Itanium OpenVMS
+ Copyright (C) 2012, Free Software Foundation, Inc.
+
+ Contributed by Tristan Gingold, AdaCore.
+
+ 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/>. */
+
+/* On VMS, the debugger (in our case the stub) is loaded in the process and
+ executed (via SYS$IMGSTA) before the main entry point of the executable.
+ In UNIX parlance, this is like using LD_PRELOAD and debug via installing
+ SIGTRAP, SIGSEGV... handlers.
+
+ This is currently a partial implementation. In particular, modifying
+ registers is currently not implemented, as well as inferior procedure
+ calls.
+
+ This is written in very low-level C, in order not to use the C runtime,
+ because it may have weird consequences on the program being debugged.
+*/
+
+#if __INITIAL_POINTER_SIZE != 64
+#error "Must be compiled with 64 bit pointers"
+#endif
+
+#define __NEW_STARLET 1
+#include <descrip.h>
+#include <iledef.h>
+#include <efndef.h>
+#include <in.h>
+#include <inet.h>
+#include <iodef.h>
+#include <ssdef.h>
+#include <starlet.h>
+#include <stsdef.h>
+#include <tcpip$inetdef.h>
+
+#include <lib$routines.h>
+#include <ots$routines.h>
+#include <str$routines.h>
+#include <libdef.h>
+#include <clidef.h>
+#include <iosbdef.h>
+#include <dvidef.h>
+#include <lnmdef.h>
+#include <builtins.h>
+#include <prtdef.h>
+#include <psldef.h>
+#include <ssdef.h>
+#include <chfdef.h>
+
+#include <lib_c/imcbdef.h>
+#include <lib_c/ldrimgdef.h>
+#include <lib_c/intstkdef.h>
+#include <lib_c/psrdef.h>
+#include <lib_c/ifddef.h>
+#include <lib_c/eihddef.h>
+
+#include <stdarg.h>
+#include <pthread_debug.h>
+
+#define VMS_PAGE_SIZE 0x2000
+#define VMS_PAGE_MASK (VMS_PAGE_SIZE - 1)
+
+/* Declared in lib$ots. */
+extern void ots$fill (void *addr, size_t len, unsigned char b);
+extern void ots$move (void *dst, size_t len, const void *src);
+extern int ots$strcmp_eql (const void *str1, size_t str1len,
+ const void *str2, size_t str2len);
+
+/* Stub port number. */
+static unsigned int serv_port = 1234;
+
+/* DBGEXT structure. Not declared in any header. */
+struct dbgext_control_block
+{
+ unsigned short dbgext$w_function_code;
+#define DBGEXT$K_NEXT_TASK 3
+#define DBGEXT$K_STOP_ALL_OTHER_TASKS 31
+#define DBGEXT$K_GET_REGS 33
+ unsigned short dbgext$w_facility_id;
+#define CMA$_FACILITY 64
+ unsigned int dbgext$l_status;
+ unsigned int dbgext$l_flags;
+ unsigned int dbgext$l_print_routine;
+ unsigned int dbgext$l_evnt_code;
+ unsigned int dbgext$l_evnt_name;
+ unsigned int dbgext$l_evnt_entry;
+ unsigned int dbgext$l_task_value;
+ unsigned int dbgext$l_task_number;
+ unsigned int dbgext$l_ada_flags;
+ unsigned int dbgext$l_stop_value;
+#define dbgext$l_priority dbgext$l_stop_value;
+#define dbgext$l_symb_addr dbgext$l_stop_value;
+#define dbgext$l_time_slice dbgext$l_stop_value;
+ unsigned int dbgext$l_active_registers;
+};
+
+#pragma pointer_size save
+#pragma pointer_size 32
+
+/* Pthread handler. */
+static int (*dbgext_func) (struct dbgext_control_block *blk);
+
+#pragma pointer_size restore
+
+/* Set to 1 if thread-aware. */
+static int has_threads;
+
+/* Current thread. */
+static pthread_t selected_thread;
+static pthreadDebugId_t selected_id;
+
+/* Internal debugging flags. */
+struct debug_flag
+{
+ /* Name of the flag (as a string descriptor). */
+ const struct dsc$descriptor_s name;
+ /* Value. */
+ int val;
+};
+
+/* Macro to define a debugging flag. */
+#define DEBUG_FLAG_ENTRY(str) \
+ { { sizeof (str) - 1, DSC$K_DTYPE_T, DSC$K_CLASS_S, str }, 0}
+
+static struct debug_flag debug_flags[] =
+{
+ /* Disp packets exchanged with gdb. */
+ DEBUG_FLAG_ENTRY("packets"),
+#define trace_pkt (debug_flags[0].val)
+ /* Display entry point informations. */
+ DEBUG_FLAG_ENTRY("entry"),
+#define trace_entry (debug_flags[1].val)
+ /* Be verbose about exceptions. */
+ DEBUG_FLAG_ENTRY("excp"),
+#define trace_excp (debug_flags[2].val)
+ /* Be verbose about unwinding. */
+ DEBUG_FLAG_ENTRY("unwind"),
+#define trace_unwind (debug_flags[3].val)
+ /* Display image at startup. */
+ DEBUG_FLAG_ENTRY("images"),
+#define trace_images (debug_flags[4].val)
+ /* Display pthread_debug info. */
+ DEBUG_FLAG_ENTRY("pthreaddbg")
+#define trace_pthreaddbg (debug_flags[5].val)
+};
+
+#define NBR_DEBUG_FLAGS (sizeof (debug_flags) / sizeof (debug_flags[0]))
+
+/* Connect inet device I/O channel. */
+static unsigned short conn_channel;
+
+/* Widely used hex digit to ascii. */
+static const char hex[] = "0123456789abcdef";
+
+/* Socket characteristics. Apparently, there are no declaration for it in
+ standard headers. */
+struct sockchar
+{
+ unsigned short prot;
+ unsigned char type;
+ unsigned char af;
+};
+
+/* Chain of images loaded. */
+extern IMCB* ctl$gl_imglstptr;
+
+/* IA64 integer register representation. */
+union ia64_ireg
+{
+ unsigned __int64 v;
+ unsigned char b[8];
+};
+
+/* IA64 register numbers, as defined by ia64-tdep.h. */
+#define IA64_GR0_REGNUM 0
+#define IA64_GR32_REGNUM (IA64_GR0_REGNUM + 32)
+
+/* Floating point registers; 128 82-bit wide registers. */
+#define IA64_FR0_REGNUM 128
+
+/* Predicate registers; There are 64 of these one bit registers. It'd
+ be more convenient (implementation-wise) to use a single 64 bit
+ word with all of these register in them. Note that there's also a
+ IA64_PR_REGNUM below which contains all the bits and is used for
+ communicating the actual values to the target. */
+#define IA64_PR0_REGNUM 256
+
+/* Branch registers: 8 64-bit registers for holding branch targets. */
+#define IA64_BR0_REGNUM 320
+
+/* Virtual frame pointer; this matches IA64_FRAME_POINTER_REGNUM in
+ gcc/config/ia64/ia64.h. */
+#define IA64_VFP_REGNUM 328
+
+/* Virtual return address pointer; this matches
+ IA64_RETURN_ADDRESS_POINTER_REGNUM in gcc/config/ia64/ia64.h. */
+#define IA64_VRAP_REGNUM 329
+
+/* Predicate registers: There are 64 of these 1-bit registers. We
+ define a single register which is used to communicate these values
+ to/from the target. We will somehow contrive to make it appear
+ that IA64_PR0_REGNUM thru IA64_PR63_REGNUM hold the actual values. */
+#define IA64_PR_REGNUM 330
+
+/* Instruction pointer: 64 bits wide. */
+#define IA64_IP_REGNUM 331
+
+/* Process Status Register. */
+#define IA64_PSR_REGNUM 332
+
+/* Current Frame Marker (raw form may be the cr.ifs). */
+#define IA64_CFM_REGNUM 333
+
+/* Application registers; 128 64-bit wide registers possible, but some
+ of them are reserved. */
+#define IA64_AR0_REGNUM 334
+#define IA64_KR0_REGNUM (IA64_AR0_REGNUM + 0)
+#define IA64_KR7_REGNUM (IA64_KR0_REGNUM + 7)
+
+#define IA64_RSC_REGNUM (IA64_AR0_REGNUM + 16)
+#define IA64_BSP_REGNUM (IA64_AR0_REGNUM + 17)
+#define IA64_BSPSTORE_REGNUM (IA64_AR0_REGNUM + 18)
+#define IA64_RNAT_REGNUM (IA64_AR0_REGNUM + 19)
+#define IA64_FCR_REGNUM (IA64_AR0_REGNUM + 21)
+#define IA64_EFLAG_REGNUM (IA64_AR0_REGNUM + 24)
+#define IA64_CSD_REGNUM (IA64_AR0_REGNUM + 25)
+#define IA64_SSD_REGNUM (IA64_AR0_REGNUM + 26)
+#define IA64_CFLG_REGNUM (IA64_AR0_REGNUM + 27)
+#define IA64_FSR_REGNUM (IA64_AR0_REGNUM + 28)
+#define IA64_FIR_REGNUM (IA64_AR0_REGNUM + 29)
+#define IA64_FDR_REGNUM (IA64_AR0_REGNUM + 30)
+#define IA64_CCV_REGNUM (IA64_AR0_REGNUM + 32)
+#define IA64_UNAT_REGNUM (IA64_AR0_REGNUM + 36)
+#define IA64_FPSR_REGNUM (IA64_AR0_REGNUM + 40)
+#define IA64_ITC_REGNUM (IA64_AR0_REGNUM + 44)
+#define IA64_PFS_REGNUM (IA64_AR0_REGNUM + 64)
+#define IA64_LC_REGNUM (IA64_AR0_REGNUM + 65)
+#define IA64_EC_REGNUM (IA64_AR0_REGNUM + 66)
+
+/* NAT (Not A Thing) Bits for the general registers; there are 128 of
+ these. */
+#define IA64_NAT0_REGNUM 462
+
+/* Process registers when a condition is caught. */
+struct ia64_all_regs
+{
+ union ia64_ireg gr[32];
+ union ia64_ireg br[8];
+ union ia64_ireg ip;
+ union ia64_ireg psr;
+ union ia64_ireg bsp;
+ union ia64_ireg cfm;
+ union ia64_ireg pfs;
+ union ia64_ireg pr;
+};
+
+static struct ia64_all_regs excp_regs;
+static struct ia64_all_regs sel_regs;
+static pthread_t sel_regs_pthread;
+
+/* IO channel for the terminal. */
+static unsigned short term_chan;
+
+/* Output buffer and length. */
+static char term_buf[128];
+static int term_buf_len;
+
+/* Buffer for communication with gdb. */
+static unsigned char gdb_buf[sizeof (struct ia64_all_regs) * 2 + 64];
+static unsigned int gdb_blen;
+
+/* Previous primary handler. */
+static void *prevhnd;
+
+/* Entry point address and bundle. */
+static unsigned __int64 entry_pc;
+static unsigned char entry_saved[16];
+
+/* Write on the terminal. */
+
+static void
+term_raw_write (const char *str, unsigned int len)
+{
+ unsigned short status;
+ struct _iosb iosb;
+
+ status = sys$qiow (EFN$C_ENF, /* Event flag. */
+ term_chan, /* I/O channel. */
+ IO$_WRITEVBLK, /* I/O function code. */
+ &iosb, /* I/O status block. */
+ 0, /* Ast service routine. */
+ 0, /* Ast parameter. */
+ (char *)str, /* P1 - buffer address. */
+ len, /* P2 - buffer length. */
+ 0, 0, 0, 0);
+
+ if (status & STS$M_SUCCESS)
+ status = iosb.iosb$w_status;
+ if (!(status & STS$M_SUCCESS))
+ LIB$SIGNAL (status);
+}
+
+/* Flush ther term buffer. */
+
+static void
+term_flush (void)
+{
+ if (term_buf_len != 0)
+ {
+ term_raw_write (term_buf, term_buf_len);
+ term_buf_len = 0;
+ }
+}
+
+/* Write a single character, without translation. */
+
+static void
+term_raw_putchar (char c)
+{
+ if (term_buf_len == sizeof (term_buf))
+ term_flush ();
+ term_buf[term_buf_len++] = c;
+}
+
+/* Write character C. Translate '\n' to '\n\r'. */
+
+static void
+term_putc (char c)
+{
+ if (c < 32)
+ switch (c)
+ {
+ case '\r':
+ case '\n':
+ break;
+ default:
+ c = '.';
+ break;
+ }
+ term_raw_putchar (c);
+ if (c == '\n')
+ {
+ term_raw_putchar ('\r');
+ term_flush ();
+ }
+}
+
+/* Write a C string. */
+
+static void
+term_puts (const char *str)
+{
+ while (*str)
+ term_putc (*str++);
+}
+
+/* Write LEN bytes from STR. */
+
+static void
+term_write (const char *str, unsigned int len)
+{
+ for (; len > 0; len--)
+ term_putc (*str++);
+}
+
+/* Write using FAO formatting. */
+
+static void
+term_fao (const char *str, unsigned int str_len, ...)
+{
+ int cnt;
+ va_list vargs;
+ int i;
+ __int64 *args;
+ int status;
+ struct dsc$descriptor_s dstr =
+ { str_len, DSC$K_DTYPE_T, DSC$K_CLASS_S, (__char_ptr32)str };
+ char buf[128];
+ $DESCRIPTOR (buf_desc, buf);
+
+ va_start (vargs, str_len);
+ va_count (cnt);
+ args = (__int64 *) __ALLOCA (cnt * sizeof (__int64));
+ cnt -= 2;
+ for (i = 0; i < cnt; i++)
+ args[i] = va_arg (vargs, __int64);
+
+ status = sys$faol_64 (&dstr, &buf_desc.dsc$w_length, &buf_desc, args);
+ if (status & 1)
+ {
+ /* FAO !/ already insert a line feed. */
+ for (i = 0; i < buf_desc.dsc$w_length; i++)
+ {
+ term_raw_putchar (buf[i]);
+ if (buf[i] == '\n')
+ term_flush ();
+ }
+ }
+
+ va_end (vargs);
+}
+
+#define TERM_FAO(STR, ...) term_fao (STR, sizeof (STR) - 1, __VA_ARGS__)
+
+/* New line. */
+
+static void
+term_putnl (void)
+{
+ term_putc ('\n');
+}
+
+/* Initialize terminal. */
+
+static void
+term_init (void)
+{
+ unsigned int status,i;
+ unsigned short len;
+ char resstring[LNM$C_NAMLENGTH];
+ static const $DESCRIPTOR (tabdesc, "LNM$FILE_DEV");
+ static const $DESCRIPTOR (logdesc, "SYS$OUTPUT");
+ $DESCRIPTOR (term_desc, resstring);
+ ILE3 item_lst[2];
+
+ item_lst[0].ile3$w_length = LNM$C_NAMLENGTH;
+ item_lst[0].ile3$w_code = LNM$_STRING;
+ item_lst[0].ile3$ps_bufaddr = resstring;
+ item_lst[0].ile3$ps_retlen_addr = &len;
+ item_lst[1].ile3$w_length = 0;
+ item_lst[1].ile3$w_code = 0;
+
+ /* Translate the logical name. */
+ status = SYS$TRNLNM (0, /* Attr of the logical name. */
+ (void *) &tabdesc, /* Logical name table. */
+ (void *) &logdesc, /* Logical name. */
+ 0, /* Access mode. */
+ item_lst); /* Item list. */
+ if (!(status & STS$M_SUCCESS))
+ LIB$SIGNAL (status);
+
+ term_desc.dsc$w_length = len;
+
+ /* Examine 4-byte header. Skip escape sequence. */
+ if (resstring[0] == 0x1B)
+ {
+ term_desc.dsc$w_length -= 4;
+ term_desc.dsc$a_pointer += 4;
+ }
+
+ /* Assign a channel. */
+ status = sys$assign (&term_desc, /* Device name. */
+ &term_chan, /* I/O channel. */
+ 0, /* Access mode. */
+ 0);
+ if (!(status & STS$M_SUCCESS))
+ LIB$SIGNAL (status);
+}
+
+/* Convert from native endianness to network endianness (and vice-versa). */
+
+static unsigned int
+wordswap (unsigned int v)
+{
+ return ((v & 0xff) << 8) | ((v >> 8) & 0xff);
+}
+
+/* Initialize the socket connection, and wait for a client. */
+
+static void
+sock_init (void)
+{
+ struct _iosb iosb;
+ unsigned int status;
+
+ /* Listen channel and characteristics. */
+ unsigned short listen_channel;
+ struct sockchar listen_sockchar;
+
+ /* Client address. */
+ unsigned short cli_addrlen;
+ struct sockaddr_in cli_addr;
+ ILE3 cli_itemlst;
+
+ /* Our address. */
+ struct sockaddr_in serv_addr;
+ ILE2 serv_itemlst;
+
+ /* Reuseaddr option value (on). */
+ int optval = 1;
+ ILE2 sockopt_itemlst;
+ ILE2 reuseaddr_itemlst;
+
+ /* TCP/IP network pseudodevice. */
+ static const $DESCRIPTOR (inet_device, "TCPIP$DEVICE:");
+
+ /* Initialize socket characteristics. */
+ listen_sockchar.prot = TCPIP$C_TCP;
+ listen_sockchar.type = TCPIP$C_STREAM;
+ listen_sockchar.af = TCPIP$C_AF_INET;
+
+ /* Assign I/O channels to network device. */
+ status = sys$assign ((void *) &inet_device, &listen_channel, 0, 0);
+ if (status & STS$M_SUCCESS)
+ status = sys$assign ((void *) &inet_device, &conn_channel, 0, 0);
+ if (!(status & STS$M_SUCCESS))
+ {
+ term_puts ("Failed to assign I/O channel(s)\n");
+ LIB$SIGNAL (status);
+ }
+
+ /* Create a listen socket. */
+ status = sys$qiow (EFN$C_ENF, /* Event flag. */
+ listen_channel, /* I/O channel. */
+ IO$_SETMODE, /* I/O function code. */
+ &iosb, /* I/O status block. */
+ 0, /* Ast service routine. */
+ 0, /* Ast parameter. */
+ &listen_sockchar, /* P1 - socket characteristics. */
+ 0, 0, 0, 0, 0);
+ if (status & STS$M_SUCCESS)
+ status = iosb.iosb$w_status;
+ if (!(status & STS$M_SUCCESS))
+ {
+ term_puts ("Failed to create socket\n");
+ LIB$SIGNAL (status);
+ }
+
+ /* Set reuse address option. */
+ /* Initialize reuseaddr's item-list element. */
+ reuseaddr_itemlst.ile2$w_length = sizeof (optval);
+ reuseaddr_itemlst.ile2$w_code = TCPIP$C_REUSEADDR;
+ reuseaddr_itemlst.ile2$ps_bufaddr = &optval;
+
+ /* Initialize setsockopt's item-list descriptor. */
+ sockopt_itemlst.ile2$w_length = sizeof (reuseaddr_itemlst);
+ sockopt_itemlst.ile2$w_code = TCPIP$C_SOCKOPT;
+ sockopt_itemlst.ile2$ps_bufaddr = &reuseaddr_itemlst;
+
+ status = sys$qiow (EFN$C_ENF, /* Event flag. */
+ listen_channel, /* I/O channel. */
+ IO$_SETMODE, /* I/O function code. */
+ &iosb, /* I/O status block. */
+ 0, /* Ast service routine. */
+ 0, /* Ast parameter. */
+ 0, /* P1. */
+ 0, /* P2. */
+ 0, /* P3. */
+ 0, /* P4. */
+ (__int64) &sockopt_itemlst, /* P5 - socket options. */
+ 0);
+ if (status & STS$M_SUCCESS)
+ status = iosb.iosb$w_status;
+ if (!(status & STS$M_SUCCESS))
+ {
+ term_puts ("Failed to set socket option\n");
+ LIB$SIGNAL (status);
+ }
+
+ /* Bind server's ip address and port number to listen socket. */
+ /* Initialize server's socket address structure. */
+ ots$fill (&serv_addr, sizeof (serv_addr), 0);
+ serv_addr.sin_family = TCPIP$C_AF_INET;
+ serv_addr.sin_port = wordswap (serv_port);
+ serv_addr.sin_addr.s_addr = TCPIP$C_INADDR_ANY;
+
+ /* Initialize server's item-list descriptor. */
+ serv_itemlst.ile2$w_length = sizeof (serv_addr);
+ serv_itemlst.ile2$w_code = TCPIP$C_SOCK_NAME;
+ serv_itemlst.ile2$ps_bufaddr = &serv_addr;
+
+ status = sys$qiow (EFN$C_ENF, /* Event flag. */
+ listen_channel, /* I/O channel. */
+ IO$_SETMODE, /* I/O function code. */
+ &iosb, /* I/O status block. */
+ 0, /* Ast service routine. */
+ 0, /* Ast parameter. */
+ 0, /* P1. */
+ 0, /* P2. */
+ (__int64) &serv_itemlst, /* P3 - local socket name. */
+ 0, 0, 0);
+ if (status & STS$M_SUCCESS)
+ status = iosb.iosb$w_status;
+ if (!(status & STS$M_SUCCESS))
+ {
+ term_puts ("Failed to bind socket\n");
+ LIB$SIGNAL (status);
+ }
+
+ /* Set socket as a listen socket. */
+ status = sys$qiow (EFN$C_ENF, /* Event flag. */
+ listen_channel, /* I/O channel. */
+ IO$_SETMODE, /* I/O function code. */
+ &iosb, /* I/O status block. */
+ 0, /* Ast service routine. */
+ 0, /* Ast parameter. */
+ 0, /* P1. */
+ 0, /* P2. */
+ 0, /* P3. */
+ 1, /* P4 - connection backlog. */
+ 0, 0);
+ if (status & STS$M_SUCCESS)
+ status = iosb.iosb$w_status;
+ if (!(status & STS$M_SUCCESS))
+ {
+ term_puts ("Failed to set socket passive\n");
+ LIB$SIGNAL (status);
+ }
+
+ /* Accept connection from a client. */
+ TERM_FAO ("Waiting for a client connection on port: !ZW!/",
+ wordswap (serv_addr.sin_port));
+
+ status = sys$qiow (EFN$C_ENF, /* Event flag. */
+ listen_channel, /* I/O channel. */
+ IO$_ACCESS|IO$M_ACCEPT, /* I/O function code. */
+ &iosb, /* I/O status block. */
+ 0, /* Ast service routine. */
+ 0, /* Ast parameter. */
+ 0, /* P1. */
+ 0, /* P2. */
+ 0, /* P3. */
+ (__int64) &conn_channel, /* P4 - I/O channel for conn. */
+ 0, 0);
+
+ if (status & STS$M_SUCCESS)
+ status = iosb.iosb$w_status;
+ if (!(status & STS$M_SUCCESS))
+ {
+ term_puts ("Failed to accept client connection\n");
+ LIB$SIGNAL (status);
+ }
+
+ /* Log client connection request. */
+ cli_itemlst.ile3$w_length = sizeof (cli_addr);
+ cli_itemlst.ile3$w_code = TCPIP$C_SOCK_NAME;
+ cli_itemlst.ile3$ps_bufaddr = &cli_addr;
+ cli_itemlst.ile3$ps_retlen_addr = &cli_addrlen;
+ ots$fill (&cli_addr, sizeof(cli_addr), 0);
+ status = sys$qiow (EFN$C_ENF, /* Event flag. */
+ conn_channel, /* I/O channel. */
+ IO$_SENSEMODE, /* I/O function code. */
+ &iosb, /* I/O status block. */
+ 0, /* Ast service routine. */
+ 0, /* Ast parameter. */
+ 0, /* P1. */
+ 0, /* P2. */
+ 0, /* P3. */
+ (__int64) &cli_itemlst, /* P4 - peer socket name. */
+ 0, 0);
+ if (status & STS$M_SUCCESS)
+ status = iosb.iosb$w_status;
+ if (!(status & STS$M_SUCCESS))
+ {
+ term_puts ("Failed to get client name\n");
+ LIB$SIGNAL (status);
+ }
+
+ TERM_FAO ("Accepted connection from host: !UB.!UB,!UB.!UB, port: !UW!/",
+ (cli_addr.sin_addr.s_addr >> 0) & 0xff,
+ (cli_addr.sin_addr.s_addr >> 8) & 0xff,
+ (cli_addr.sin_addr.s_addr >> 16) & 0xff,
+ (cli_addr.sin_addr.s_addr >> 24) & 0xff,
+ wordswap (cli_addr.sin_port));
+}
+
+/* Close the socket. */
+
+static void
+sock_close (void)
+{
+ struct _iosb iosb;
+ unsigned int status;
+
+ /* Close socket. */
+ status = sys$qiow (EFN$C_ENF, /* Event flag. */
+ conn_channel, /* I/O channel. */
+ IO$_DEACCESS, /* I/O function code. */
+ &iosb, /* I/O status block. */
+ 0, /* Ast service routine. */
+ 0, /* Ast parameter. */
+ 0, 0, 0, 0, 0, 0);
+
+ if (status & STS$M_SUCCESS)
+ status = iosb.iosb$w_status;
+ if (!(status & STS$M_SUCCESS))
+ {
+ term_puts ("Failed to close socket\n");
+ LIB$SIGNAL (status);
+ }
+
+ /* Deassign I/O channel to network device. */
+ status = sys$dassgn (conn_channel);
+
+ if (!(status & STS$M_SUCCESS))
+ {
+ term_puts ("Failed to deassign I/O channel\n");
+ LIB$SIGNAL (status);
+ }
+}
+
+/* Mark a page as R/W. Return old rights. */
+
+static unsigned int
+page_set_rw (unsigned __int64 startva, unsigned __int64 len,
+ unsigned int *oldprot)
+{
+ unsigned int status;
+ unsigned __int64 retva;
+ unsigned __int64 retlen;
+
+ status = SYS$SETPRT_64 ((void *)startva, len, PSL$C_USER, PRT$C_UW,
+ (void *)&retva, &retlen, oldprot);
+ return status;
+}
+
+/* Restore page rights. */
+
+static void
+page_restore_rw (unsigned __int64 startva, unsigned __int64 len,
+ unsigned int prot)
+{
+ unsigned int status;
+ unsigned __int64 retva;
+ unsigned __int64 retlen;
+ unsigned int oldprot;
+
+ status = SYS$SETPRT_64 ((void *)startva, len, PSL$C_USER, prot,
+ (void *)&retva, &retlen, &oldprot);
+ if (!(status & STS$M_SUCCESS))
+ LIB$SIGNAL (status);
+}
+
+/* Get the TEB (thread environment block). */
+
+static pthread_t
+get_teb (void)
+{
+ return (pthread_t)__getReg (_IA64_REG_TP);
+}
+
+/* Enable thread scheduling if VAL is true. */
+
+static unsigned int
+set_thread_scheduling (int val)
+{
+ struct dbgext_control_block blk;
+ unsigned int status;
+
+ if (!dbgext_func)
+ return 0;
+
+ blk.dbgext$w_function_code = DBGEXT$K_STOP_ALL_OTHER_TASKS;
+ blk.dbgext$w_facility_id = CMA$_FACILITY;
+ blk.dbgext$l_stop_value = val;
+
+ status = dbgext_func (&blk);
+ if (!(status & STS$M_SUCCESS))
+ {
+ TERM_FAO ("set_thread_scheduling error, val=!SL, status=!XL!/",
+ val, blk.dbgext$l_status);
+ lib$signal (status);
+ }
+
+ return blk.dbgext$l_stop_value;
+}
+
+/* Get next thead (after THR). Start with 0. */
+
+static unsigned int
+thread_next (unsigned int thr)
+{
+ struct dbgext_control_block blk;
+ unsigned int status;
+
+ if (!dbgext_func)
+ return 0;
+
+ blk.dbgext$w_function_code = DBGEXT$K_NEXT_TASK;
+ blk.dbgext$w_facility_id = CMA$_FACILITY;
+ blk.dbgext$l_ada_flags = 0;
+ blk.dbgext$l_task_value = thr;
+
+ status = dbgext_func (&blk);
+ if (!(status & STS$M_SUCCESS))
+ lib$signal (status);
+
+ return blk.dbgext$l_task_value;
+}
+
+/* Pthread Debug callbacks. */
+
+static int
+read_callback (pthreadDebugClient_t context,
+ pthreadDebugTargetAddr_t addr,
+ pthreadDebugAddr_t buf,
+ size_t size)
+{
+ if (trace_pthreaddbg)
+ TERM_FAO ("read_callback (!XH, !XH, !SL)!/", addr, buf, size);
+ ots$move (buf, size, addr);
+ return 0;
+}
+
+static int
+write_callback (pthreadDebugClient_t context,
+ pthreadDebugTargetAddr_t addr,
+ pthreadDebugLongConstAddr_t buf,
+ size_t size)
+{
+ if (trace_pthreaddbg)
+ TERM_FAO ("write_callback (!XH, !XH, !SL)!/", addr, buf, size);
+ ots$move (addr, size, buf);
+ return 0;
+}
+
+static int
+suspend_callback (pthreadDebugClient_t context)
+{
+ /* Always suspended. */
+ return 0;
+}
+
+static int
+resume_callback (pthreadDebugClient_t context)
+{
+ /* So no need to resume. */
+ return 0;
+}
+
+static int
+kthdinfo_callback (pthreadDebugClient_t context,
+ pthreadDebugKId_t kid,
+ pthreadDebugKThreadInfo_p thread_info)
+{
+ if (trace_pthreaddbg)
+ term_puts ("kthinfo_callback");
+ return ENOSYS;
+}
+
+static int
+hold_callback (pthreadDebugClient_t context,
+ pthreadDebugKId_t kid)
+{
+ if (trace_pthreaddbg)
+ term_puts ("hold_callback");
+ return ENOSYS;
+}
+
+static int
+unhold_callback (pthreadDebugClient_t context,
+ pthreadDebugKId_t kid)
+{
+ if (trace_pthreaddbg)
+ term_puts ("unhold_callback");
+ return ENOSYS;
+}
+
+static int
+getfreg_callback (pthreadDebugClient_t context,
+ pthreadDebugFregs_t *reg,
+ pthreadDebugKId_t kid)
+{
+ if (trace_pthreaddbg)
+ term_puts ("getfreg_callback");
+ return ENOSYS;
+}
+
+static int
+setfreg_callback (pthreadDebugClient_t context,
+ const pthreadDebugFregs_t *reg,
+ pthreadDebugKId_t kid)
+{
+ if (trace_pthreaddbg)
+ term_puts ("setfreg_callback");
+ return ENOSYS;
+}
+
+static int
+getreg_callback (pthreadDebugClient_t context,
+ pthreadDebugRegs_t *reg,
+ pthreadDebugKId_t kid)
+{
+ if (trace_pthreaddbg)
+ term_puts ("getreg_callback");
+ return ENOSYS;
+}
+
+static int
+setreg_callback (pthreadDebugClient_t context,
+ const pthreadDebugRegs_t *reg,
+ pthreadDebugKId_t kid)
+{
+ if (trace_pthreaddbg)
+ term_puts ("setreg_callback");
+ return ENOSYS;
+}
+
+static int
+output_callback (pthreadDebugClient_t context,
+ pthreadDebugConstString_t line)
+{
+ term_puts (line);
+ term_putnl ();
+ return 0;
+}
+
+static int
+error_callback (pthreadDebugClient_t context,
+ pthreadDebugConstString_t line)
+{
+ term_puts (line);
+ term_putnl ();
+ return 0;
+}
+
+static pthreadDebugAddr_t
+malloc_callback (pthreadDebugClient_t caller_context, size_t size)
+{
+ unsigned int status;
+ unsigned int res;
+ int len;
+
+ len = size + 16;
+ status = lib$get_vm (&len, &res, 0);
+ if (!(status & STS$M_SUCCESS))
+ LIB$SIGNAL (status);
+ if (trace_pthreaddbg)
+ TERM_FAO ("malloc_callback (!UL) -> !XA!/", size, res);
+ *(unsigned int *)res = len;
+ return (char *)res + 16;
+}
+
+static void
+free_callback (pthreadDebugClient_t caller_context, pthreadDebugAddr_t address)
+{
+ unsigned int status;
+ unsigned int res;
+ int len;
+
+ res = (unsigned int)address - 16;
+ len = *(unsigned int *)res;
+ if (trace_pthreaddbg)
+ TERM_FAO ("free_callback (!XA)!/", address);
+ status = lib$free_vm (&len, &res, 0);
+ if (!(status & STS$M_SUCCESS))
+ LIB$SIGNAL (status);
+}
+
+static int
+speckthd_callback (pthreadDebugClient_t caller_context,
+ pthreadDebugSpecialType_t type,
+ pthreadDebugKId_t *kernel_tid)
+{
+ return ENOTSUP;
+}
+
+static pthreadDebugCallbacks_t pthread_debug_callbacks = {
+ PTHREAD_DEBUG_VERSION,
+ read_callback,
+ write_callback,
+ suspend_callback,
+ resume_callback,
+ kthdinfo_callback,
+ hold_callback,
+ unhold_callback,
+ getfreg_callback,
+ setfreg_callback,
+ getreg_callback,
+ setreg_callback,
+ output_callback,
+ error_callback,
+ malloc_callback,
+ free_callback,
+ speckthd_callback
+};
+
+/* Name of the pthread shared library. */
+static const $DESCRIPTOR (pthread_rtl_desc, "PTHREAD$RTL");
+
+/* List of symbols to extract from pthread debug library. */
+struct pthread_debug_entry
+{
+ const unsigned int namelen;
+ const __char_ptr32 name;
+ __void_ptr32 func;
+};
+
+#define DEBUG_ENTRY(str) { sizeof(str) - 1, str, 0 }
+
+static struct pthread_debug_entry pthread_debug_entries[] = {
+ DEBUG_ENTRY("pthreadDebugContextInit"),
+ DEBUG_ENTRY("pthreadDebugThdSeqInit"),
+ DEBUG_ENTRY("pthreadDebugThdSeqNext"),
+ DEBUG_ENTRY("pthreadDebugThdSeqDestroy"),
+ DEBUG_ENTRY("pthreadDebugThdGetInfo"),
+ DEBUG_ENTRY("pthreadDebugThdGetInfoAddr"),
+ DEBUG_ENTRY("pthreadDebugThdGetReg"),
+ DEBUG_ENTRY("pthreadDebugCmd")
+};
+
+/* Pthread debug context. */
+static pthreadDebugContext_t debug_context;
+
+/* Wrapper around pthread debug entry points. */
+
+static int
+pthread_debug_thd_seq_init (pthreadDebugId_t *id)
+{
+ return ((int (*)())pthread_debug_entries[1].func)
+ (debug_context, id);
+}
+
+static int
+pthread_debug_thd_seq_next (pthreadDebugId_t *id)
+{
+ return ((int (*)())pthread_debug_entries[2].func)
+ (debug_context, id);
+}
+
+static int
+pthread_debug_thd_seq_destroy (void)
+{
+ return ((int (*)())pthread_debug_entries[3].func)
+ (debug_context);
+}
+
+static int
+pthread_debug_thd_get_info (pthreadDebugId_t id,
+ pthreadDebugThreadInfo_t *info)
+{
+ return ((int (*)())pthread_debug_entries[4].func)
+ (debug_context, id, info);
+}
+
+static int
+pthread_debug_thd_get_info_addr (pthread_t thr,
+ pthreadDebugThreadInfo_t *info)
+{
+ return ((int (*)())pthread_debug_entries[5].func)
+ (debug_context, thr, info);
+}
+
+static int
+pthread_debug_thd_get_reg (pthreadDebugId_t thr,
+ pthreadDebugRegs_t *regs)
+{
+ return ((int (*)())pthread_debug_entries[6].func)
+ (debug_context, thr, regs);
+}
+
+static int
+stub_pthread_debug_cmd (const char *cmd)
+{
+ return ((int (*)())pthread_debug_entries[7].func)
+ (debug_context, cmd);
+}
+
+/* Show all the threads. */
+
+static void
+threads_show (void)
+{
+ pthreadDebugId_t id;
+ pthreadDebugThreadInfo_t info;
+ int res;
+
+ res = pthread_debug_thd_seq_init (&id);
+ if (res != 0)
+ {
+ TERM_FAO ("seq init failed, res=!SL!/", res);
+ return;
+ }
+ while (1)
+ {
+ if (pthread_debug_thd_get_info (id, &info) != 0)
+ {
+ TERM_FAO ("thd_get_info !SL failed!/", id);
+ break;
+ }
+ if (pthread_debug_thd_seq_next (&id) != 0)
+ break;
+ }
+ pthread_debug_thd_seq_destroy ();
+}
+
+/* Initialize pthread support. */
+
+static void
+threads_init (void)
+{
+ static const $DESCRIPTOR (dbgext_desc, "PTHREAD$DBGEXT");
+ static const $DESCRIPTOR (pthread_debug_desc, "PTHREAD$DBGSHR");
+ static const $DESCRIPTOR (dbgsymtable_desc, "PTHREAD_DBG_SYMTABLE");
+ int pthread_dbgext;
+ int status;
+ void *dbg_symtable;
+ int i;
+ void *caller_context = 0;
+
+ status = lib$find_image_symbol
+ ((void *) &pthread_rtl_desc, (void *) &dbgext_desc,
+ (int *) &dbgext_func);
+ if (!(status & STS$M_SUCCESS))
+ LIB$SIGNAL (status);
+
+ status = lib$find_image_symbol
+ ((void *) &pthread_rtl_desc, (void *) &dbgsymtable_desc,
+ (int *) &dbg_symtable);
+ if (!(status & STS$M_SUCCESS))
+ LIB$SIGNAL (status);
+
+ /* Find entry points in pthread_debug. */
+ for (i = 0;
+ i < sizeof (pthread_debug_entries) / sizeof (pthread_debug_entries[0]);
+ i++)
+ {
+ struct dsc$descriptor_s sym =
+ { pthread_debug_entries[i].namelen,
+ DSC$K_DTYPE_T, DSC$K_CLASS_S,
+ pthread_debug_entries[i].name };
+ status = lib$find_image_symbol
+ ((void *) &pthread_debug_desc, (void *) &sym,
+ (int *) &pthread_debug_entries[i].func);
+ if (!(status & STS$M_SUCCESS))
+ lib$signal (status);
+ }
+
+ if (trace_pthreaddbg)
+ TERM_FAO ("debug symtable: !XH!/", dbg_symtable);
+ status = ((int (*)()) pthread_debug_entries[0].func)
+ (&caller_context, &pthread_debug_callbacks, dbg_symtable, &debug_context);
+ if (status != 0)
+ TERM_FAO ("cannot initialize pthread_debug: !UL!/", status);
+ TERM_FAO ("pthread debug done!/", 0);
+}
+
+/* Convert an hexadecimal character to a nibble. Return -1 in case of
+ error. */
+
+static int
+hex2nibble (unsigned char h)
+{
+ if (h >= '0' && h <= '9')
+ return h - '0';
+ if (h >= 'A' && h <= 'F')
+ return h - 'A' + 10;
+ if (h >= 'a' && h <= 'f')
+ return h - 'a' + 10;
+ return -1;
+}
+
+/* Convert an hexadecimal 2 character string to a byte. Return -1 in case
+ of error. */
+
+static int
+hex2byte (const unsigned char *p)
+{
+ int h, l;
+
+ h = hex2nibble (p[0]);
+ l = hex2nibble (p[1]);
+ if (h == -1 || l == -1)
+ return -1;
+ return (h << 4) | l;
+}
+
+/* Convert a byte V to a 2 character strings P. */
+
+static void
+byte2hex (unsigned char *p, unsigned char v)
+{
+ p[0] = hex[v >> 4];
+ p[1] = hex[v & 0xf];
+}
+
+/* Convert a quadword V to a 16 character strings P. */
+
+static void
+quad2hex (unsigned char *p, unsigned __int64 v)
+{
+ int i;
+ for (i = 0; i < 16; i++)
+ {
+ p[i] = hex[v >> 60];
+ v <<= 4;
+ }
+}
+
+static void
+long2pkt (unsigned int v)
+{
+ int i;
+
+ for (i = 0; i < 8; i++)
+ {
+ gdb_buf[gdb_blen + i] = hex[(v >> 28) & 0x0f];
+ v <<= 4;
+ }
+ gdb_blen += 8;
+}
+
+/* Generate an error packet. */
+
+static void
+packet_error (unsigned int err)
+{
+ gdb_buf[1] = 'E';
+ byte2hex (gdb_buf + 2, err);
+ gdb_blen = 4;
+}
+
+/* Generate an OK packet. */
+
+static void
+packet_ok (void)
+{
+ gdb_buf[1] = 'O';
+ gdb_buf[2] = 'K';
+ gdb_blen = 3;
+}
+
+/* Append a register to the packet. */
+
+static void
+ireg2pkt (const unsigned char *p)
+{
+ int i;
+
+ for (i = 0; i < 8; i++)
+ {
+ byte2hex (gdb_buf + gdb_blen, p[i]);
+ gdb_blen += 2;
+ }
+}
+
+/* Append a C string (ASCIZ) to the packet. */
+
+static void
+str2pkt (const char *str)
+{
+ while (*str)
+ gdb_buf[gdb_blen++] = *str++;
+}
+
+/* Extract a number fro the packet. */
+
+static unsigned __int64
+pkt2val (const unsigned char *pkt, unsigned int *pos)
+{
+ unsigned __int64 res = 0;
+ unsigned int i;
+
+ while (1)
+ {
+ int r = hex2nibble (pkt[*pos]);
+
+ if (r < 0)
+ return res;
+ res = (res << 4) | r;
+ (*pos)++;
+ }
+}
+
+/* Append LEN bytes from B to the current gdb packet (encode in binary). */
+
+static void
+mem2bin (const unsigned char *b, unsigned int len)
+{
+ unsigned int i;
+ for (i = 0; i < len; i++)
+ switch (b[i])
+ {
+ case '#':
+ case '$':
+ case '}':
+ case '*':
+ case 0:
+ gdb_buf[gdb_blen++] = '}';
+ gdb_buf[gdb_blen++] = b[i] ^ 0x20;
+ break;
+ default:
+ gdb_buf[gdb_blen++] = b[i];
+ break;
+ }
+}
+
+/* Append LEN bytes from B to the current gdb packet (encode in hex). */
+
+static void
+mem2hex (const unsigned char *b, unsigned int len)
+{
+ unsigned int i;
+ for (i = 0; i < len; i++)
+ {
+ byte2hex (gdb_buf + gdb_blen, b[i]);
+ gdb_blen += 2;
+ }
+}
+
+/* Handle the 'q' packet. */
+
+static void
+handle_q_packet (const unsigned char *pkt, unsigned int pktlen)
+{
+ /* For qfThreadInfo and qsThreadInfo. */
+ static unsigned int first_thread;
+ static unsigned int last_thread;
+
+ static const char xfer_uib[] = "qXfer:uib:read:";
+#define XFER_UIB_LEN (sizeof (xfer_uib) - 1)
+ static const char qfthreadinfo[] = "qfThreadInfo";
+#define QFTHREADINFO_LEN (sizeof (qfthreadinfo) - 1)
+ static const char qsthreadinfo[] = "qsThreadInfo";
+#define QSTHREADINFO_LEN (sizeof (qsthreadinfo) - 1)
+ static const char qthreadextrainfo[] = "qThreadExtraInfo,";
+#define QTHREADEXTRAINFO_LEN (sizeof (qthreadextrainfo) - 1)
+ static const char qsupported[] = "qSupported:";
+#define QSUPPORTED_LEN (sizeof (qsupported) - 1)
+
+ if (pktlen == 2 && pkt[1] == 'C')
+ {
+ /* Current thread. */
+ gdb_buf[0] = '$';
+ gdb_buf[1] = 'Q';
+ gdb_buf[2] = 'C';
+ gdb_blen = 3;
+ if (has_threads)
+ long2pkt ((unsigned long) get_teb ());
+ return;
+ }
+ else if (pktlen > XFER_UIB_LEN
+ && ots$strcmp_eql (pkt, XFER_UIB_LEN, xfer_uib, XFER_UIB_LEN))
+ {
+ /* Get unwind information block. */
+ unsigned __int64 pc;
+ unsigned int pos = XFER_UIB_LEN;
+ unsigned int off;
+ unsigned int len;
+ union
+ {
+ unsigned char bytes[32];
+ struct
+ {
+ unsigned __int64 code_start_va;
+ unsigned __int64 code_end_va;
+ unsigned __int64 uib_start_va;
+ unsigned __int64 gp_value;
+ } data;
+ } uei;
+ int res;
+ int i;
+
+ packet_error (0);
+
+ pc = pkt2val (pkt, &pos);
+ if (pkt[pos] != ':')
+ return;
+ pos++;
+ off = pkt2val (pkt, &pos);
+ if (pkt[pos] != ',' || off != 0)
+ return;
+ pos++;
+ len = pkt2val (pkt, &pos);
+ if (pkt[pos] != '#' || len != 0x20)
+ return;
+
+ res = SYS$GET_UNWIND_ENTRY_INFO (pc, &uei.data, 0);
+ if (res == SS$_NODATA || res != SS$_NORMAL)
+ ots$fill (uei.bytes, sizeof (uei.bytes), 0);
+
+ if (trace_unwind)
+ {
+ TERM_FAO ("Unwind request for !XH, status=!XL, uib=!XQ, GP=!XQ!/",
+ pc, res, uei.data.uib_start_va, uei.data.gp_value);
+ }
+
+ gdb_buf[0] = '$';
+ gdb_buf[1] = 'l';
+ gdb_blen = 2;
+ mem2bin (uei.bytes, sizeof (uei.bytes));
+ }
+ else if (pktlen == QFTHREADINFO_LEN
+ && ots$strcmp_eql (pkt, QFTHREADINFO_LEN,
+ qfthreadinfo, QFTHREADINFO_LEN))
+ {
+ /* Get first thread(s). */
+ gdb_buf[0] = '$';
+ gdb_buf[1] = 'm';
+ gdb_blen = 2;
+
+ if (!has_threads)
+ {
+ gdb_buf[1] = 'l';
+ return;
+ }
+ first_thread = thread_next (0);
+ last_thread = first_thread;
+ long2pkt (first_thread);
+ }
+ else if (pktlen == QSTHREADINFO_LEN
+ && ots$strcmp_eql (pkt, QSTHREADINFO_LEN,
+ qsthreadinfo, QSTHREADINFO_LEN))
+ {
+ /* Get subsequent threads. */
+ gdb_buf[0] = '$';
+ gdb_buf[1] = 'm';
+ gdb_blen = 2;
+ while (dbgext_func)
+ {
+ unsigned int res;
+ res = thread_next (last_thread);
+ if (res == first_thread)
+ break;
+ if (gdb_blen > 2)
+ gdb_buf[gdb_blen++] = ',';
+ long2pkt (res);
+ last_thread = res;
+ if (gdb_blen > sizeof (gdb_buf) - 16)
+ break;
+ }
+
+ if (gdb_blen == 2)
+ gdb_buf[1] = 'l';
+ }
+ else if (pktlen > QTHREADEXTRAINFO_LEN
+ && ots$strcmp_eql (pkt, QTHREADEXTRAINFO_LEN,
+ qthreadextrainfo, QTHREADEXTRAINFO_LEN))
+ {
+ /* Get extra info about a thread. */
+ pthread_t thr;
+ unsigned int pos = QTHREADEXTRAINFO_LEN;
+ pthreadDebugThreadInfo_t info;
+ int res;
+
+ packet_error (0);
+ if (!has_threads)
+ return;
+
+ thr = (pthread_t) pkt2val (pkt, &pos);
+ if (pkt[pos] != '#')
+ return;
+ res = pthread_debug_thd_get_info_addr (thr, &info);
+ if (res != 0)
+ {
+ TERM_FAO ("qThreadExtraInfo (!XH) failed: !SL!/", thr, res);
+ return;
+ }
+ gdb_buf[0] = '$';
+ gdb_blen = 1;
+ mem2hex ((const unsigned char *)"VMS-thread", 11);
+ }
+ else if (pktlen > QSUPPORTED_LEN
+ && ots$strcmp_eql (pkt, QSUPPORTED_LEN,
+ qsupported, QSUPPORTED_LEN))
+ {
+ /* Get supported features. */
+ pthread_t thr;
+ unsigned int pos = QSUPPORTED_LEN;
+ pthreadDebugThreadInfo_t info;
+ int res;
+
+ /* Ignore gdb features. */
+ gdb_buf[0] = '$';
+ gdb_blen = 1;
+
+ str2pkt ("qXfer:uib:read+");
+ return;
+ }
+ else
+ {
+ if (trace_pkt)
+ {
+ term_puts ("unknown <: ");
+ term_write ((char *)pkt, pktlen);
+ term_putnl ();
+ }
+ return;
+ }
+}
+
+/* Handle the 'v' packet. */
+
+static int
+handle_v_packet (const unsigned char *pkt, unsigned int pktlen)
+{
+ static const char vcontq[] = "vCont?";
+#define VCONTQ_LEN (sizeof (vcontq) - 1)
+
+ if (pktlen == VCONTQ_LEN
+ && ots$strcmp_eql (pkt, VCONTQ_LEN, vcontq, VCONTQ_LEN))
+ {
+ gdb_buf[0] = '$';
+ gdb_blen = 1;
+
+ str2pkt ("vCont;c;s");
+ return 0;
+ }
+ else
+ {
+ if (trace_pkt)
+ {
+ term_puts ("unknown <: ");
+ term_write ((char *)pkt, pktlen);
+ term_putnl ();
+ }
+ return 0;
+ }
+}
+
+/* Get regs for the selected thread. */
+
+static struct ia64_all_regs *
+get_selected_regs (void)
+{
+ pthreadDebugRegs_t regs;
+ int res;
+
+ if (selected_thread == 0 || selected_thread == get_teb ())
+ return &excp_regs;
+
+ if (selected_thread == sel_regs_pthread)
+ return &sel_regs;
+
+ /* Read registers. */
+ res = pthread_debug_thd_get_reg (selected_id, ®s);
+ if (res != 0)
+ {
+ /* FIXME: return NULL ? */
+ return &excp_regs;
+ }
+ sel_regs_pthread = selected_thread;
+ sel_regs.gr[1].v = regs.gp;
+ sel_regs.gr[4].v = regs.r4;
+ sel_regs.gr[5].v = regs.r5;
+ sel_regs.gr[6].v = regs.r6;
+ sel_regs.gr[7].v = regs.r7;
+ sel_regs.gr[12].v = regs.sp;
+ sel_regs.br[0].v = regs.rp;
+ sel_regs.br[1].v = regs.b1;
+ sel_regs.br[2].v = regs.b2;
+ sel_regs.br[3].v = regs.b3;
+ sel_regs.br[4].v = regs.b4;
+ sel_regs.br[5].v = regs.b5;
+ sel_regs.ip.v = regs.ip;
+ sel_regs.bsp.v = regs.bspstore; /* FIXME: it is correct ? */
+ sel_regs.pfs.v = regs.pfs;
+ sel_regs.pr.v = regs.pr;
+ return &sel_regs;
+}
+
+/* Create a status packet. */
+
+static void
+packet_status (void)
+{
+ gdb_blen = 0;
+ if (has_threads)
+ {
+ str2pkt ("$T05thread:");
+ long2pkt ((unsigned long) get_teb ());
+ gdb_buf[gdb_blen++] = ';';
+ }
+ else
+ str2pkt ("$S05");
+}
+
+/* Return 1 to continue. */
+
+static int
+handle_packet (unsigned char *pkt, unsigned int len)
+{
+ unsigned int pos;
+
+ /* By default, reply unsupported. */
+ gdb_buf[0] = '$';
+ gdb_blen = 1;
+
+ pos = 1;
+ switch (pkt[0])
+ {
+ case '?':
+ if (len == 1)
+ {
+ packet_status ();
+ return 0;
+ }
+ break;
+ case 'c':
+ if (len == 1)
+ {
+ /* Clear psr.ss. */
+ excp_regs.psr.v &= ~(unsigned __int64)PSR$M_SS;
+ return 1;
+ }
+ else
+ packet_error (0);
+ break;
+ case 'g':
+ if (len == 1)
+ {
+ unsigned int i;
+ struct ia64_all_regs *regs = get_selected_regs ();
+ unsigned char *p = regs->gr[0].b;
+
+ for (i = 0; i < 8 * 32; i++)
+ byte2hex (gdb_buf + 1 + 2 * i, p[i]);
+ gdb_blen += 2 * 8 * 32;
+ return 0;
+ }
+ break;
+ case 'H':
+ if (pkt[1] == 'g')
+ {
+ int res;
+ unsigned __int64 val;
+ pthreadDebugThreadInfo_t info;
+
+ pos++;
+ val = pkt2val (pkt, &pos);
+ if (pos != len)
+ {
+ packet_error (0);
+ return 0;
+ }
+ if (val == 0)
+ {
+ /* Default one. */
+ selected_thread = get_teb ();
+ selected_id = 0;
+ }
+ else if (!has_threads)
+ {
+ packet_error (0);
+ return 0;
+ }
+ else
+ {
+ res = pthread_debug_thd_get_info_addr ((pthread_t) val, &info);
+ if (res != 0)
+ {
+ TERM_FAO ("qThreadExtraInfo (!XH) failed: !SL!/", val, res);
+ packet_error (0);
+ return 0;
+ }
+ selected_thread = info.teb;
+ selected_id = info.sequence;
+ }
+ packet_ok ();
+ break;
+ }
+ else if (pkt[1] == 'c'
+ && ((pkt[2] == '-' && pkt[3] == '1' && len == 4)
+ || (pkt[2] == '0' && len == 3)))
+ {
+ /* Silently accept 'Hc0' and 'Hc-1'. */
+ packet_ok ();
+ break;
+ }
+ else
+ {
+ packet_error (0);
+ return 0;
+ }
+ case 'k':
+ SYS$EXIT (SS$_NORMAL);
+ break;
+ case 'm':
+ {
+ unsigned __int64 addr;
+ unsigned __int64 paddr;
+ unsigned int l;
+ unsigned int i;
+
+ addr = pkt2val (pkt, &pos);
+ if (pkt[pos] != ',')
+ {
+ packet_error (0);
+ return 0;
+ }
+ pos++;
+ l = pkt2val (pkt, &pos);
+ if (pkt[pos] != '#')
+ {
+ packet_error (0);
+ return 0;
+ }
+
+ /* Check access. */
+ i = l + (addr & VMS_PAGE_MASK);
+ paddr = addr & ~VMS_PAGE_MASK;
+ while (1)
+ {
+ if (__prober (paddr, 0) != 1)
+ {
+ packet_error (2);
+ return 0;
+ }
+ if (i < VMS_PAGE_SIZE)
+ break;
+ i -= VMS_PAGE_SIZE;
+ paddr += VMS_PAGE_SIZE;
+ }
+
+ /* Transfer. */
+ for (i = 0; i < l; i++)
+ byte2hex (gdb_buf + 1 + 2 * i, ((unsigned char *)addr)[i]);
+ gdb_blen += 2 * l;
+ }
+ break;
+ case 'M':
+ {
+ unsigned __int64 addr;
+ unsigned __int64 paddr;
+ unsigned int l;
+ unsigned int i;
+ unsigned int oldprot;
+
+ addr = pkt2val (pkt, &pos);
+ if (pkt[pos] != ',')
+ {
+ packet_error (0);
+ return 0;
+ }
+ pos++;
+ l = pkt2val (pkt, &pos);
+ if (pkt[pos] != ':')
+ {
+ packet_error (0);
+ return 0;
+ }
+ pos++;
+ page_set_rw (addr, l, &oldprot);
+
+ /* Check access. */
+ i = l + (addr & VMS_PAGE_MASK);
+ paddr = addr & ~VMS_PAGE_MASK;
+ while (1)
+ {
+ if (__probew (paddr, 0) != 1)
+ {
+ page_restore_rw (addr, l, oldprot);
+ return 0;
+ }
+ if (i < VMS_PAGE_SIZE)
+ break;
+ i -= VMS_PAGE_SIZE;
+ paddr += VMS_PAGE_SIZE;
+ }
+
+ /* Write. */
+ for (i = 0; i < l; i++)
+ {
+ int v = hex2byte (pkt + pos);
+ pos += 2;
+ ((unsigned char *)addr)[i] = v;
+ }
+
+ /* Sync caches. */
+ for (i = 0; i < l; i += 15)
+ __fc (addr + i);
+ __fc (addr + l);
+
+ page_restore_rw (addr, l, oldprot);
+ packet_ok ();
+ }
+ break;
+ case 'p':
+ {
+ unsigned int num = 0;
+ unsigned int i;
+ struct ia64_all_regs *regs = get_selected_regs ();
+
+ num = pkt2val (pkt, &pos);
+ if (pos != len)
+ {
+ packet_error (0);
+ return 0;
+ }
+
+ switch (num)
+ {
+ case IA64_IP_REGNUM:
+ ireg2pkt (regs->ip.b);
+ break;
+ case IA64_BR0_REGNUM:
+ ireg2pkt (regs->br[0].b);
+ break;
+ case IA64_PSR_REGNUM:
+ ireg2pkt (regs->psr.b);
+ break;
+ case IA64_BSP_REGNUM:
+ ireg2pkt (regs->bsp.b);
+ break;
+ case IA64_CFM_REGNUM:
+ ireg2pkt (regs->cfm.b);
+ break;
+ case IA64_PFS_REGNUM:
+ ireg2pkt (regs->pfs.b);
+ break;
+ case IA64_PR_REGNUM:
+ ireg2pkt (regs->pr.b);
+ break;
+ default:
+ TERM_FAO ("gdbserv: unhandled reg !UW!/", num);
+ packet_error (0);
+ return 0;
+ }
+ }
+ break;
+ case 'q':
+ handle_q_packet (pkt, len);
+ break;
+ case 's':
+ if (len == 1)
+ {
+ /* Set psr.ss. */
+ excp_regs.psr.v |= (unsigned __int64)PSR$M_SS;
+ return 1;
+ }
+ else
+ packet_error (0);
+ break;
+ case 'T':
+ /* Thread status. */
+ if (!has_threads)
+ {
+ packet_ok ();
+ break;
+ }
+ else
+ {
+ int res;
+ unsigned __int64 val;
+ unsigned int fthr, thr;
+
+ val = pkt2val (pkt, &pos);
+ /* Default is error (but only after parsing is complete). */
+ packet_error (0);
+ if (pos != len)
+ break;
+
+ /* Follow the list. This makes a O(n2) algorithm, but we don't really
+ have the choice. Note that pthread_debug_thd_get_info_addr
+ doesn't look reliable. */
+ fthr = thread_next (0);
+ thr = fthr;
+ do
+ {
+ if (val == thr)
+ {
+ packet_ok ();
+ break;
+ }
+ thr = thread_next (thr);
+ }
+ while (thr != fthr);
+ }
+ break;
+ case 'v':
+ return handle_v_packet (pkt, len);
+ break;
+ case 'V':
+ if (len > 3 && pkt[1] == 'M' && pkt[2] == 'S' && pkt[3] == ' ')
+ {
+ /* Temporary extension. */
+ if (has_threads)
+ {
+ pkt[len] = 0;
+ stub_pthread_debug_cmd ((char *)pkt + 4);
+ packet_ok ();
+ }
+ else
+ packet_error (0);
+ }
+ break;
+ default:
+ if (trace_pkt)
+ {
+ term_puts ("unknown <: ");
+ term_write ((char *)pkt, len);
+ term_putnl ();
+ }
+ break;
+ }
+ return 0;
+}
+
+/* Raw write to gdb. */
+
+static void
+sock_write (const unsigned char *buf, int len)
+{
+ struct _iosb iosb;
+ unsigned int status;
+
+ /* Write data to connection. */
+ status = sys$qiow (EFN$C_ENF, /* Event flag. */
+ conn_channel, /* I/O channel. */
+ IO$_WRITEVBLK, /* I/O function code. */
+ &iosb, /* I/O status block. */
+ 0, /* Ast service routine. */
+ 0, /* Ast parameter. */
+ (char *)buf, /* P1 - buffer address. */
+ len, /* P2 - buffer length. */
+ 0, 0, 0, 0);
+ if (status & STS$M_SUCCESS)
+ status = iosb.iosb$w_status;
+ if (!(status & STS$M_SUCCESS))
+ {
+ term_puts ("Failed to write data to gdb\n");
+ LIB$SIGNAL (status);
+ }
+}
+
+/* Compute the cheksum and send the packet. */
+
+static void
+send_pkt (void)
+{
+ unsigned char chksum = 0;
+ unsigned int i;
+
+ for (i = 1; i < gdb_blen; i++)
+ chksum += gdb_buf[i];
+
+ gdb_buf[gdb_blen] = '#';
+ byte2hex (gdb_buf + gdb_blen + 1, chksum);
+
+ sock_write (gdb_buf, gdb_blen + 3);
+
+ if (trace_pkt > 1)
+ {
+ term_puts (">: ");
+ term_write ((char *)gdb_buf, gdb_blen + 3);
+ term_putnl ();
+ }
+}
+
+/* Read and handle one command. Return 1 is execution must resume. */
+
+static int
+one_command (void)
+{
+ struct _iosb iosb;
+ unsigned int status;
+ unsigned int off;
+ unsigned int dollar_off = 0;
+ unsigned int sharp_off = 0;
+ unsigned int cmd_off;
+ unsigned int cmd_len;
+
+ /* Wait for a packet. */
+ while (1)
+ {
+ off = 0;
+ while (1)
+ {
+ /* Read data from connection. */
+ status = sys$qiow (EFN$C_ENF, /* Event flag. */
+ conn_channel, /* I/O channel. */
+ IO$_READVBLK, /* I/O function code. */
+ &iosb, /* I/O status block. */
+ 0, /* Ast service routine. */
+ 0, /* Ast parameter. */
+ gdb_buf + off, /* P1 - buffer address. */
+ sizeof (gdb_buf) - off, /* P2 - buffer leng. */
+ 0, 0, 0, 0);
+ if (status & STS$M_SUCCESS)
+ status = iosb.iosb$w_status;
+ if (!(status & STS$M_SUCCESS))
+ {
+ term_puts ("Failed to read data from connection\n" );
+ LIB$SIGNAL (status);
+ }
+
+#ifdef RAW_DUMP
+ term_puts ("{: ");
+ term_write ((char *)gdb_buf + off, iosb.iosb$w_bcnt);
+ term_putnl ();
+#endif
+
+ gdb_blen = off + iosb.iosb$w_bcnt;
+
+ if (off == 0)
+ {
+ /* Search for '$'. */
+ for (dollar_off = 0; dollar_off < gdb_blen; dollar_off++)
+ if (gdb_buf[dollar_off] == '$')
+ break;
+ if (dollar_off >= gdb_blen)
+ {
+ /* Not found, discard the data. */
+ off = 0;
+ continue;
+ }
+ /* Search for '#'. */
+ for (sharp_off = dollar_off + 1;
+ sharp_off < gdb_blen;
+ sharp_off++)
+ if (gdb_buf[sharp_off] == '#')
+ break;
+ }
+ else if (sharp_off >= off)
+ {
+ /* Search for '#'. */
+ for (; sharp_off < gdb_blen; sharp_off++)
+ if (gdb_buf[sharp_off] == '#')
+ break;
+ }
+
+ /* Got packet with checksum. */
+ if (sharp_off + 2 <= gdb_blen)
+ break;
+
+ off = gdb_blen;
+ if (gdb_blen == sizeof (gdb_buf))
+ {
+ /* Packet too large, discard. */
+ off = 0;
+ }
+ }
+
+ /* Validate and acknowledge a packet. */
+ {
+ unsigned char chksum = 0;
+ unsigned int i;
+ int v;
+
+ for (i = dollar_off + 1; i < sharp_off; i++)
+ chksum += gdb_buf[i];
+ v = hex2byte (gdb_buf + sharp_off + 1);
+ if (v != chksum)
+ {
+ term_puts ("Discard bad checksum packet\n");
+ continue;
+ }
+ else
+ {
+ sock_write ((const unsigned char *)"+", 1);
+ break;
+ }
+ }
+ }
+
+ if (trace_pkt > 1)
+ {
+ term_puts ("<: ");
+ term_write ((char *)gdb_buf + dollar_off, sharp_off - dollar_off + 1);
+ term_putnl ();
+ }
+
+ cmd_off = dollar_off + 1;
+ cmd_len = sharp_off - dollar_off - 1;
+
+ if (handle_packet (gdb_buf + dollar_off + 1, sharp_off - dollar_off - 1) == 1)
+ return 1;
+
+ send_pkt ();
+ return 0;
+}
+
+/* Display the condition given by SIG64. */
+
+static void
+display_excp (struct chf64$signal_array *sig64, struct chf$mech_array *mech)
+{
+ unsigned int status;
+ char msg[160];
+ unsigned short msglen;
+ $DESCRIPTOR (msg_desc, msg);
+ unsigned char outadr[4];
+
+ status = SYS$GETMSG (sig64->chf64$q_sig_name, &msglen, &msg_desc, 0, outadr);
+ if (status & STS$M_SUCCESS)
+ {
+ char msg2[160];
+ unsigned short msg2len;
+ struct dsc$descriptor_s msg2_desc =
+ { sizeof (msg2), DSC$K_DTYPE_T, DSC$K_CLASS_S, msg2};
+ msg_desc.dsc$w_length = msglen;
+ status = SYS$FAOL_64 (&msg_desc, &msg2len, &msg2_desc,
+ &sig64->chf64$q_sig_arg1);
+ if (status & STS$M_SUCCESS)
+ term_write (msg2, msg2len);
+ }
+ else
+ term_puts ("no message");
+ term_putnl ();
+
+ if (trace_excp > 1)
+ {
+ TERM_FAO (" Frame: !XH, Depth: !4SL, Esf: !XH!/",
+ mech->chf$q_mch_frame, mech->chf$q_mch_depth,
+ mech->chf$q_mch_esf_addr);
+ }
+}
+
+/* Get all registers from current thread. */
+
+static void
+read_all_registers (struct chf$mech_array *mech)
+{
+ struct _intstk *intstk =
+ (struct _intstk *)mech->chf$q_mch_esf_addr;
+ struct chf64$signal_array *sig64 =
+ (struct chf64$signal_array *)mech->chf$ph_mch_sig64_addr;
+ unsigned int cnt = sig64->chf64$w_sig_arg_count;
+ unsigned __int64 pc = (&sig64->chf64$q_sig_name)[cnt - 2];
+
+ excp_regs.ip.v = pc;
+ excp_regs.psr.v = intstk->intstk$q_ipsr;
+ /* GDB and linux expects bsp to point after the current register frame.
+ Adjust. */
+ {
+ unsigned __int64 bsp = intstk->intstk$q_bsp;
+ unsigned int sof = intstk->intstk$q_ifs & 0x7f;
+ unsigned int delta = ((bsp >> 3) & 0x3f) + sof;
+ excp_regs.bsp.v = bsp + ((sof + delta / 0x3f) << 3);
+ }
+ excp_regs.cfm.v = intstk->intstk$q_ifs & 0x3fffffffff;
+ excp_regs.pfs.v = intstk->intstk$q_pfs;
+ excp_regs.pr.v = intstk->intstk$q_preds;
+ excp_regs.gr[0].v = 0;
+ excp_regs.gr[1].v = intstk->intstk$q_gp;
+ excp_regs.gr[2].v = intstk->intstk$q_r2;
+ excp_regs.gr[3].v = intstk->intstk$q_r3;
+ excp_regs.gr[4].v = intstk->intstk$q_r4;
+ excp_regs.gr[5].v = intstk->intstk$q_r5;
+ excp_regs.gr[6].v = intstk->intstk$q_r6;
+ excp_regs.gr[7].v = intstk->intstk$q_r7;
+ excp_regs.gr[8].v = intstk->intstk$q_r8;
+ excp_regs.gr[9].v = intstk->intstk$q_r9;
+ excp_regs.gr[10].v = intstk->intstk$q_r10;
+ excp_regs.gr[11].v = intstk->intstk$q_r11;
+ excp_regs.gr[12].v = (unsigned __int64)intstk + intstk->intstk$l_stkalign;
+ excp_regs.gr[13].v = intstk->intstk$q_r13;
+ excp_regs.gr[14].v = intstk->intstk$q_r14;
+ excp_regs.gr[15].v = intstk->intstk$q_r15;
+ excp_regs.gr[16].v = intstk->intstk$q_r16;
+ excp_regs.gr[17].v = intstk->intstk$q_r17;
+ excp_regs.gr[18].v = intstk->intstk$q_r18;
+ excp_regs.gr[19].v = intstk->intstk$q_r19;
+ excp_regs.gr[20].v = intstk->intstk$q_r20;
+ excp_regs.gr[21].v = intstk->intstk$q_r21;
+ excp_regs.gr[22].v = intstk->intstk$q_r22;
+ excp_regs.gr[23].v = intstk->intstk$q_r23;
+ excp_regs.gr[24].v = intstk->intstk$q_r24;
+ excp_regs.gr[25].v = intstk->intstk$q_r25;
+ excp_regs.gr[26].v = intstk->intstk$q_r26;
+ excp_regs.gr[27].v = intstk->intstk$q_r27;
+ excp_regs.gr[28].v = intstk->intstk$q_r28;
+ excp_regs.gr[29].v = intstk->intstk$q_r29;
+ excp_regs.gr[30].v = intstk->intstk$q_r30;
+ excp_regs.gr[31].v = intstk->intstk$q_r31;
+ excp_regs.br[0].v = intstk->intstk$q_b0;
+ excp_regs.br[1].v = intstk->intstk$q_b1;
+ excp_regs.br[2].v = intstk->intstk$q_b2;
+ excp_regs.br[3].v = intstk->intstk$q_b3;
+ excp_regs.br[4].v = intstk->intstk$q_b4;
+ excp_regs.br[5].v = intstk->intstk$q_b5;
+ excp_regs.br[6].v = intstk->intstk$q_b6;
+ excp_regs.br[7].v = intstk->intstk$q_b7;
+}
+
+/* Write all registers to current thread. FIXME: not yet complete. */
+
+static void
+write_all_registers (struct chf$mech_array *mech)
+{
+ struct _intstk *intstk =
+ (struct _intstk *)mech->chf$q_mch_esf_addr;
+
+ intstk->intstk$q_ipsr = excp_regs.psr.v;
+}
+
+/* Do debugging. Report status to gdb and execute commands. */
+
+static void
+do_debug (struct chf$mech_array *mech)
+{
+ struct _intstk *intstk =
+ (struct _intstk *)mech->chf$q_mch_esf_addr;
+ unsigned int old_ast;
+ unsigned int old_sch;
+ unsigned int status;
+
+ /* Disable ast. */
+ status = sys$setast (0);
+ switch (status)
+ {
+ case SS$_WASCLR:
+ old_ast = 0;
+ break;
+ case SS$_WASSET:
+ old_ast = 1;
+ break;
+ default:
+ /* Should never happen! */
+ lib$signal (status);
+ }
+
+ /* Disable thread scheduling. */
+ if (has_threads)
+ old_sch = set_thread_scheduling (0);
+
+ read_all_registers (mech);
+
+ /* Send stop reply packet. */
+ packet_status ();
+ send_pkt ();
+
+ while (one_command () == 0)
+ ;
+
+ write_all_registers (mech);
+
+ /* Re-enable scheduling. */
+ if (has_threads)
+ set_thread_scheduling (old_sch);
+
+ /* Re-enable AST. */
+ status = sys$setast (old_ast);
+ if (!(status & STS$M_SUCCESS))
+ LIB$SIGNAL (status);
+}
+
+/* The condition handler. That's the core of the stub. */
+
+static int
+excp_handler (struct chf$signal_array *sig,
+ struct chf$mech_array *mech)
+{
+ struct chf64$signal_array *sig64 =
+ (struct chf64$signal_array *)mech->chf$ph_mch_sig64_addr;
+ unsigned int code = sig->chf$l_sig_name & STS$M_COND_ID;
+ unsigned int cnt = sig64->chf64$w_sig_arg_count;
+ unsigned __int64 pc;
+ unsigned int ret;
+ /* Self protection. FIXME: Should be per thread ? */
+ static int in_handler = 0;
+
+ /* Completly ignore some conditions (signaled indirectly by this stub). */
+ switch (code)
+ {
+ case LIB$_KEYNOTFOU & STS$M_COND_ID:
+ return SS$_RESIGNAL_64;
+ default:
+ break;
+ }
+
+ /* Protect against recursion. */
+ in_handler++;
+ if (in_handler > 1)
+ {
+ if (in_handler == 2)
+ TERM_FAO ("gdbstub: exception in handler (pc=!XH)!!!/",
+ (&sig64->chf64$q_sig_name)[cnt - 2]);
+ sys$exit (sig->chf$l_sig_name);
+ }
+
+ pc = (&sig64->chf64$q_sig_name)[cnt - 2];
+ if (trace_excp)
+ TERM_FAO ("excp_handler: code: !XL, pc=!XH!/", code, pc);
+
+ /* If break on the entry point, restore the bundle. */
+ if (code == (SS$_BREAK & STS$M_COND_ID)
+ && pc == entry_pc
+ && entry_pc != 0)
+ {
+ static unsigned int entry_prot;
+
+ if (trace_entry)
+ term_puts ("initial entry breakpoint\n");
+ page_set_rw (entry_pc, 16, &entry_prot);
+
+ ots$move ((void *)entry_pc, 16, entry_saved);
+ __fc (entry_pc);
+ page_restore_rw (entry_pc, 16, entry_prot);
+ }
+
+ switch (code)
+ {
+ case SS$_ACCVIO & STS$M_COND_ID:
+ if (trace_excp <= 1)
+ display_excp (sig64, mech);
+ /* Fall through. */
+ case SS$_BREAK & STS$M_COND_ID:
+ case SS$_OPCDEC & STS$M_COND_ID:
+ case SS$_TBIT & STS$M_COND_ID:
+ case SS$_DEBUG & STS$M_COND_ID:
+ if (trace_excp > 1)
+ {
+ int i;
+ struct _intstk *intstk =
+ (struct _intstk *)mech->chf$q_mch_esf_addr;
+
+ display_excp (sig64, mech);
+
+ TERM_FAO (" intstk: !XH!/", intstk);
+ for (i = 0; i < cnt + 1; i++)
+ TERM_FAO (" !XH!/", ((unsigned __int64 *)sig64)[i]);
+ }
+ do_debug (mech);
+ ret = SS$_CONTINUE_64;
+ break;
+
+ default:
+ display_excp (sig64, mech);
+ ret = SS$_RESIGNAL_64;
+ break;
+ }
+
+ in_handler--;
+ /* Discard selected thread registers. */
+ sel_regs_pthread = 0;
+ return ret;
+}
+
+/* Setup internal trace flags according to GDBSTUB$TRACE logical. */
+
+static void
+trace_init (void)
+{
+ unsigned int status, i, start;
+ unsigned short len;
+ char resstring[LNM$C_NAMLENGTH];
+ static const $DESCRIPTOR (tabdesc, "LNM$DCL_LOGICAL");
+ static const $DESCRIPTOR (logdesc, "GDBSTUB$TRACE");
+ $DESCRIPTOR (sub_desc, resstring);
+ ILE3 item_lst[2];
+
+ item_lst[0].ile3$w_length = LNM$C_NAMLENGTH;
+ item_lst[0].ile3$w_code = LNM$_STRING;
+ item_lst[0].ile3$ps_bufaddr = resstring;
+ item_lst[0].ile3$ps_retlen_addr = &len;
+ item_lst[1].ile3$w_length = 0;
+ item_lst[1].ile3$w_code = 0;
+
+ /* Translate the logical name. */
+ status = SYS$TRNLNM (0, /* Attributes of the logical name. */
+ (void *)&tabdesc, /* Logical name table. */
+ (void *)&logdesc, /* Logical name. */
+ 0, /* Access mode. */
+ &item_lst); /* Item list. */
+ if (status == SS$_NOLOGNAM)
+ return;
+ if (!(status & STS$M_SUCCESS))
+ LIB$SIGNAL (status);
+
+ start = 0;
+ for (i = 0; i <= len; i++)
+ {
+ if ((i == len || resstring[i] == ',' || resstring[i] == ';')
+ && i != start)
+ {
+ int j;
+
+ sub_desc.dsc$a_pointer = resstring + start;
+ sub_desc.dsc$w_length = i - start;
+
+ for (j = 0; j < NBR_DEBUG_FLAGS; j++)
+ if (str$case_blind_compare (&sub_desc,
+ (void *)&debug_flags[j].name) == 0)
+ {
+ debug_flags[j].val++;
+ break;
+ }
+ if (j == NBR_DEBUG_FLAGS)
+ TERM_FAO ("GDBSTUB$TRACE: unknown directive !AS!/", &sub_desc);
+
+ start = i + 1;
+ }
+ }
+
+ TERM_FAO ("GDBSTUB$TRACE=!AD ->", len, resstring);
+ for (i = 0; i < NBR_DEBUG_FLAGS; i++)
+ if (debug_flags[i].val > 0)
+ TERM_FAO (" !AS=!ZL", &debug_flags[i].name, debug_flags[i].val);
+ term_putnl ();
+}
+
+
+/* Entry point. */
+
+static int
+stub_start (unsigned __int64 *progxfer, void *cli_util,
+ EIHD *imghdr, IFD *imgfile,
+ unsigned int linkflag, unsigned int cliflag)
+{
+ static int initialized;
+ int i;
+ int cnt;
+ int is_attached;
+ IMCB *imcb;
+ if (initialized)
+ term_puts ("gdbstub: re-entry\n");
+ else
+ initialized = 1;
+
+ /* When attached (through SS$_DEBUG condition), the number of arguments
+ is 4 and PROGXFER is the PC at interruption. */
+ va_count (cnt);
+ is_attached = cnt == 4;
+
+ term_init ();
+
+ /* Hello banner. */
+ term_puts ("Hello from gdb stub\n");
+
+ trace_init ();
+
+ if (trace_entry && !is_attached)
+ {
+ TERM_FAO ("xfer: !XH, imghdr: !XH, ifd: !XH!/",
+ progxfer, imghdr, imgfile);
+ for (i = -2; i < 8; i++)
+ TERM_FAO (" at !2SW: !XH!/", i, progxfer[i]);
+ }
+
+ /* Search for entry point. */
+ if (!is_attached)
+ {
+ entry_pc = 0;
+ for (i = 0; progxfer[i]; i++)
+ entry_pc = progxfer[i];
+
+ if (trace_entry)
+ {
+ if (entry_pc == 0)
+ {
+ term_puts ("No entry point\n");
+ return 0;
+ }
+ else
+ TERM_FAO ("Entry: !XH!/",entry_pc);
+ }
+ }
+ else
+ entry_pc = progxfer[0];
+
+ has_threads = 0;
+ for (imcb = ctl$gl_imglstptr->imcb$l_flink;
+ imcb != ctl$gl_imglstptr;
+ imcb = imcb->imcb$l_flink)
+ {
+ if (ots$strcmp_eql (pthread_rtl_desc.dsc$a_pointer,
+ pthread_rtl_desc.dsc$w_length,
+ imcb->imcb$t_log_image_name + 1,
+ imcb->imcb$t_log_image_name[0]))
+ has_threads = 1;
+
+ if (trace_images)
+ {
+ unsigned int j;
+ LDRIMG *ldrimg = imcb->imcb$l_ldrimg;
+ LDRISD *ldrisd;
+
+ TERM_FAO ("!XA-!XA ",
+ imcb->imcb$l_starting_address,
+ imcb->imcb$l_end_address);
+
+ switch (imcb->imcb$b_act_code)
+ {
+ case IMCB$K_MAIN_PROGRAM:
+ term_puts ("prog");
+ break;
+ case IMCB$K_MERGED_IMAGE:
+ term_puts ("mrge");
+ break;
+ case IMCB$K_GLOBAL_IMAGE_SECTION:
+ term_puts ("glob");
+ break;
+ default:
+ term_puts ("????");
+ }
+ TERM_FAO (" !AD !40AC!/",
+ 1, "KESU" + (imcb->imcb$b_access_mode & 3),
+ imcb->imcb$t_log_image_name);
+
+ if ((long) ldrimg < 0 || trace_images < 2)
+ continue;
+ ldrisd = ldrimg->ldrimg$l_segments;
+ for (j = 0; j < ldrimg->ldrimg$l_segcount; j++)
+ {
+ unsigned int flags = ldrisd[j].ldrisd$i_flags;
+ term_puts (" ");
+ term_putc (flags & 0x04 ? 'R' : '-');
+ term_putc (flags & 0x02 ? 'W' : '-');
+ term_putc (flags & 0x01 ? 'X' : '-');
+ term_puts (flags & 0x01000000 ? " Prot" : " ");
+ term_puts (flags & 0x04000000 ? " Shrt" : " ");
+ term_puts (flags & 0x08000000 ? " Shrd" : " ");
+ TERM_FAO (" !XA-!XA!/",
+ ldrisd[j].ldrisd$p_base,
+ (unsigned __int64) ldrisd[j].ldrisd$p_base
+ + ldrisd[j].ldrisd$i_len - 1);
+ }
+ ldrisd = ldrimg->ldrimg$l_dyn_seg;
+ if (ldrisd)
+ TERM_FAO (" dynamic !XA-!XA!/",
+ ldrisd->ldrisd$p_base,
+ (unsigned __int64) ldrisd->ldrisd$p_base
+ + ldrisd->ldrisd$i_len - 1);
+ }
+ }
+
+ if (has_threads)
+ threads_init ();
+
+ /* Wait for connection. */
+ sock_init ();
+
+ /* Set primary exception vector. */
+ {
+ unsigned int status;
+ status = sys$setexv (0, excp_handler, PSL$C_USER, (__void_ptr32) &prevhnd);
+ if (!(status & STS$M_SUCCESS))
+ LIB$SIGNAL (status);
+ }
+
+ if (is_attached)
+ {
+ return excp_handler ((struct chf$signal_array *) progxfer[2],
+ (struct chf$mech_array *) progxfer[3]);
+ }
+
+ /* Change first instruction to set a breakpoint. */
+ {
+ /*
+ 01 08 00 40 00 00 [MII] break.m 0x80001
+ 00 00 00 02 00 00 nop.i 0x0
+ 00 00 04 00 nop.i 0x0;;
+ */
+ static const unsigned char initbp[16] =
+ { 0x01, 0x08, 0x00, 0x40, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+ 0x00, 0x00, 0x04, 0x00 };
+ unsigned int entry_prot;
+ unsigned int status;
+
+ status = page_set_rw (entry_pc, 16, &entry_prot);
+
+ if (!(status & STS$M_SUCCESS))
+ {
+ if ((status & STS$M_COND_ID) == (SS$_NOT_PROCESS_VA & STS$M_COND_ID))
+ {
+ /* Cannot write here. This can happen when pthreads are
+ used. */
+ entry_pc = 0;
+ term_puts ("gdbstub: cannot set breakpoint on entry\n");
+ }
+ else
+ LIB$SIGNAL (status);
+ }
+
+ if (entry_pc != 0)
+ {
+ ots$move (entry_saved, 16, (void *)entry_pc);
+ ots$move ((void *)entry_pc, 16, (void *)initbp);
+ __fc (entry_pc);
+ page_restore_rw (entry_pc, 16, entry_prot);
+ }
+ }
+
+ /* If it wasn't possible to set a breakpoint on the entry point,
+ accept gdb commands now. Note that registers are not updated. */
+ if (entry_pc == 0)
+ {
+ while (one_command () == 0)
+ ;
+ }
+
+ /* We will see! */
+ return SS$_CONTINUE;
+}
+
+/* Declare the entry point of this relocatable module. */
+
+struct xfer_vector
+{
+ __int64 impure_start;
+ __int64 impure_end;
+ int (*entry) ();
+};
+
+#pragma __extern_model save
+#pragma __extern_model strict_refdef "XFER_PSECT"
+struct xfer_vector xfer_vector = {0, 0, stub_start};
+#pragma __extern_model restore
projects / binutils-gdb.git / commitdiff