gdb/stubs/ia64vms-stub.c - gdb

Global variables defined

Data types defined

Functions defined

Macros defined

Source code

  1. /* GDB stub for Itanium OpenVMS
  2.    Copyright (C) 2012-2015 Free Software Foundation, Inc.

  4.    Contributed by Tristan Gingold, AdaCore.

  6.    This program is free software; you can redistribute it and/or modify
  7.    it under the terms of the GNU General Public License as published by
  8.    the Free Software Foundation; either version 3 of the License, or
  9.    (at your option) any later version.

  11.    This program is distributed in the hope that it will be useful,
  12.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.    GNU General Public License for more details.

  16.    You should have received a copy of the GNU General Public License
  17.    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

  19. /* On VMS, the debugger (in our case the stub) is loaded in the process and
  20.    executed (via SYS$IMGSTA) before the main entry point of the executable.
  21.    In UNIX parlance, this is like using LD_PRELOAD and debug via installing
  22.    SIGTRAP, SIGSEGV... handlers.

  24.    This is currently a partial implementation.  In particular, modifying
  25.    registers is currently not implemented, as well as inferior procedure
  26.    calls.

  28.    This is written in very low-level C, in order not to use the C runtime,
  29.    because it may have weird consequences on the program being debugged.
  30. */

  32. #if __INITIAL_POINTER_SIZE != 64
  33. #error "Must be compiled with 64 bit pointers"
  34. #endif

  36. ‌#define __NEW_STARLET 1
  37. #include <descrip.h>
  38. #include <iledef.h>
  39. #include <efndef.h>
  40. #include <in.h>
  41. #include <inet.h>
  42. #include <iodef.h>
  43. #include <ssdef.h>
  44. #include <starlet.h>
  45. #include <stsdef.h>
  46. #include <tcpip$inetdef.h>

  48. #include <lib$routines.h>
  49. #include <ots$routines.h>
  50. #include <str$routines.h>
  51. #include <libdef.h>
  52. #include <clidef.h>
  53. #include <iosbdef.h>
  54. #include <dvidef.h>
  55. #include <lnmdef.h>
  56. #include <builtins.h>
  57. #include <prtdef.h>
  58. #include <psldef.h>
  59. #include <ssdef.h>
  60. #include <chfdef.h>

  62. #include <lib_c/imcbdef.h>
  63. #include <lib_c/ldrimgdef.h>
  64. #include <lib_c/intstkdef.h>
  65. #include <lib_c/psrdef.h>
  66. #include <lib_c/ifddef.h>
  67. #include <lib_c/eihddef.h>

  69. #include <stdarg.h>
  70. #include <pthread_debug.h>

  72. ‌#define VMS_PAGE_SIZE 0x2000
  73. ‌#define VMS_PAGE_MASK (VMS_PAGE_SIZE - 1)

  75. /* Declared in lib$ots.  */
  76. extern void ots$fill (void *addr, size_t len, unsigned char b);
  77. extern void ots$move (void *dst, size_t len, const void *src);
  78. extern int ots$strcmp_eql (const void *str1, size_t str1len,
  79.                            const void *str2, size_t str2len);

  81. /* Stub port number.  */
  82. ‌static unsigned int serv_port = 1234;

  84. /* DBGEXT structure.  Not declared in any header.  */
  85. ‌struct dbgext_control_block
  86. {
  87.   unsigned short dbgext$w_function_code;
  88. ‌#define DBGEXT$K_NEXT_TASK              3
  89. ‌#define DBGEXT$K_STOP_ALL_OTHER_TASKS 31
  90. ‌#define DBGEXT$K_GET_REGS 33
  91.   unsigned short dbgext$w_facility_id;
  92. ‌#define CMA$_FACILITY 64
  93.   unsigned int dbgext$l_status;
  94.   unsigned int dbgext$l_flags;
  95.   unsigned int dbgext$l_print_routine;
  96.   unsigned int dbgext$l_evnt_code;
  97.   unsigned int dbgext$l_evnt_name;
  98.   unsigned int dbgext$l_evnt_entry;
  99.   unsigned int dbgext$l_task_value;
  100.   unsigned int dbgext$l_task_number;
  101.   unsigned int dbgext$l_ada_flags;
  102.   unsigned int dbgext$l_stop_value;
  103. ‌#define dbgext$l_priority   dbgext$l_stop_value;
  104. ‌#define dbgext$l_symb_addr  dbgext$l_stop_value;
  105. ‌#define dbgext$l_time_slice dbgext$l_stop_value;
  106.   unsigned int dbgext$l_active_registers;
  107. };

  109. #pragma pointer_size save
  110. #pragma pointer_size 32

  112. /* Pthread handler.  */
  113. ‌static int (*dbgext_func) (struct dbgext_control_block *blk);

  115. #pragma pointer_size restore

  117. /* Set to 1 if thread-aware.  */
  118. ‌static int has_threads;

  120. /* Current thread.  */
  121. ‌static pthread_t selected_thread;
  122. ‌static pthreadDebugId_t selected_id;

  124. /* Internal debugging flags.  */
  125. ‌struct debug_flag
  126. {
  127.   /* Name of the flag (as a string descriptor).  */
  128.   const struct dsc$descriptor_s name;
  129.   /* Value.  */
  130.   int val;
  131. };

  133. /* Macro to define a debugging flag.  */
  134. ‌#define DEBUG_FLAG_ENTRY(str) \
  135.   { { sizeof (str) - 1, DSC$K_DTYPE_T, DSC$K_CLASS_S, str }, 0}

  137. ‌static struct debug_flag debug_flags[] =
  138. {
  139.   /* Disp packets exchanged with gdb.  */
  140.   DEBUG_FLAG_ENTRY("packets"),
  141. ‌#define trace_pkt (debug_flags[0].val)
  142.   /* Display entry point informations.  */
  143.   DEBUG_FLAG_ENTRY("entry"),
  144. ‌#define trace_entry (debug_flags[1].val)
  145.   /* Be verbose about exceptions.  */
  146.   DEBUG_FLAG_ENTRY("excp"),
  147. ‌#define trace_excp (debug_flags[2].val)
  148.   /* Be verbose about unwinding.  */
  149.   DEBUG_FLAG_ENTRY("unwind"),
  150. ‌#define trace_unwind (debug_flags[3].val)
  151.   /* Display image at startup.  */
  152.   DEBUG_FLAG_ENTRY("images"),
  153. ‌#define trace_images (debug_flags[4].val)
  154.   /* Display pthread_debug info.  */
  155.   DEBUG_FLAG_ENTRY("pthreaddbg")
  156. ‌#define trace_pthreaddbg (debug_flags[5].val)
  157. };

  159. ‌#define NBR_DEBUG_FLAGS (sizeof (debug_flags) / sizeof (debug_flags[0]))

  161. /* Connect inet device I/O channel.  */
  162. ‌static unsigned short conn_channel;

  164. /* Widely used hex digit to ascii.  */
  165. ‌static const char hex[] = "0123456789abcdef";

  167. /* Socket characteristics.  Apparently, there are no declaration for it in
  168.    standard headers.  */
  169. ‌struct sockchar
  170. {
  171.   unsigned short prot;
  172.   unsigned char type;
  173.   unsigned char af;
  174. };

  176. /* Chain of images loaded.  */
  177. extern IMCB* ctl$gl_imglstptr;

  179. /* IA64 integer register representation.  */
  180. ‌union ia64_ireg
  181. {
  182.   unsigned __int64 v;
  183.   unsigned char b[8];
  184. };

  186. /* IA64 register numbers, as defined by ia64-tdep.h.  */
  187. ‌#define IA64_GR0_REGNUM                0
  188. ‌#define IA64_GR32_REGNUM        (IA64_GR0_REGNUM + 32)

  190. /* Floating point registers; 128 82-bit wide registers.  */
  191. ‌#define IA64_FR0_REGNUM                128

  193. /* Predicate registers; There are 64 of these one bit registers.  It'd
  194.    be more convenient (implementation-wise) to use a single 64 bit
  195.    word with all of these register in them.  Note that there's also a
  196.    IA64_PR_REGNUM below which contains all the bits and is used for
  197.    communicating the actual values to the target.  */
  198. ‌#define IA64_PR0_REGNUM                256

  200. /* Branch registers: 8 64-bit registers for holding branch targets.  */
  201. ‌#define IA64_BR0_REGNUM                320

  203. /* Virtual frame pointer; this matches IA64_FRAME_POINTER_REGNUM in
  204.    gcc/config/ia64/ia64.h.  */
  205. ‌#define IA64_VFP_REGNUM                328

  207. /* Virtual return address pointer; this matches
  208.    IA64_RETURN_ADDRESS_POINTER_REGNUM in gcc/config/ia64/ia64.h.  */
  209. ‌#define IA64_VRAP_REGNUM        329

  211. /* Predicate registers: There are 64 of these 1-bit registers.  We
  212.    define a single register which is used to communicate these values
  213.    to/from the target.  We will somehow contrive to make it appear
  214.    that IA64_PR0_REGNUM thru IA64_PR63_REGNUM hold the actual values.  */
  215. ‌#define IA64_PR_REGNUM                330

  217. /* Instruction pointer: 64 bits wide.  */
  218. ‌#define IA64_IP_REGNUM                331

  220. /* Process Status Register.  */
  221. ‌#define IA64_PSR_REGNUM                332

  223. /* Current Frame Marker (raw form may be the cr.ifs).  */
  224. ‌#define IA64_CFM_REGNUM                333

  226. /* Application registers; 128 64-bit wide registers possible, but some
  227.    of them are reserved.  */
  228. ‌#define IA64_AR0_REGNUM                334
  229. ‌#define IA64_KR0_REGNUM                (IA64_AR0_REGNUM + 0)
  230. ‌#define IA64_KR7_REGNUM                (IA64_KR0_REGNUM + 7)

  232. ‌#define IA64_RSC_REGNUM                (IA64_AR0_REGNUM + 16)
  233. ‌#define IA64_BSP_REGNUM                (IA64_AR0_REGNUM + 17)
  234. ‌#define IA64_BSPSTORE_REGNUM        (IA64_AR0_REGNUM + 18)
  235. ‌#define IA64_RNAT_REGNUM        (IA64_AR0_REGNUM + 19)
  236. ‌#define IA64_FCR_REGNUM                (IA64_AR0_REGNUM + 21)
  237. ‌#define IA64_EFLAG_REGNUM        (IA64_AR0_REGNUM + 24)
  238. ‌#define IA64_CSD_REGNUM                (IA64_AR0_REGNUM + 25)
  239. ‌#define IA64_SSD_REGNUM                (IA64_AR0_REGNUM + 26)
  240. ‌#define IA64_CFLG_REGNUM        (IA64_AR0_REGNUM + 27)
  241. ‌#define IA64_FSR_REGNUM                (IA64_AR0_REGNUM + 28)
  242. ‌#define IA64_FIR_REGNUM                (IA64_AR0_REGNUM + 29)
  243. ‌#define IA64_FDR_REGNUM                (IA64_AR0_REGNUM + 30)
  244. ‌#define IA64_CCV_REGNUM                (IA64_AR0_REGNUM + 32)
  245. ‌#define IA64_UNAT_REGNUM        (IA64_AR0_REGNUM + 36)
  246. ‌#define IA64_FPSR_REGNUM        (IA64_AR0_REGNUM + 40)
  247. ‌#define IA64_ITC_REGNUM                (IA64_AR0_REGNUM + 44)
  248. ‌#define IA64_PFS_REGNUM                (IA64_AR0_REGNUM + 64)
  249. ‌#define IA64_LC_REGNUM                (IA64_AR0_REGNUM + 65)
  250. ‌#define IA64_EC_REGNUM                (IA64_AR0_REGNUM + 66)

  252. /* NAT (Not A Thing) Bits for the general registers; there are 128 of
  253.    these.  */
  254. ‌#define IA64_NAT0_REGNUM        462

  256. /* Process registers when a condition is caught.  */
  257. ‌struct ia64_all_regs
  258. {
  259.   union ia64_ireg gr[32];
  260.   union ia64_ireg br[8];
  261.   union ia64_ireg ip;
  262.   union ia64_ireg psr;
  263.   union ia64_ireg bsp;
  264.   union ia64_ireg cfm;
  265.   union ia64_ireg pfs;
  266.   union ia64_ireg pr;
  267. };

  269. ‌static struct ia64_all_regs excp_regs;
  270. ‌static struct ia64_all_regs sel_regs;
  271. ‌static pthread_t sel_regs_pthread;

  273. /* IO channel for the terminal.  */
  274. ‌static unsigned short term_chan;

  276. /* Output buffer and length.  */
  277. ‌static char term_buf[128];
  278. ‌static int term_buf_len;

  280. /* Buffer for communication with gdb.  */
  281. ‌static unsigned char gdb_buf[sizeof (struct ia64_all_regs) * 2 + 64];
  282. ‌static unsigned int gdb_blen;

  284. /* Previous primary handler.  */
  285. ‌static void *prevhnd;

  287. /* Entry point address and bundle.  */
  288. ‌static unsigned __int64 entry_pc;
  289. ‌static unsigned char entry_saved[16];

  291. /* Write on the terminal.  */

  293. static void
  294. ‌term_raw_write (const char *str, unsigned int len)
  295. {
  296.   unsigned short status;
  297.   struct _iosb iosb;

  299.   status = sys$qiow (EFN$C_ENF,           /* Event flag.  */
  300.                      term_chan,           /* I/O channel.  */
  301.                      IO$_WRITEVBLK,       /* I/O function code.  */
  302.                      &iosb,               /* I/O status block.  */
  303.                      0,                   /* Ast service routine.  */
  304.                      0,                   /* Ast parameter.  */
  305.                      (char *)str,         /* P1 - buffer address.  */
  306.                      len,                 /* P2 - buffer length.  */
  307.                      0, 0, 0, 0);

  309.   if (status & STS$M_SUCCESS)
  310.     status = iosb.iosb$w_status;
  311.   if (!(status & STS$M_SUCCESS))
  312.     LIB$SIGNAL (status);
  313. }

  315. /* Flush ther term buffer.  */

  317. static void
  318. ‌term_flush (void)
  319. {
  320.   if (term_buf_len != 0)
  321.     {
  322.       term_raw_write (term_buf, term_buf_len);
  323.       term_buf_len = 0;
  324.     }
  325. }

  327. /* Write a single character, without translation.  */

  329. static void
  330. ‌term_raw_putchar (char c)
  331. {
  332.   if (term_buf_len == sizeof (term_buf))
  333.     term_flush ();
  334.   term_buf[term_buf_len++] = c;
  335. }

  337. /* Write character C.  Translate '\n' to '\n\r'.  */

  339. static void
  340. ‌term_putc (char c)
  341. {
  342.   if (c < 32)
  343.     switch (c)
  344.       {
  345.       case '\r':
  346.       case '\n':
  347.         break;
  348.       default:
  349.         c = '.';
  350.         break;
  351.       }
  352.   term_raw_putchar (c);
  353.   if (c == '\n')
  354.     {
  355.       term_raw_putchar ('\r');
  356.       term_flush ();
  357.     }
  358. }

  360. /* Write a C string.  */

  362. static void
  363. ‌term_puts (const char *str)
  364. {
  365.   while (*str)
  366.     term_putc (*str++);
  367. }

  369. /* Write LEN bytes from STR.  */

  371. static void
  372. ‌term_write (const char *str, unsigned int len)
  373. {
  374.   for (; len > 0; len--)
  375.     term_putc (*str++);
  376. }

  378. /* Write using FAO formatting.  */

  380. static void
  381. ‌term_fao (const char *str, unsigned int str_len, ...)
  382. {
  383.   int cnt;
  384.   va_list vargs;
  385.   int i;
  386.   __int64 *args;
  387.   int status;
  388.   struct dsc$descriptor_s dstr =
  389.     { str_len, DSC$K_DTYPE_T, DSC$K_CLASS_S, (__char_ptr32)str };
  390.   char buf[128];
  391.   $DESCRIPTOR (buf_desc, buf);

  393.   va_start (vargs, str_len);
  394.   va_count (cnt);
  395.   args = (__int64 *) __ALLOCA (cnt * sizeof (__int64));
  396.   cnt -= 2;
  397.   for (i = 0; i < cnt; i++)
  398.     args[i] = va_arg (vargs, __int64);

  400.   status = sys$faol_64 (&dstr, &buf_desc.dsc$w_length, &buf_desc, args);
  401.   if (status & 1)
  402.     {
  403.       /* FAO !/ already insert a line feed.  */
  404.       for (i = 0; i < buf_desc.dsc$w_length; i++)
  405.         {
  406.           term_raw_putchar (buf[i]);
  407.           if (buf[i] == '\n')
  408.             term_flush ();
  409.         }
  410.     }

  412.   va_end (vargs);
  413. }

  415. ‌#define TERM_FAO(STR, ...) term_fao (STR, sizeof (STR) - 1, __VA_ARGS__)

  417. /* New line.  */

  419. static void
  420. ‌term_putnl (void)
  421. {
  422.   term_putc ('\n');
  423. }

  425. /* Initialize terminal.  */

  427. static void
  428. ‌term_init (void)
  429. {
  430.   unsigned int status,i;
  431.   unsigned short len;
  432.   char resstring[LNM$C_NAMLENGTH];
  433.   static const $DESCRIPTOR (tabdesc, "LNM$FILE_DEV");
  434.   static const $DESCRIPTOR (logdesc, "SYS$OUTPUT");
  435.   $DESCRIPTOR (term_desc, resstring);
  436.   ILE3 item_lst[2];

  438.   item_lst[0].ile3$w_length = LNM$C_NAMLENGTH;
  439.   item_lst[0].ile3$w_code = LNM$_STRING;
  440.   item_lst[0].ile3$ps_bufaddr = resstring;
  441.   item_lst[0].ile3$ps_retlen_addr = &len;
  442.   item_lst[1].ile3$w_length = 0;
  443.   item_lst[1].ile3$w_code = 0;

  445.   /* Translate the logical name.  */
  446.   status = SYS$TRNLNM (0,                    /* Attr of the logical name.  */
  447.                        (void *) &tabdesc, /* Logical name table.  */
  448.                        (void *) &logdesc, /* Logical name.  */
  449.                        0,          /* Access mode.  */
  450.                        item_lst);  /* Item list.  */
  451.   if (!(status & STS$M_SUCCESS))
  452.     LIB$SIGNAL (status);

  454.   term_desc.dsc$w_length = len;

  456.   /* Examine 4-byte header.  Skip escape sequence.  */
  457.   if (resstring[0] == 0x1B)
  458.     {
  459.       term_desc.dsc$w_length -= 4;
  460.       term_desc.dsc$a_pointer += 4;
  461.     }

  463.   /* Assign a channel.  */
  464.   status = sys$assign (&term_desc,   /* Device name.  */
  465.                        &term_chan,   /* I/O channel.  */
  466.                        0,            /* Access mode.  */
  467.                        0);
  468.   if (!(status & STS$M_SUCCESS))
  469.     LIB$SIGNAL (status);
  470. }

  472. /* Convert from native endianness to network endianness (and vice-versa).  */

  474. static unsigned int
  475. ‌wordswap (unsigned int v)
  476. {
  477.   return ((v & 0xff) << 8) | ((v >> 8) & 0xff);
  478. }

  480. /* Initialize the socket connection, and wait for a client.  */

  482. static void
  483. ‌sock_init (void)
  484. {
  485.   struct _iosb iosb;
  486.   unsigned int status;

  488.   /* Listen channel and characteristics.  */
  489.   unsigned short listen_channel;
  490.   struct sockchar listen_sockchar;

  492.   /* Client address.  */
  493.   unsigned short cli_addrlen;
  494.   struct sockaddr_in cli_addr;
  495.   ILE3 cli_itemlst;

  497.   /* Our address.  */
  498.   struct sockaddr_in serv_addr;
  499.   ILE2 serv_itemlst;

  501.   /* Reuseaddr option value (on).  */
  502.   int optval = 1;
  503.   ILE2 sockopt_itemlst;
  504.   ILE2 reuseaddr_itemlst;

  506.   /* TCP/IP network pseudodevice.  */
  507.   static const $DESCRIPTOR (inet_device, "TCPIP$DEVICE:");

  509.   /* Initialize socket characteristics.  */
  510.   listen_sockchar.prot = TCPIP$C_TCP;
  511.   listen_sockchar.type = TCPIP$C_STREAM;
  512.   listen_sockchar.af   = TCPIP$C_AF_INET;

  514.   /* Assign I/O channels to network device.  */
  515.   status = sys$assign ((void *) &inet_device, &listen_channel, 0, 0);
  516.   if (status & STS$M_SUCCESS)
  517.     status = sys$assign ((void *) &inet_device, &conn_channel, 0, 0);
  518.   if (!(status & STS$M_SUCCESS))
  519.     {
  520.       term_puts ("Failed to assign I/O channel(s)\n");
  521.       LIB$SIGNAL (status);
  522.     }

  524.   /* Create a listen socket.  */
  525.   status = sys$qiow (EFN$C_ENF,           /* Event flag.  */
  526.                      listen_channel,      /* I/O channel.  */
  527.                      IO$_SETMODE,         /* I/O function code.  */
  528.                      &iosb,               /* I/O status block.  */
  529.                      0,                   /* Ast service routine.  */
  530.                      0,                   /* Ast parameter.  */
  531.                      &listen_sockchar,    /* P1 - socket characteristics.  */
  532.                      0, 0, 0, 0, 0);
  533.   if (status & STS$M_SUCCESS)
  534.     status = iosb.iosb$w_status;
  535.   if (!(status & STS$M_SUCCESS))
  536.     {
  537.       term_puts ("Failed to create socket\n");
  538.       LIB$SIGNAL (status);
  539.     }

  541.   /* Set reuse address option.  */
  542.   /* Initialize reuseaddr's item-list element.  */
  543.   reuseaddr_itemlst.ile2$w_length   = sizeof (optval);
  544.   reuseaddr_itemlst.ile2$w_code     = TCPIP$C_REUSEADDR;
  545.   reuseaddr_itemlst.ile2$ps_bufaddr = &optval;

  547.   /* Initialize setsockopt's item-list descriptor.  */
  548.   sockopt_itemlst.ile2$w_length   = sizeof (reuseaddr_itemlst);
  549.   sockopt_itemlst.ile2$w_code     = TCPIP$C_SOCKOPT;
  550.   sockopt_itemlst.ile2$ps_bufaddr = &reuseaddr_itemlst;

  552.   status = sys$qiow (EFN$C_ENF,       /* Event flag.  */
  553.                      listen_channel,  /* I/O channel.  */
  554.                      IO$_SETMODE,     /* I/O function code.  */
  555.                      &iosb,           /* I/O status block.  */
  556.                      0,               /* Ast service routine.  */
  557.                      0,               /* Ast parameter.  */
  558.                      0,               /* P1.  */
  559.                      0,               /* P2.  */
  560.                      0,               /* P3.  */
  561.                      0,               /* P4.  */
  562.                      (__int64) &sockopt_itemlst, /* P5 - socket options.  */
  563.                      0);
  564.   if (status & STS$M_SUCCESS)
  565.     status = iosb.iosb$w_status;
  566.   if (!(status & STS$M_SUCCESS))
  567.     {
  568.       term_puts ("Failed to set socket option\n");
  569.       LIB$SIGNAL (status);
  570.     }

  572.   /* Bind server's ip address and port number to listen socket.  */
  573.   /* Initialize server's socket address structure.  */
  574.   ots$fill (&serv_addr, sizeof (serv_addr), 0);
  575.   serv_addr.sin_family = TCPIP$C_AF_INET;
  576.   serv_addr.sin_port = wordswap (serv_port);
  577.   serv_addr.sin_addr.s_addr = TCPIP$C_INADDR_ANY;

  579.   /* Initialize server's item-list descriptor.  */
  580.   serv_itemlst.ile2$w_length   = sizeof (serv_addr);
  581.   serv_itemlst.ile2$w_code     = TCPIP$C_SOCK_NAME;
  582.   serv_itemlst.ile2$ps_bufaddr = &serv_addr;

  584.   status = sys$qiow (EFN$C_ENF,           /* Event flag.  */
  585.                      listen_channel,      /* I/O channel.  */
  586.                      IO$_SETMODE,         /* I/O function code.  */
  587.                      &iosb,               /* I/O status block.  */
  588.                      0,                   /* Ast service routine.  */
  589.                      0,                   /* Ast parameter.  */
  590.                      0,                   /* P1.  */
  591.                      0,                   /* P2.  */
  592.                      (__int64) &serv_itemlst, /* P3 - local socket name.  */
  593.                      0, 0, 0);
  594.   if (status & STS$M_SUCCESS)
  595.     status = iosb.iosb$w_status;
  596.   if (!(status & STS$M_SUCCESS))
  597.     {
  598.       term_puts ("Failed to bind socket\n");
  599.       LIB$SIGNAL (status);
  600.     }

  602.   /* Set socket as a listen socket.  */
  603.   status = sys$qiow (EFN$C_ENF,           /* Event flag.  */
  604.                      listen_channel,      /* I/O channel.  */
  605.                      IO$_SETMODE,         /* I/O function code.  */
  606.                      &iosb,               /* I/O status block.  */
  607.                      0,                   /* Ast service routine.  */
  608.                      0,                   /* Ast parameter.  */
  609.                      0,                   /* P1.  */
  610.                      0,                   /* P2.  */
  611.                      0,                   /* P3.  */
  612.                      1,                   /* P4 - connection backlog.  */
  613.                      0, 0);
  614.   if (status & STS$M_SUCCESS)
  615.     status = iosb.iosb$w_status;
  616.   if (!(status & STS$M_SUCCESS))
  617.     {
  618.       term_puts ("Failed to set socket passive\n");
  619.       LIB$SIGNAL (status);
  620.     }

  622.   /* Accept connection from a client.  */
  623.   TERM_FAO ("Waiting for a client connection on port: !ZW!/",
  624.             wordswap (serv_addr.sin_port));

  626.   status = sys$qiow (EFN$C_ENF,              /* Event flag.  */
  627.                      listen_channel,         /* I/O channel.  */
  628.                      IO$_ACCESS|IO$M_ACCEPT, /* I/O function code.  */
  629.                      &iosb,                  /* I/O status block.  */
  630.                      0,                      /* Ast service routine.  */
  631.                      0,                      /* Ast parameter.  */
  632.                      0,                      /* P1.  */
  633.                      0,                      /* P2.  */
  634.                      0,                      /* P3.  */
  635.                      (__int64) &conn_channel, /* P4 - I/O channel for conn.  */
  636.                      0, 0);

  638.   if (status & STS$M_SUCCESS)
  639.     status = iosb.iosb$w_status;
  640.   if (!(status & STS$M_SUCCESS))
  641.     {
  642.       term_puts ("Failed to accept client connection\n");
  643.       LIB$SIGNAL (status);
  644.     }

  646.   /* Log client connection request.  */
  647.   cli_itemlst.ile3$w_length = sizeof (cli_addr);
  648.   cli_itemlst.ile3$w_code = TCPIP$C_SOCK_NAME;
  649.   cli_itemlst.ile3$ps_bufaddr = &cli_addr;
  650.   cli_itemlst.ile3$ps_retlen_addr = &cli_addrlen;
  651.   ots$fill (&cli_addr, sizeof(cli_addr), 0);
  652.   status = sys$qiow (EFN$C_ENF,           /* Event flag.  */
  653.                      conn_channel,        /* I/O channel.  */
  654.                      IO$_SENSEMODE,       /* I/O function code.  */
  655.                      &iosb,               /* I/O status block.  */
  656.                      0,                   /* Ast service routine.  */
  657.                      0,                   /* Ast parameter.  */
  658.                      0,                   /* P1.  */
  659.                      0,                   /* P2.  */
  660.                      0,                   /* P3.  */
  661.                      (__int64) &cli_itemlst,  /* P4 - peer socket name.  */
  662.                      0, 0);
  663.   if (status & STS$M_SUCCESS)
  664.     status = iosb.iosb$w_status;
  665.   if (!(status & STS$M_SUCCESS))
  666.     {
  667.       term_puts ("Failed to get client name\n");
  668.       LIB$SIGNAL (status);
  669.     }

  671.   TERM_FAO ("Accepted connection from host: !UB.!UB,!UB.!UB, port: !UW!/",
  672.             (cli_addr.sin_addr.s_addr >> 0) & 0xff,
  673.             (cli_addr.sin_addr.s_addr >> 8) & 0xff,
  674.             (cli_addr.sin_addr.s_addr >> 16) & 0xff,
  675.             (cli_addr.sin_addr.s_addr >> 24) & 0xff,
  676.             wordswap (cli_addr.sin_port));
  677. }

  679. /* Close the socket.  */

  681. static void
  682. ‌sock_close (void)
  683. {
  684.   struct _iosb iosb;
  685.   unsigned int status;

  687.   /* Close socket.  */
  688.   status = sys$qiow (EFN$C_ENF,           /* Event flag.  */
  689.                      conn_channel,        /* I/O channel.  */
  690.                      IO$_DEACCESS,        /* I/O function code.  */
  691.                      &iosb,               /* I/O status block.  */
  692.                      0,                   /* Ast service routine.  */
  693.                      0,                   /* Ast parameter.  */
  694.                      0, 0, 0, 0, 0, 0);

  696.   if (status & STS$M_SUCCESS)
  697.     status = iosb.iosb$w_status;
  698.   if (!(status & STS$M_SUCCESS))
  699.     {
  700.       term_puts ("Failed to close socket\n");
  701.       LIB$SIGNAL (status);
  702.     }

  704.   /* Deassign I/O channel to network device.  */
  705.   status = sys$dassgn (conn_channel);

  707.   if (!(status & STS$M_SUCCESS))
  708.     {
  709.       term_puts ("Failed to deassign I/O channel\n");
  710.       LIB$SIGNAL (status);
  711.     }
  712. }

  714. /* Mark a page as R/W.  Return old rights.  */

  716. static unsigned int
  717. ‌page_set_rw (unsigned __int64 startva, unsigned __int64 len,
  718.              unsigned int *oldprot)
  719. {
  720.   unsigned int status;
  721.   unsigned __int64 retva;
  722.   unsigned __int64 retlen;

  724.   status = SYS$SETPRT_64 ((void *)startva, len, PSL$C_USER, PRT$C_UW,
  725.                           (void *)&retva, &retlen, oldprot);
  726.   return status;
  727. }

  729. /* Restore page rights.  */

  731. static void
  732. ‌page_restore_rw (unsigned __int64 startva, unsigned __int64 len,
  733.                 unsigned int prot)
  734. {
  735.   unsigned int status;
  736.   unsigned __int64 retva;
  737.   unsigned __int64 retlen;
  738.   unsigned int oldprot;

  740.   status = SYS$SETPRT_64 ((void *)startva, len, PSL$C_USER, prot,
  741.                           (void *)&retva, &retlen, &oldprot);
  742.   if (!(status & STS$M_SUCCESS))
  743.     LIB$SIGNAL (status);
  744. }

  746. /* Get the TEB (thread environment block).  */

  748. static pthread_t
  749. ‌get_teb (void)
  750. {
  751.   return (pthread_t)__getReg (_IA64_REG_TP);
  752. }

  754. /* Enable thread scheduling if VAL is true.  */

  756. static unsigned int
  757. ‌set_thread_scheduling (int val)
  758. {
  759.   struct dbgext_control_block blk;
  760.   unsigned int status;

  762.   if (!dbgext_func)
  763.     return 0;

  765.   blk.dbgext$w_function_code = DBGEXT$K_STOP_ALL_OTHER_TASKS;
  766.   blk.dbgext$w_facility_id = CMA$_FACILITY;
  767.   blk.dbgext$l_stop_value = val;

  769.   status = dbgext_func (&blk);
  770.   if (!(status & STS$M_SUCCESS))
  771.     {
  772.       TERM_FAO ("set_thread_scheduling error, val=!SL, status=!XL!/",
  773.                 val, blk.dbgext$l_status);
  774.       lib$signal (status);
  775.     }

  777.   return blk.dbgext$l_stop_value;
  778. }

  780. /* Get next thead (after THR).  Start with 0.  */

  782. static unsigned int
  783. ‌thread_next (unsigned int thr)
  784. {
  785.   struct dbgext_control_block blk;
  786.   unsigned int status;

  788.   if (!dbgext_func)
  789.     return 0;

  791.   blk.dbgext$w_function_code = DBGEXT$K_NEXT_TASK;
  792.   blk.dbgext$w_facility_id = CMA$_FACILITY;
  793.   blk.dbgext$l_ada_flags = 0;
  794.   blk.dbgext$l_task_value = thr;

  796.   status = dbgext_func (&blk);
  797.   if (!(status & STS$M_SUCCESS))
  798.     lib$signal (status);

  800.   return blk.dbgext$l_task_value;
  801. }

  803. /* Pthread Debug callbacks.  */

  805. static int
  806. ‌read_callback (pthreadDebugClient_t context,
  807.                pthreadDebugTargetAddr_t addr,
  808.                pthreadDebugAddr_t buf,
  809.                size_t size)
  810. {
  811.   if (trace_pthreaddbg)
  812.     TERM_FAO ("read_callback (!XH, !XH, !SL)!/", addr, buf, size);
  813.   ots$move (buf, size, addr);
  814.   return 0;
  815. }

  817. static int
  818. ‌write_callback (pthreadDebugClient_t context,
  819.                 pthreadDebugTargetAddr_t addr,
  820.                 pthreadDebugLongConstAddr_t buf,
  821.                 size_t size)
  822. {
  823.   if (trace_pthreaddbg)
  824.     TERM_FAO ("write_callback (!XH, !XH, !SL)!/", addr, buf, size);
  825.   ots$move (addr, size, buf);
  826.   return 0;
  827. }

  829. static int
  830. ‌suspend_callback (pthreadDebugClient_t context)
  831. {
  832.   /* Always suspended.  */
  833.   return 0;
  834. }

  836. static int
  837. ‌resume_callback (pthreadDebugClient_t context)
  838. {
  839.   /* So no need to resume.  */
  840.   return 0;
  841. }

  843. static int
  844. ‌kthdinfo_callback (pthreadDebugClient_t context,
  845.                    pthreadDebugKId_t kid,
  846.                    pthreadDebugKThreadInfo_p thread_info)
  847. {
  848.   if (trace_pthreaddbg)
  849.     term_puts ("kthinfo_callback");
  850.   return ENOSYS;
  851. }

  853. static int
  854. ‌hold_callback (pthreadDebugClient_t context,
  855.                pthreadDebugKId_t kid)
  856. {
  857.   if (trace_pthreaddbg)
  858.     term_puts ("hold_callback");
  859.   return ENOSYS;
  860. }

  862. static int
  863. ‌unhold_callback (pthreadDebugClient_t context,
  864.                  pthreadDebugKId_t kid)
  865. {
  866.   if (trace_pthreaddbg)
  867.     term_puts ("unhold_callback");
  868.   return ENOSYS;
  869. }

  871. static int
  872. ‌getfreg_callback (pthreadDebugClient_t context,
  873.                   pthreadDebugFregs_t *reg,
  874.                   pthreadDebugKId_t kid)
  875. {
  876.   if (trace_pthreaddbg)
  877.     term_puts ("getfreg_callback");
  878.   return ENOSYS;
  879. }

  881. static int
  882. ‌setfreg_callback (pthreadDebugClient_t context,
  883.                   const pthreadDebugFregs_t *reg,
  884.                   pthreadDebugKId_t kid)
  885. {
  886.   if (trace_pthreaddbg)
  887.     term_puts ("setfreg_callback");
  888.   return ENOSYS;
  889. }

  891. static int
  892. ‌getreg_callback (pthreadDebugClient_t context,
  893.                  pthreadDebugRegs_t *reg,
  894.                  pthreadDebugKId_t kid)
  895. {
  896.   if (trace_pthreaddbg)
  897.     term_puts ("getreg_callback");
  898.   return ENOSYS;
  899. }

  901. static int
  902. ‌setreg_callback (pthreadDebugClient_t context,
  903.                  const pthreadDebugRegs_t *reg,
  904.                  pthreadDebugKId_t kid)
  905. {
  906.   if (trace_pthreaddbg)
  907.     term_puts ("setreg_callback");
  908.   return ENOSYS;
  909. }

  911. static int
  912. ‌output_callback (pthreadDebugClient_t context,
  913.                  pthreadDebugConstString_t line)
  914. {
  915.   term_puts (line);
  916.   term_putnl ();
  917.   return 0;
  918. }

  920. static int
  921. ‌error_callback (pthreadDebugClient_t context,
  922.                  pthreadDebugConstString_t line)
  923. {
  924.   term_puts (line);
  925.   term_putnl ();
  926.   return 0;
  927. }

  929. static pthreadDebugAddr_t
  930. ‌malloc_callback (pthreadDebugClient_t caller_context, size_t size)
  931. {
  932.   unsigned int status;
  933.   unsigned int res;
  934.   int len;

  936.   len = size + 16;
  937.   status = lib$get_vm (&len, &res, 0);
  938.   if (!(status & STS$M_SUCCESS))
  939.     LIB$SIGNAL (status);
  940.   if (trace_pthreaddbg)
  941.     TERM_FAO ("malloc_callback (!UL) -> !XA!/", size, res);
  942.   *(unsigned int *)res = len;
  943.   return (char *)res + 16;
  944. }

  946. static void
  947. ‌free_callback (pthreadDebugClient_t caller_context, pthreadDebugAddr_t address)
  948. {
  949.   unsigned int status;
  950.   unsigned int res;
  951.   int len;

  953.   res = (unsigned int)address - 16;
  954.   len = *(unsigned int *)res;
  955.   if (trace_pthreaddbg)
  956.     TERM_FAO ("free_callback (!XA)!/", address);
  957.   status = lib$free_vm (&len, &res, 0);
  958.   if (!(status & STS$M_SUCCESS))
  959.     LIB$SIGNAL (status);
  960. }

  962. static int
  963. ‌speckthd_callback (pthreadDebugClient_t caller_context,
  964.                    pthreadDebugSpecialType_t type,
  965.                    pthreadDebugKId_t *kernel_tid)
  966. {
  967.   return ENOTSUP;
  968. }

  970. ‌static pthreadDebugCallbacks_t pthread_debug_callbacks = {
  971.   PTHREAD_DEBUG_VERSION,
  972.   read_callback,
  973.   write_callback,
  974.   suspend_callback,
  975.   resume_callback,
  976.   kthdinfo_callback,
  977.   hold_callback,
  978.   unhold_callback,
  979.   getfreg_callback,
  980.   setfreg_callback,
  981.   getreg_callback,
  982.   setreg_callback,
  983.   output_callback,
  984.   error_callback,
  985.   malloc_callback,
  986.   free_callback,
  987.   speckthd_callback
  988. };

  990. /* Name of the pthread shared library.  */
  991. static const $DESCRIPTOR (pthread_rtl_desc, "PTHREAD$RTL");

  993. /* List of symbols to extract from pthread debug library.  */
  994. ‌struct pthread_debug_entry
  995. {
  996.   const unsigned int namelen;
  997.   const __char_ptr32 name;
  998.   __void_ptr32 func;
  999. };

  1001. ‌#define DEBUG_ENTRY(str) { sizeof(str) - 1, str, 0 }

  1003. ‌static struct pthread_debug_entry pthread_debug_entries[] = {
  1004.   DEBUG_ENTRY("pthreadDebugContextInit"),
  1005.   DEBUG_ENTRY("pthreadDebugThdSeqInit"),
  1006.   DEBUG_ENTRY("pthreadDebugThdSeqNext"),
  1007.   DEBUG_ENTRY("pthreadDebugThdSeqDestroy"),
  1008.   DEBUG_ENTRY("pthreadDebugThdGetInfo"),
  1009.   DEBUG_ENTRY("pthreadDebugThdGetInfoAddr"),
  1010.   DEBUG_ENTRY("pthreadDebugThdGetReg"),
  1011.   DEBUG_ENTRY("pthreadDebugCmd")
  1012. };

  1014. /* Pthread debug context.  */
  1015. ‌static pthreadDebugContext_t debug_context;

  1017. /* Wrapper around pthread debug entry points.  */

  1019. static int
  1020. ‌pthread_debug_thd_seq_init (pthreadDebugId_t *id)
  1021. {
  1022.   return ((int (*)())pthread_debug_entries[1].func)
  1023.     (debug_context, id);
  1024. }

  1026. static int
  1027. ‌pthread_debug_thd_seq_next (pthreadDebugId_t *id)
  1028. {
  1029.   return ((int (*)())pthread_debug_entries[2].func)
  1030.     (debug_context, id);
  1031. }

  1033. static int
  1034. ‌pthread_debug_thd_seq_destroy (void)
  1035. {
  1036.   return ((int (*)())pthread_debug_entries[3].func)
  1037.     (debug_context);
  1038. }

  1040. static int
  1041. ‌pthread_debug_thd_get_info (pthreadDebugId_t id,
  1042.                             pthreadDebugThreadInfo_t *info)
  1043. {
  1044.   return ((int (*)())pthread_debug_entries[4].func)
  1045.     (debug_context, id, info);
  1046. }

  1048. static int
  1049. ‌pthread_debug_thd_get_info_addr (pthread_t thr,
  1050.                                  pthreadDebugThreadInfo_t *info)
  1051. {
  1052.   return ((int (*)())pthread_debug_entries[5].func)
  1053.     (debug_context, thr, info);
  1054. }

  1056. static int
  1057. ‌pthread_debug_thd_get_reg (pthreadDebugId_t thr,
  1058.                            pthreadDebugRegs_t *regs)
  1059. {
  1060.   return ((int (*)())pthread_debug_entries[6].func)
  1061.     (debug_context, thr, regs);
  1062. }

  1064. static int
  1065. ‌stub_pthread_debug_cmd (const char *cmd)
  1066. {
  1067.   return ((int (*)())pthread_debug_entries[7].func)
  1068.     (debug_context, cmd);
  1069. }

  1071. /* Show all the threads.  */

  1073. static void
  1074. ‌threads_show (void)
  1075. {
  1076.   pthreadDebugId_t id;
  1077.   pthreadDebugThreadInfo_t info;
  1078.   int res;

  1080.   res = pthread_debug_thd_seq_init (&id);
  1081.   if (res != 0)
  1082.     {
  1083.       TERM_FAO ("seq init failed, res=!SL!/", res);
  1084.       return;
  1085.     }
  1086.   while (1)
  1087.     {
  1088.       if (pthread_debug_thd_get_info (id, &info) != 0)
  1089.         {
  1090.           TERM_FAO ("thd_get_info !SL failed!/", id);
  1091.           break;
  1092.         }
  1093.       if (pthread_debug_thd_seq_next (&id) != 0)
  1094.         break;
  1095.     }
  1096.   pthread_debug_thd_seq_destroy ();
  1097. }

  1099. /* Initialize pthread support.  */

  1101. static void
  1102. ‌threads_init (void)
  1103. {
  1104.   static const $DESCRIPTOR (dbgext_desc, "PTHREAD$DBGEXT");
  1105.   static const $DESCRIPTOR (pthread_debug_desc, "PTHREAD$DBGSHR");
  1106.   static const $DESCRIPTOR (dbgsymtable_desc, "PTHREAD_DBG_SYMTABLE");
  1107.   int pthread_dbgext;
  1108.   int status;
  1109.   void *dbg_symtable;
  1110.   int i;
  1111.   void *caller_context = 0;

  1113.   status = lib$find_image_symbol
  1114.     ((void *) &pthread_rtl_desc, (void *) &dbgext_desc,
  1115.      (int *) &dbgext_func);
  1116.   if (!(status & STS$M_SUCCESS))
  1117.     LIB$SIGNAL (status);

  1119.   status = lib$find_image_symbol
  1120.     ((void *) &pthread_rtl_desc, (void *) &dbgsymtable_desc,
  1121.      (int *) &dbg_symtable);
  1122.   if (!(status & STS$M_SUCCESS))
  1123.     LIB$SIGNAL (status);

  1125.   /* Find entry points in pthread_debug.  */
  1126.   for (i = 0;
  1127.        i < sizeof (pthread_debug_entries) / sizeof (pthread_debug_entries[0]);
  1128.        i++)
  1129.     {
  1130.       struct dsc$descriptor_s sym =
  1131.         { pthread_debug_entries[i].namelen,
  1132.           DSC$K_DTYPE_T, DSC$K_CLASS_S,
  1133.           pthread_debug_entries[i].name };
  1134.       status = lib$find_image_symbol
  1135.         ((void *) &pthread_debug_desc, (void *) &sym,
  1136.          (int *) &pthread_debug_entries[i].func);
  1137.       if (!(status & STS$M_SUCCESS))
  1138.         lib$signal (status);
  1139.     }

  1141.   if (trace_pthreaddbg)
  1142.     TERM_FAO ("debug symtable: !XH!/", dbg_symtable);
  1143.   status = ((int (*)()) pthread_debug_entries[0].func)
  1144.     (&caller_context, &pthread_debug_callbacks, dbg_symtable, &debug_context);
  1145.   if (status != 0)
  1146.     TERM_FAO ("cannot initialize pthread_debug: !UL!/", status);
  1147.   TERM_FAO ("pthread debug done!/", 0);
  1148. }

  1150. /* Convert an hexadecimal character to a nibble.  Return -1 in case of
  1151.    error.  */

  1153. static int
  1154. ‌hex2nibble (unsigned char h)
  1155. {
  1156.   if (h >= '0' && h <= '9')
  1157.     return h - '0';
  1158.   if (h >= 'A' && h <= 'F')
  1159.     return h - 'A' + 10;
  1160.   if (h >= 'a' && h <= 'f')
  1161.     return h - 'a' + 10;
  1162.   return -1;
  1163. }

  1165. /* Convert an hexadecimal 2 character string to a byte.  Return -1 in case
  1166.    of error.  */

  1168. static int
  1169. ‌hex2byte (const unsigned char *p)
  1170. {
  1171.   int h, l;

  1173.   h = hex2nibble (p[0]);
  1174.   l = hex2nibble (p[1]);
  1175.   if (h == -1 || l == -1)
  1176.     return -1;
  1177.   return (h << 4) | l;
  1178. }

  1180. /* Convert a byte V to a 2 character strings P.  */

  1182. static void
  1183. ‌byte2hex (unsigned char *p, unsigned char v)
  1184. {
  1185.   p[0] = hex[v >> 4];
  1186.   p[1] = hex[v & 0xf];
  1187. }

  1189. /* Convert a quadword V to a 16 character strings P.  */

  1191. static void
  1192. ‌quad2hex (unsigned char *p, unsigned __int64 v)
  1193. {
  1194.   int i;
  1195.   for (i = 0; i < 16; i++)
  1196.     {
  1197.       p[i] = hex[v >> 60];
  1198.       v <<= 4;
  1199.     }
  1200. }

  1202. static void
  1203. ‌long2pkt (unsigned int v)
  1204. {
  1205.   int i;

  1207.   for (i = 0; i < 8; i++)
  1208.     {
  1209.       gdb_buf[gdb_blen + i] = hex[(v >> 28) & 0x0f];
  1210.       v <<= 4;
  1211.     }
  1212.   gdb_blen += 8;
  1213. }

  1215. /* Generate an error packet.  */

  1217. static void
  1218. ‌packet_error (unsigned int err)
  1219. {
  1220.   gdb_buf[1] = 'E';
  1221.   byte2hex (gdb_buf + 2, err);
  1222.   gdb_blen = 4;
  1223. }

  1225. /* Generate an OK packet.  */

  1227. static void
  1228. ‌packet_ok (void)
  1229. {
  1230.   gdb_buf[1] = 'O';
  1231.   gdb_buf[2] = 'K';
  1232.   gdb_blen = 3;
  1233. }

  1235. /* Append a register to the packet.  */

  1237. static void
  1238. ‌ireg2pkt (const unsigned char *p)
  1239. {
  1240.   int i;

  1242.   for (i = 0; i < 8; i++)
  1243.     {
  1244.       byte2hex (gdb_buf + gdb_blen, p[i]);
  1245.       gdb_blen += 2;
  1246.     }
  1247. }

  1249. /* Append a C string (ASCIZ) to the packet.  */

  1251. static void
  1252. ‌str2pkt (const char *str)
  1253. {
  1254.   while (*str)
  1255.     gdb_buf[gdb_blen++] = *str++;
  1256. }

  1258. /* Extract a number fro the packet.  */

  1260. static unsigned __int64
  1261. ‌pkt2val (const unsigned char *pkt, unsigned int *pos)
  1262. {
  1263.   unsigned __int64 res = 0;
  1264.   unsigned int i;

  1266.   while (1)
  1267.     {
  1268.       int r = hex2nibble (pkt[*pos]);

  1270.       if (r < 0)
  1271.         return res;
  1272.       res = (res << 4) | r;
  1273.       (*pos)++;
  1274.     }
  1275. }

  1277. /* Append LEN bytes from B to the current gdb packet (encode in binary).  */

  1279. static void
  1280. ‌mem2bin (const unsigned char *b, unsigned int len)
  1281. {
  1282.   unsigned int i;
  1283.   for (i = 0; i < len; i++)
  1284.     switch (b[i])
  1285.       {
  1286.       case '#':
  1287.       case '$':
  1288.       case '}':
  1289.       case '*':
  1290.       case 0:
  1291.         gdb_buf[gdb_blen++] = '}';
  1292.         gdb_buf[gdb_blen++] = b[i] ^ 0x20;
  1293.         break;
  1294.       default:
  1295.         gdb_buf[gdb_blen++] = b[i];
  1296.         break;
  1297.       }
  1298. }

  1300. /* Append LEN bytes from B to the current gdb packet (encode in hex).  */

  1302. static void
  1303. ‌mem2hex (const unsigned char *b, unsigned int len)
  1304. {
  1305.   unsigned int i;
  1306.   for (i = 0; i < len; i++)
  1307.     {
  1308.       byte2hex (gdb_buf + gdb_blen, b[i]);
  1309.       gdb_blen += 2;
  1310.     }
  1311. }

  1313. /* Handle the 'q' packet.  */

  1315. static void
  1316. ‌handle_q_packet (const unsigned char *pkt, unsigned int pktlen)
  1317. {
  1318.   /* For qfThreadInfo and qsThreadInfo.  */
  1319.   static unsigned int first_thread;
  1320.   static unsigned int last_thread;

  1322.   static const char xfer_uib[] = "qXfer:uib:read:";
  1323. ‌#define XFER_UIB_LEN (sizeof (xfer_uib) - 1)
  1324.   static const char qfthreadinfo[] = "qfThreadInfo";
  1325. ‌#define QFTHREADINFO_LEN (sizeof (qfthreadinfo) - 1)
  1326.   static const char qsthreadinfo[] = "qsThreadInfo";
  1327. ‌#define QSTHREADINFO_LEN (sizeof (qsthreadinfo) - 1)
  1328.   static const char qthreadextrainfo[] = "qThreadExtraInfo,";
  1329. ‌#define QTHREADEXTRAINFO_LEN (sizeof (qthreadextrainfo) - 1)
  1330.   static const char qsupported[] = "qSupported:";
  1331. ‌#define QSUPPORTED_LEN (sizeof (qsupported) - 1)

  1333.   if (pktlen == 2 && pkt[1] == 'C')
  1334.     {
  1335.       /* Current thread.  */
  1336.       gdb_buf[0] = '$';
  1337.       gdb_buf[1] = 'Q';
  1338.       gdb_buf[2] = 'C';
  1339.       gdb_blen = 3;
  1340.       if (has_threads)
  1341.         long2pkt ((unsigned long) get_teb ());
  1342.       return;
  1343.     }
  1344.   else if (pktlen > XFER_UIB_LEN
  1345.       && ots$strcmp_eql (pkt, XFER_UIB_LEN, xfer_uib, XFER_UIB_LEN))
  1346.     {
  1347.       /* Get unwind information block.  */
  1348.       unsigned __int64 pc;
  1349.       unsigned int pos = XFER_UIB_LEN;
  1350.       unsigned int off;
  1351.       unsigned int len;
  1352.       union
  1353.       {
  1354.         unsigned char bytes[32];
  1355.         struct
  1356.         {
  1357.           unsigned __int64 code_start_va;
  1358.           unsigned __int64 code_end_va;
  1359.           unsigned __int64 uib_start_va;
  1360.           unsigned __int64 gp_value;
  1361.         } data;
  1362.       } uei;
  1363.       int res;
  1364.       int i;

  1366.       packet_error (0);

  1368.       pc = pkt2val (pkt, &pos);
  1369.       if (pkt[pos] != ':')
  1370.         return;
  1371.       pos++;
  1372.       off = pkt2val (pkt, &pos);
  1373.       if (pkt[pos] != ',' || off != 0)
  1374.         return;
  1375.       pos++;
  1376.       len = pkt2val (pkt, &pos);
  1377.       if (pkt[pos] != '#' || len != 0x20)
  1378.         return;

  1380.       res = SYS$GET_UNWIND_ENTRY_INFO (pc, &uei.data, 0);
  1381.       if (res == SS$_NODATA || res != SS$_NORMAL)
  1382.         ots$fill (uei.bytes, sizeof (uei.bytes), 0);

  1384.       if (trace_unwind)
  1385.         {
  1386.           TERM_FAO ("Unwind request for !XH, status=!XL, uib=!XQ, GP=!XQ!/",
  1387.                     pc, res, uei.data.uib_start_va, uei.data.gp_value);
  1388.         }

  1390.       gdb_buf[0] = '$';
  1391.       gdb_buf[1] = 'l';
  1392.       gdb_blen = 2;
  1393.       mem2bin (uei.bytes, sizeof (uei.bytes));
  1394.     }
  1395.   else if (pktlen == QFTHREADINFO_LEN
  1396.            && ots$strcmp_eql (pkt, QFTHREADINFO_LEN,
  1397.                               qfthreadinfo, QFTHREADINFO_LEN))
  1398.     {
  1399.       /* Get first thread(s).  */
  1400.       gdb_buf[0] = '$';
  1401.       gdb_buf[1] = 'm';
  1402.       gdb_blen = 2;

  1404.       if (!has_threads)
  1405.         {
  1406.           gdb_buf[1] = 'l';
  1407.           return;
  1408.         }
  1409.       first_thread = thread_next (0);
  1410.       last_thread = first_thread;
  1411.       long2pkt (first_thread);
  1412.     }
  1413.   else if (pktlen == QSTHREADINFO_LEN
  1414.            && ots$strcmp_eql (pkt, QSTHREADINFO_LEN,
  1415.                               qsthreadinfo, QSTHREADINFO_LEN))
  1416.     {
  1417.       /* Get subsequent threads.  */
  1418.       gdb_buf[0] = '$';
  1419.       gdb_buf[1] = 'm';
  1420.       gdb_blen = 2;
  1421.       while (dbgext_func)
  1422.         {
  1423.           unsigned int res;
  1424.           res = thread_next (last_thread);
  1425.           if (res == first_thread)
  1426.             break;
  1427.           if (gdb_blen > 2)
  1428.             gdb_buf[gdb_blen++] = ',';
  1429.           long2pkt (res);
  1430.           last_thread = res;
  1431.           if (gdb_blen > sizeof (gdb_buf) - 16)
  1432.             break;
  1433.         }

  1435.       if (gdb_blen == 2)
  1436.         gdb_buf[1] = 'l';
  1437.     }
  1438.   else if (pktlen > QTHREADEXTRAINFO_LEN
  1439.            && ots$strcmp_eql (pkt, QTHREADEXTRAINFO_LEN,
  1440.                               qthreadextrainfo, QTHREADEXTRAINFO_LEN))
  1441.     {
  1442.       /* Get extra info about a thread.  */
  1443.       pthread_t thr;
  1444.       unsigned int pos = QTHREADEXTRAINFO_LEN;
  1445.       pthreadDebugThreadInfo_t info;
  1446.       int res;

  1448.       packet_error (0);
  1449.       if (!has_threads)
  1450.         return;

  1452.       thr = (pthread_t) pkt2val (pkt, &pos);
  1453.       if (pkt[pos] != '#')
  1454.         return;
  1455.       res = pthread_debug_thd_get_info_addr (thr, &info);
  1456.       if (res != 0)
  1457.         {
  1458.           TERM_FAO ("qThreadExtraInfo (!XH) failed: !SL!/", thr, res);
  1459.           return;
  1460.         }
  1461.       gdb_buf[0] = '$';
  1462.       gdb_blen = 1;
  1463.       mem2hex ((const unsigned char *)"VMS-thread", 11);
  1464.     }
  1465.   else if (pktlen > QSUPPORTED_LEN
  1466.            && ots$strcmp_eql (pkt, QSUPPORTED_LEN,
  1467.                               qsupported, QSUPPORTED_LEN))
  1468.     {
  1469.       /* Get supported features.  */
  1470.       pthread_t thr;
  1471.       unsigned int pos = QSUPPORTED_LEN;
  1472.       pthreadDebugThreadInfo_t info;
  1473.       int res;

  1475.       /* Ignore gdb features.  */
  1476.       gdb_buf[0] = '$';
  1477.       gdb_blen = 1;

  1479.       str2pkt ("qXfer:uib:read+");
  1480.       return;
  1481.     }
  1482.   else
  1483.     {
  1484.       if (trace_pkt)
  1485.         {
  1486.           term_puts ("unknown <: ");
  1487.           term_write ((char *)pkt, pktlen);
  1488.           term_putnl ();
  1489.         }
  1490.       return;
  1491.     }
  1492. }

  1494. /* Handle the 'v' packet.  */

  1496. static int
  1497. ‌handle_v_packet (const unsigned char *pkt, unsigned int pktlen)
  1498. {
  1499.   static const char vcontq[] = "vCont?";
  1500. ‌#define VCONTQ_LEN (sizeof (vcontq) - 1)

  1502.   if (pktlen == VCONTQ_LEN
  1503.       && ots$strcmp_eql (pkt, VCONTQ_LEN, vcontq, VCONTQ_LEN))
  1504.     {
  1505.       gdb_buf[0] = '$';
  1506.       gdb_blen = 1;

  1508.       str2pkt ("vCont;c;s");
  1509.       return 0;
  1510.     }
  1511.   else
  1512.     {
  1513.       if (trace_pkt)
  1514.         {
  1515.           term_puts ("unknown <: ");
  1516.           term_write ((char *)pkt, pktlen);
  1517.           term_putnl ();
  1518.         }
  1519.       return 0;
  1520.     }
  1521. }

  1523. /* Get regs for the selected thread.  */

  1525. static struct ia64_all_regs *
  1526. ‌get_selected_regs (void)
  1527. {
  1528.   pthreadDebugRegs_t regs;
  1529.   int res;

  1531.   if (selected_thread == 0 || selected_thread == get_teb ())
  1532.     return &excp_regs;

  1534.   if (selected_thread == sel_regs_pthread)
  1535.     return &sel_regs;

  1537.   /* Read registers.  */
  1538.   res = pthread_debug_thd_get_reg (selected_id, &regs);
  1539.   if (res != 0)
  1540.     {
  1541.       /* FIXME: return NULL ?  */
  1542.       return &excp_regs;
  1543.     }
  1544.   sel_regs_pthread = selected_thread;
  1545.   sel_regs.gr[1].v = regs.gp;
  1546.   sel_regs.gr[4].v = regs.r4;
  1547.   sel_regs.gr[5].v = regs.r5;
  1548.   sel_regs.gr[6].v = regs.r6;
  1549.   sel_regs.gr[7].v = regs.r7;
  1550.   sel_regs.gr[12].v = regs.sp;
  1551.   sel_regs.br[0].v = regs.rp;
  1552.   sel_regs.br[1].v = regs.b1;
  1553.   sel_regs.br[2].v = regs.b2;
  1554.   sel_regs.br[3].v = regs.b3;
  1555.   sel_regs.br[4].v = regs.b4;
  1556.   sel_regs.br[5].v = regs.b5;
  1557.   sel_regs.ip.v = regs.ip;
  1558.   sel_regs.bsp.v = regs.bspstore; /* FIXME: it is correct ?  */
  1559.   sel_regs.pfs.v = regs.pfs;
  1560.   sel_regs.pr.v = regs.pr;
  1561.   return &sel_regs;
  1562. }

  1564. /* Create a status packet.  */

  1566. static void
  1567. ‌packet_status (void)
  1568. {
  1569.   gdb_blen = 0;
  1570.   if (has_threads)
  1571.     {
  1572.       str2pkt ("$T05thread:");
  1573.       long2pkt ((unsigned long) get_teb ());
  1574.       gdb_buf[gdb_blen++] = ';';
  1575.     }
  1576.   else
  1577.     str2pkt ("$S05");
  1578. }

  1580. /* Return 1 to continue.  */

  1582. static int
  1583. ‌handle_packet (unsigned char *pkt, unsigned int len)
  1584. {
  1585.   unsigned int pos;

  1587.   /* By default, reply unsupported.  */
  1588.   gdb_buf[0] = '$';
  1589.   gdb_blen = 1;

  1591.   pos = 1;
  1592.   switch (pkt[0])
  1593.     {
  1594.     case '?':
  1595.       if (len == 1)
  1596.         {
  1597.           packet_status ();
  1598.           return 0;
  1599.         }
  1600.       break;
  1601.     case 'c':
  1602.       if (len == 1)
  1603.         {
  1604.           /* Clear psr.ss.  */
  1605.           excp_regs.psr.v &= ~(unsigned __int64)PSR$M_SS;
  1606.           return 1;
  1607.         }
  1608.       else
  1609.         packet_error (0);
  1610.       break;
  1611.     case 'g':
  1612.       if (len == 1)
  1613.         {
  1614.           unsigned int i;
  1615.           struct ia64_all_regs *regs = get_selected_regs ();
  1616.           unsigned char *p = regs->gr[0].b;

  1618.           for (i = 0; i < 8 * 32; i++)
  1619.             byte2hex (gdb_buf + 1 + 2 * i, p[i]);
  1620.           gdb_blen += 2 * 8 * 32;
  1621.           return 0;
  1622.         }
  1623.       break;
  1624.     case 'H':
  1625.       if (pkt[1] == 'g')
  1626.         {
  1627.           int res;
  1628.           unsigned __int64 val;
  1629.           pthreadDebugThreadInfo_t info;

  1631.           pos++;
  1632.           val = pkt2val (pkt, &pos);
  1633.           if (pos != len)
  1634.             {
  1635.               packet_error (0);
  1636.               return 0;
  1637.             }
  1638.           if (val == 0)
  1639.             {
  1640.               /* Default one.  */
  1641.               selected_thread = get_teb ();
  1642.               selected_id = 0;
  1643.             }
  1644.           else if (!has_threads)
  1645.             {
  1646.               packet_error (0);
  1647.               return 0;
  1648.             }
  1649.           else
  1650.             {
  1651.               res = pthread_debug_thd_get_info_addr ((pthread_t) val, &info);
  1652.               if (res != 0)
  1653.                 {
  1654.                   TERM_FAO ("qThreadExtraInfo (!XH) failed: !SL!/", val, res);
  1655.                   packet_error (0);
  1656.                   return 0;
  1657.                 }
  1658.               selected_thread = info.teb;
  1659.               selected_id = info.sequence;
  1660.             }
  1661.           packet_ok ();
  1662.           break;
  1663.         }
  1664.       else if (pkt[1] == 'c'
  1665.                && ((pkt[2] == '-' && pkt[3] == '1' && len == 4)
  1666.                    || (pkt[2] == '0' && len == 3)))
  1667.         {
  1668.           /* Silently accept 'Hc0' and 'Hc-1'.  */
  1669.           packet_ok ();
  1670.           break;
  1671.         }
  1672.       else
  1673.         {
  1674.           packet_error (0);
  1675.           return 0;
  1676.         }
  1677.     case 'k':
  1678.       SYS$EXIT (SS$_NORMAL);
  1679.       break;
  1680.     case 'm':
  1681.       {
  1682.         unsigned __int64 addr;
  1683.         unsigned __int64 paddr;
  1684.         unsigned int l;
  1685.         unsigned int i;

  1687.         addr = pkt2val (pkt, &pos);
  1688.         if (pkt[pos] != ',')
  1689.           {
  1690.             packet_error (0);
  1691.             return 0;
  1692.           }
  1693.         pos++;
  1694.         l = pkt2val (pkt, &pos);
  1695.         if (pkt[pos] != '#')
  1696.           {
  1697.             packet_error (0);
  1698.             return 0;
  1699.           }

  1701.         /* Check access.  */
  1702.         i = l + (addr & VMS_PAGE_MASK);
  1703.         paddr = addr & ~VMS_PAGE_MASK;
  1704.         while (1)
  1705.           {
  1706.             if (__prober (paddr, 0) != 1)
  1707.               {
  1708.                 packet_error (2);
  1709.                 return 0;
  1710.               }
  1711.             if (i < VMS_PAGE_SIZE)
  1712.               break;
  1713.             i -= VMS_PAGE_SIZE;
  1714.             paddr += VMS_PAGE_SIZE;
  1715.           }

  1717.         /* Transfer.  */
  1718.         for (i = 0; i < l; i++)
  1719.           byte2hex (gdb_buf + 1 + 2 * i, ((unsigned char *)addr)[i]);
  1720.         gdb_blen += 2 * l;
  1721.       }
  1722.       break;
  1723.     case 'M':
  1724.       {
  1725.         unsigned __int64 addr;
  1726.         unsigned __int64 paddr;
  1727.         unsigned int l;
  1728.         unsigned int i;
  1729.         unsigned int oldprot;

  1731.         addr = pkt2val (pkt, &pos);
  1732.         if (pkt[pos] != ',')
  1733.           {
  1734.             packet_error (0);
  1735.             return 0;
  1736.           }
  1737.         pos++;
  1738.         l = pkt2val (pkt, &pos);
  1739.         if (pkt[pos] != ':')
  1740.           {
  1741.             packet_error (0);
  1742.             return 0;
  1743.           }
  1744.         pos++;
  1745.         page_set_rw (addr, l, &oldprot);

  1747.         /* Check access.  */
  1748.         i = l + (addr & VMS_PAGE_MASK);
  1749.         paddr = addr & ~VMS_PAGE_MASK;
  1750.         while (1)
  1751.           {
  1752.             if (__probew (paddr, 0) != 1)
  1753.               {
  1754.                 page_restore_rw (addr, l, oldprot);
  1755.                 return 0;
  1756.               }
  1757.             if (i < VMS_PAGE_SIZE)
  1758.               break;
  1759.             i -= VMS_PAGE_SIZE;
  1760.             paddr += VMS_PAGE_SIZE;
  1761.           }

  1763.         /* Write.  */
  1764.         for (i = 0; i < l; i++)
  1765.           {
  1766.             int v = hex2byte (pkt + pos);
  1767.             pos += 2;
  1768.             ((unsigned char *)addr)[i] = v;
  1769.           }

  1771.         /* Sync caches.  */
  1772.         for (i = 0; i < l; i += 15)
  1773.           __fc (addr + i);
  1774.         __fc (addr + l);

  1776.         page_restore_rw (addr, l, oldprot);
  1777.         packet_ok ();
  1778.       }
  1779.       break;
  1780.     case 'p':
  1781.       {
  1782.         unsigned int num = 0;
  1783.         unsigned int i;
  1784.         struct ia64_all_regs *regs = get_selected_regs ();

  1786.         num = pkt2val (pkt, &pos);
  1787.         if (pos != len)
  1788.           {
  1789.             packet_error (0);
  1790.             return 0;
  1791.           }

  1793.         switch (num)
  1794.           {
  1795.           case IA64_IP_REGNUM:
  1796.             ireg2pkt (regs->ip.b);
  1797.             break;
  1798.           case IA64_BR0_REGNUM:
  1799.             ireg2pkt (regs->br[0].b);
  1800.             break;
  1801.           case IA64_PSR_REGNUM:
  1802.             ireg2pkt (regs->psr.b);
  1803.             break;
  1804.           case IA64_BSP_REGNUM:
  1805.             ireg2pkt (regs->bsp.b);
  1806.             break;
  1807.           case IA64_CFM_REGNUM:
  1808.             ireg2pkt (regs->cfm.b);
  1809.             break;
  1810.           case IA64_PFS_REGNUM:
  1811.             ireg2pkt (regs->pfs.b);
  1812.             break;
  1813.           case IA64_PR_REGNUM:
  1814.             ireg2pkt (regs->pr.b);
  1815.             break;
  1816.           default:
  1817.             TERM_FAO ("gdbserv: unhandled reg !UW!/", num);
  1818.             packet_error (0);
  1819.             return 0;
  1820.           }
  1821.       }
  1822.       break;
  1823.     case 'q':
  1824.       handle_q_packet (pkt, len);
  1825.       break;
  1826.     case 's':
  1827.       if (len == 1)
  1828.         {
  1829.           /* Set psr.ss.  */
  1830.           excp_regs.psr.v |= (unsigned __int64)PSR$M_SS;
  1831.           return 1;
  1832.         }
  1833.       else
  1834.         packet_error (0);
  1835.       break;
  1836.     case 'T':
  1837.       /* Thread status.  */
  1838.       if (!has_threads)
  1839.         {
  1840.           packet_ok ();
  1841.           break;
  1842.         }
  1843.       else
  1844.         {
  1845.           int res;
  1846.           unsigned __int64 val;
  1847.           unsigned int fthr, thr;

  1849.           val = pkt2val (pkt, &pos);
  1850.           /* Default is error (but only after parsing is complete).  */
  1851.           packet_error (0);
  1852.           if (pos != len)
  1853.             break;

  1855.           /* Follow the list.  This makes a O(n2) algorithm, but we don't really
  1856.              have the choice.  Note that pthread_debug_thd_get_info_addr
  1857.              doesn't look reliable.  */
  1858.           fthr = thread_next (0);
  1859.           thr = fthr;
  1860.           do
  1861.             {
  1862.               if (val == thr)
  1863.                 {
  1864.                   packet_ok ();
  1865.                   break;
  1866.                 }
  1867.               thr = thread_next (thr);
  1868.             }
  1869.           while (thr != fthr);
  1870.         }
  1871.       break;
  1872.     case 'v':
  1873.       return handle_v_packet (pkt, len);
  1874.       break;
  1875.     case 'V':
  1876.       if (len > 3 && pkt[1] == 'M' && pkt[2] == 'S' && pkt[3] == ' ')
  1877.         {
  1878.           /* Temporary extension.  */
  1879.           if (has_threads)
  1880.             {
  1881.               pkt[len] = 0;
  1882.               stub_pthread_debug_cmd ((char *)pkt + 4);
  1883.               packet_ok ();
  1884.             }
  1885.           else
  1886.             packet_error (0);
  1887.         }
  1888.       break;
  1889.     default:
  1890.       if (trace_pkt)
  1891.         {
  1892.           term_puts ("unknown <: ");
  1893.           term_write ((char *)pkt, len);
  1894.           term_putnl ();
  1895.         }
  1896.       break;
  1897.     }
  1898.   return 0;
  1899. }

  1901. /* Raw write to gdb.  */

  1903. static void
  1904. ‌sock_write (const unsigned char *buf, int len)
  1905. {
  1906.   struct _iosb iosb;
  1907.   unsigned int status;

  1909.   /* Write data to connection.  */
  1910.   status = sys$qiow (EFN$C_ENF,           /* Event flag.  */
  1911.                      conn_channel,        /* I/O channel.  */
  1912.                      IO$_WRITEVBLK,       /* I/O function code.  */
  1913.                      &iosb,               /* I/O status block.  */
  1914.                      0,                   /* Ast service routine.  */
  1915.                      0,                   /* Ast parameter.  */
  1916.                      (char *)buf,         /* P1 - buffer address.  */
  1917.                      len,                 /* P2 - buffer length.  */
  1918.                      0, 0, 0, 0);
  1919.   if (status & STS$M_SUCCESS)
  1920.     status = iosb.iosb$w_status;
  1921.   if (!(status & STS$M_SUCCESS))
  1922.     {
  1923.       term_puts ("Failed to write data to gdb\n");
  1924.       LIB$SIGNAL (status);
  1925.     }
  1926. }

  1928. /* Compute the cheksum and send the packet.  */

  1930. static void
  1931. ‌send_pkt (void)
  1932. {
  1933.   unsigned char chksum = 0;
  1934.   unsigned int i;

  1936.   for (i = 1; i < gdb_blen; i++)
  1937.     chksum += gdb_buf[i];

  1939.   gdb_buf[gdb_blen] = '#';
  1940.   byte2hex (gdb_buf + gdb_blen + 1, chksum);

  1942.   sock_write (gdb_buf, gdb_blen + 3);

  1944.   if (trace_pkt > 1)
  1945.     {
  1946.       term_puts (">: ");
  1947.       term_write ((char *)gdb_buf, gdb_blen + 3);
  1948.       term_putnl ();
  1949.     }
  1950. }

  1952. /* Read and handle one command.  Return 1 is execution must resume.  */

  1954. static int
  1955. ‌one_command (void)
  1956. {
  1957.   struct _iosb iosb;
  1958.   unsigned int status;
  1959.   unsigned int off;
  1960.   unsigned int dollar_off = 0;
  1961.   unsigned int sharp_off = 0;
  1962.   unsigned int cmd_off;
  1963.   unsigned int cmd_len;

  1965.   /* Wait for a packet.  */
  1966.   while (1)
  1967.     {
  1968.       off = 0;
  1969.       while (1)
  1970.         {
  1971.           /* Read data from connection.  */
  1972.           status = sys$qiow (EFN$C_ENF,           /* Event flag.  */
  1973.                              conn_channel,        /* I/O channel.  */
  1974.                              IO$_READVBLK,        /* I/O function code.  */
  1975.                              &iosb,               /* I/O status block.  */
  1976.                              0,                   /* Ast service routine.  */
  1977.                              0,                   /* Ast parameter.  */
  1978.                              gdb_buf + off,       /* P1 - buffer address.  */
  1979.                              sizeof (gdb_buf) - off, /* P2 - buffer leng.  */
  1980.                              0, 0, 0, 0);
  1981.           if (status & STS$M_SUCCESS)
  1982.             status = iosb.iosb$w_status;
  1983.           if (!(status & STS$M_SUCCESS))
  1984.             {
  1985.               term_puts ("Failed to read data from connection\n" );
  1986.               LIB$SIGNAL (status);
  1987.             }

  1989. #ifdef RAW_DUMP
  1990.           term_puts ("{: ");
  1991.           term_write ((char *)gdb_buf + off, iosb.iosb$w_bcnt);
  1992.           term_putnl ();
  1993. #endif

  1995.           gdb_blen = off + iosb.iosb$w_bcnt;

  1997.           if (off == 0)
  1998.             {
  1999.               /* Search for '$'.  */
  2000.               for (dollar_off = 0; dollar_off < gdb_blen; dollar_off++)
  2001.                 if (gdb_buf[dollar_off] == '$')
  2002.                   break;
  2003.               if (dollar_off >= gdb_blen)
  2004.                 {
  2005.                   /* Not found, discard the data.  */
  2006.                   off = 0;
  2007.                   continue;
  2008.                 }
  2009.               /* Search for '#'.  */
  2010.               for (sharp_off = dollar_off + 1;
  2011.                    sharp_off < gdb_blen;
  2012.                    sharp_off++)
  2013.                 if (gdb_buf[sharp_off] == '#')
  2014.                   break;
  2015.             }
  2016.           else if (sharp_off >= off)
  2017.             {
  2018.               /* Search for '#'.  */
  2019.               for (; sharp_off < gdb_blen; sharp_off++)
  2020.                 if (gdb_buf[sharp_off] == '#')
  2021.                   break;
  2022.             }

  2024.           /* Got packet with checksum.  */
  2025.           if (sharp_off + 2 <= gdb_blen)
  2026.             break;

  2028.           off = gdb_blen;
  2029.           if (gdb_blen == sizeof (gdb_buf))
  2030.             {
  2031.               /* Packet too large, discard.  */
  2032.               off = 0;
  2033.             }
  2034.         }

  2036.       /* Validate and acknowledge a packet.  */
  2037.       {
  2038.         unsigned char chksum = 0;
  2039.         unsigned int i;
  2040.         int v;

  2042.         for (i = dollar_off + 1; i < sharp_off; i++)
  2043.           chksum += gdb_buf[i];
  2044.         v = hex2byte (gdb_buf + sharp_off + 1);
  2045.         if (v != chksum)
  2046.           {
  2047.             term_puts ("Discard bad checksum packet\n");
  2048.             continue;
  2049.           }
  2050.         else
  2051.           {
  2052.             sock_write ((const unsigned char *)"+", 1);
  2053.             break;
  2054.           }
  2055.       }
  2056.     }

  2058.   if (trace_pkt > 1)
  2059.     {
  2060.       term_puts ("<: ");
  2061.       term_write ((char *)gdb_buf + dollar_off, sharp_off - dollar_off + 1);
  2062.       term_putnl ();
  2063.     }

  2065.   cmd_off = dollar_off + 1;
  2066.   cmd_len = sharp_off - dollar_off - 1;

  2068.   if (handle_packet (gdb_buf + dollar_off + 1, sharp_off - dollar_off - 1) == 1)
  2069.     return 1;

  2071.   send_pkt ();
  2072.   return 0;
  2073. }

  2075. /* Display the condition given by SIG64.  */

  2077. static void
  2078. ‌display_excp (struct chf64$signal_array *sig64, struct chf$mech_array *mech)
  2079. {
  2080.   unsigned int status;
  2081.   char msg[160];
  2082.   unsigned short msglen;
  2083.   $DESCRIPTOR (msg_desc, msg);
  2084.   unsigned char outadr[4];

  2086.   status = SYS$GETMSG (sig64->chf64$q_sig_name, &msglen, &msg_desc, 0, outadr);
  2087.   if (status & STS$M_SUCCESS)
  2088.     {
  2089.       char msg2[160];
  2090.       unsigned short msg2len;
  2091.       struct dsc$descriptor_s msg2_desc =
  2092.         { sizeof (msg2), DSC$K_DTYPE_T, DSC$K_CLASS_S, msg2};
  2093.       msg_desc.dsc$w_length = msglen;
  2094.       status = SYS$FAOL_64 (&msg_desc, &msg2len, &msg2_desc,
  2095.                             &sig64->chf64$q_sig_arg1);
  2096.       if (status & STS$M_SUCCESS)
  2097.         term_write (msg2, msg2len);
  2098.     }
  2099.   else
  2100.     term_puts ("no message");
  2101.   term_putnl ();

  2103.   if (trace_excp > 1)
  2104.     {
  2105.       TERM_FAO (" Frame: !XH, Depth: !4SL, Esf: !XH!/",
  2106.                 mech->chf$q_mch_frame, mech->chf$q_mch_depth,
  2107.                 mech->chf$q_mch_esf_addr);
  2108.     }
  2109. }

  2111. /* Get all registers from current thread.  */

  2113. static void
  2114. ‌read_all_registers (struct chf$mech_array *mech)
  2115. {
  2116.   struct _intstk *intstk =
  2117.     (struct _intstk *)mech->chf$q_mch_esf_addr;
  2118.   struct chf64$signal_array *sig64 =
  2119.     (struct chf64$signal_array *)mech->chf$ph_mch_sig64_addr;
  2120.   unsigned int cnt = sig64->chf64$w_sig_arg_count;
  2121.   unsigned __int64 pc = (&sig64->chf64$q_sig_name)[cnt - 2];

  2123.   excp_regs.ip.v = pc;
  2124.   excp_regs.psr.v = intstk->intstk$q_ipsr;
  2125.   /* GDB and linux expects bsp to point after the current register frame.
  2126.      Adjust.  */
  2127.   {
  2128.     unsigned __int64 bsp = intstk->intstk$q_bsp;
  2129.     unsigned int sof = intstk->intstk$q_ifs & 0x7f;
  2130.     unsigned int delta = ((bsp >> 3) & 0x3f) + sof;
  2131.     excp_regs.bsp.v = bsp + ((sof + delta / 0x3f) << 3);
  2132.   }
  2133.   excp_regs.cfm.v = intstk->intstk$q_ifs & 0x3fffffffff;
  2134.   excp_regs.pfs.v = intstk->intstk$q_pfs;
  2135.   excp_regs.pr.v = intstk->intstk$q_preds;
  2136.   excp_regs.gr[0].v = 0;
  2137.   excp_regs.gr[1].v = intstk->intstk$q_gp;
  2138.   excp_regs.gr[2].v = intstk->intstk$q_r2;
  2139.   excp_regs.gr[3].v = intstk->intstk$q_r3;
  2140.   excp_regs.gr[4].v = intstk->intstk$q_r4;
  2141.   excp_regs.gr[5].v = intstk->intstk$q_r5;
  2142.   excp_regs.gr[6].v = intstk->intstk$q_r6;
  2143.   excp_regs.gr[7].v = intstk->intstk$q_r7;
  2144.   excp_regs.gr[8].v = intstk->intstk$q_r8;
  2145.   excp_regs.gr[9].v = intstk->intstk$q_r9;
  2146.   excp_regs.gr[10].v = intstk->intstk$q_r10;
  2147.   excp_regs.gr[11].v = intstk->intstk$q_r11;
  2148.   excp_regs.gr[12].v = (unsigned __int64)intstk + intstk->intstk$l_stkalign;
  2149.   excp_regs.gr[13].v = intstk->intstk$q_r13;
  2150.   excp_regs.gr[14].v = intstk->intstk$q_r14;
  2151.   excp_regs.gr[15].v = intstk->intstk$q_r15;
  2152.   excp_regs.gr[16].v = intstk->intstk$q_r16;
  2153.   excp_regs.gr[17].v = intstk->intstk$q_r17;
  2154.   excp_regs.gr[18].v = intstk->intstk$q_r18;
  2155.   excp_regs.gr[19].v = intstk->intstk$q_r19;
  2156.   excp_regs.gr[20].v = intstk->intstk$q_r20;
  2157.   excp_regs.gr[21].v = intstk->intstk$q_r21;
  2158.   excp_regs.gr[22].v = intstk->intstk$q_r22;
  2159.   excp_regs.gr[23].v = intstk->intstk$q_r23;
  2160.   excp_regs.gr[24].v = intstk->intstk$q_r24;
  2161.   excp_regs.gr[25].v = intstk->intstk$q_r25;
  2162.   excp_regs.gr[26].v = intstk->intstk$q_r26;
  2163.   excp_regs.gr[27].v = intstk->intstk$q_r27;
  2164.   excp_regs.gr[28].v = intstk->intstk$q_r28;
  2165.   excp_regs.gr[29].v = intstk->intstk$q_r29;
  2166.   excp_regs.gr[30].v = intstk->intstk$q_r30;
  2167.   excp_regs.gr[31].v = intstk->intstk$q_r31;
  2168.   excp_regs.br[0].v = intstk->intstk$q_b0;
  2169.   excp_regs.br[1].v = intstk->intstk$q_b1;
  2170.   excp_regs.br[2].v = intstk->intstk$q_b2;
  2171.   excp_regs.br[3].v = intstk->intstk$q_b3;
  2172.   excp_regs.br[4].v = intstk->intstk$q_b4;
  2173.   excp_regs.br[5].v = intstk->intstk$q_b5;
  2174.   excp_regs.br[6].v = intstk->intstk$q_b6;
  2175.   excp_regs.br[7].v = intstk->intstk$q_b7;
  2176. }

  2178. /* Write all registers to current thread.  FIXME: not yet complete.  */

  2180. static void
  2181. ‌write_all_registers (struct chf$mech_array *mech)
  2182. {
  2183.   struct _intstk *intstk =
  2184.     (struct _intstk *)mech->chf$q_mch_esf_addr;

  2186.   intstk->intstk$q_ipsr = excp_regs.psr.v;
  2187. }

  2189. /* Do debugging.  Report status to gdb and execute commands.  */

  2191. static void
  2192. ‌do_debug (struct chf$mech_array *mech)
  2193. {
  2194.   struct _intstk *intstk =
  2195.     (struct _intstk *)mech->chf$q_mch_esf_addr;
  2196.   unsigned int old_ast;
  2197.   unsigned int old_sch;
  2198.   unsigned int status;

  2200.   /* Disable ast.  */
  2201.   status = sys$setast (0);
  2202.   switch (status)
  2203.     {
  2204.     case SS$_WASCLR:
  2205.       old_ast = 0;
  2206.       break;
  2207.     case SS$_WASSET:
  2208.       old_ast = 1;
  2209.       break;
  2210.     default:
  2211.       /* Should never happen!  */
  2212.       lib$signal (status);
  2213.     }

  2215.   /* Disable thread scheduling.  */
  2216.   if (has_threads)
  2217.     old_sch = set_thread_scheduling (0);

  2219.   read_all_registers (mech);

  2221.   /* Send stop reply packet.  */
  2222.   packet_status ();
  2223.   send_pkt ();

  2225.   while (one_command () == 0)
  2226.     ;

  2228.   write_all_registers (mech);

  2230.   /* Re-enable scheduling.  */
  2231.   if (has_threads)
  2232.     set_thread_scheduling (old_sch);

  2234.   /* Re-enable AST.  */
  2235.   status = sys$setast (old_ast);
  2236.   if (!(status & STS$M_SUCCESS))
  2237.     LIB$SIGNAL (status);
  2238. }

  2240. /* The condition handler.  That's the core of the stub.  */

  2242. static int
  2243. ‌excp_handler (struct chf$signal_array *sig,
  2244.               struct chf$mech_array *mech)
  2245. {
  2246.   struct chf64$signal_array *sig64 =
  2247.     (struct chf64$signal_array *)mech->chf$ph_mch_sig64_addr;
  2248.   unsigned int code = sig->chf$l_sig_name & STS$M_COND_ID;
  2249.   unsigned int cnt = sig64->chf64$w_sig_arg_count;
  2250.   unsigned __int64 pc;
  2251.   unsigned int ret;
  2252.   /* Self protection.  FIXME: Should be per thread ?  */
  2253.   static int in_handler = 0;

  2255.   /* Completly ignore some conditions (signaled indirectly by this stub).  */
  2256.   switch (code)
  2257.     {
  2258.     case LIB$_KEYNOTFOU & STS$M_COND_ID:
  2259.       return SS$_RESIGNAL_64;
  2260.     default:
  2261.       break;
  2262.     }

  2264.   /* Protect against recursion.  */
  2265.   in_handler++;
  2266.   if (in_handler > 1)
  2267.     {
  2268.       if (in_handler == 2)
  2269.         TERM_FAO ("gdbstub: exception in handler (pc=!XH)!!!/",
  2270.                   (&sig64->chf64$q_sig_name)[cnt - 2]);
  2271.       sys$exit (sig->chf$l_sig_name);
  2272.     }

  2274.   pc = (&sig64->chf64$q_sig_name)[cnt - 2];
  2275.   if (trace_excp)
  2276.     TERM_FAO ("excp_handler: code: !XL, pc=!XH!/", code, pc);

  2278.   /* If break on the entry point, restore the bundle.  */
  2279.   if (code == (SS$_BREAK & STS$M_COND_ID)
  2280.       && pc == entry_pc
  2281.       && entry_pc != 0)
  2282.     {
  2283.       static unsigned int entry_prot;

  2285.       if (trace_entry)
  2286.         term_puts ("initial entry breakpoint\n");
  2287.       page_set_rw (entry_pc, 16, &entry_prot);

  2289.       ots$move ((void *)entry_pc, 16, entry_saved);
  2290.       __fc (entry_pc);
  2291.       page_restore_rw (entry_pc, 16, entry_prot);
  2292.     }

  2294.   switch (code)
  2295.     {
  2296.     case SS$_ACCVIO & STS$M_COND_ID:
  2297.       if (trace_excp <= 1)
  2298.         display_excp (sig64, mech);
  2299.       /* Fall through.  */
  2300.     case SS$_BREAK  & STS$M_COND_ID:
  2301.     case SS$_OPCDEC & STS$M_COND_ID:
  2302.     case SS$_TBIT   & STS$M_COND_ID:
  2303.     case SS$_DEBUG  & STS$M_COND_ID:
  2304.       if (trace_excp > 1)
  2305.         {
  2306.           int i;
  2307.           struct _intstk *intstk =
  2308.             (struct _intstk *)mech->chf$q_mch_esf_addr;

  2310.           display_excp (sig64, mech);

  2312.           TERM_FAO (" intstk: !XH!/", intstk);
  2313.           for (i = 0; i < cnt + 1; i++)
  2314.             TERM_FAO ("   !XH!/", ((unsigned __int64 *)sig64)[i]);
  2315.         }
  2316.       do_debug (mech);
  2317.       ret = SS$_CONTINUE_64;
  2318.       break;

  2320.     default:
  2321.       display_excp (sig64, mech);
  2322.       ret = SS$_RESIGNAL_64;
  2323.       break;
  2324.     }

  2326.   in_handler--;
  2327.   /* Discard selected thread registers.  */
  2328.   sel_regs_pthread = 0;
  2329.   return ret;
  2330. }

  2332. /* Setup internal trace flags according to GDBSTUB$TRACE logical.  */

  2334. static void
  2335. ‌trace_init (void)
  2336. {
  2337.   unsigned int status, i, start;
  2338.   unsigned short len;
  2339.   char resstring[LNM$C_NAMLENGTH];
  2340.   static const $DESCRIPTOR (tabdesc, "LNM$DCL_LOGICAL");
  2341.   static const $DESCRIPTOR (logdesc, "GDBSTUB$TRACE");
  2342.   $DESCRIPTOR (sub_desc, resstring);
  2343.   ILE3 item_lst[2];

  2345.   item_lst[0].ile3$w_length = LNM$C_NAMLENGTH;
  2346.   item_lst[0].ile3$w_code = LNM$_STRING;
  2347.   item_lst[0].ile3$ps_bufaddr = resstring;
  2348.   item_lst[0].ile3$ps_retlen_addr = &len;
  2349.   item_lst[1].ile3$w_length = 0;
  2350.   item_lst[1].ile3$w_code = 0;

  2352.   /* Translate the logical name.  */
  2353.   status = SYS$TRNLNM (0,                   /* Attributes of the logical name.  */
  2354.                        (void *)&tabdesc,       /* Logical name table.  */
  2355.                        (void *)&logdesc,       /* Logical name.  */
  2356.                        0,                             /* Access mode.  */
  2357.                        &item_lst);             /* Item list.  */
  2358.   if (status == SS$_NOLOGNAM)
  2359.     return;
  2360.   if (!(status & STS$M_SUCCESS))
  2361.     LIB$SIGNAL (status);

  2363.   start = 0;
  2364.   for (i = 0; i <= len; i++)
  2365.     {
  2366.       if ((i == len || resstring[i] == ',' || resstring[i] == ';')
  2367.           && i != start)
  2368.         {
  2369.           int j;

  2371.           sub_desc.dsc$a_pointer = resstring + start;
  2372.           sub_desc.dsc$w_length = i - start;

  2374.           for (j = 0; j < NBR_DEBUG_FLAGS; j++)
  2375.             if (str$case_blind_compare (&sub_desc,
  2376.                                         (void *)&debug_flags[j].name) == 0)
  2377.               {
  2378.                 debug_flags[j].val++;
  2379.                 break;
  2380.               }
  2381.           if (j == NBR_DEBUG_FLAGS)
  2382.             TERM_FAO ("GDBSTUB$TRACE: unknown directive !AS!/", &sub_desc);

  2384.           start = i + 1;
  2385.         }
  2386.     }

  2388.   TERM_FAO ("GDBSTUB$TRACE=!AD ->", len, resstring);
  2389.   for (i = 0; i < NBR_DEBUG_FLAGS; i++)
  2390.     if (debug_flags[i].val > 0)
  2391.       TERM_FAO (" !AS=!ZL", &debug_flags[i].name, debug_flags[i].val);
  2392.   term_putnl ();
  2393. }


  2396. /* Entry point.  */

  2398. static int
  2399. ‌stub_start (unsigned __int64 *progxfer, void *cli_util,
  2400.             EIHD *imghdr, IFD *imgfile,
  2401.             unsigned int linkflag, unsigned int cliflag)
  2402. {
  2403.   static int initialized;
  2404.   int i;
  2405.   int cnt;
  2406.   int is_attached;
  2407.   IMCB *imcb;
  2408.   if (initialized)
  2409.     term_puts ("gdbstub: re-entry\n");
  2410.   else
  2411.     initialized = 1;

  2413.   /* When attached (through SS$_DEBUG condition), the number of arguments
  2414.      is 4 and PROGXFER is the PC at interruption.  */
  2415.   va_count (cnt);
  2416.   is_attached = cnt == 4;

  2418.   term_init ();

  2420.   /* Hello banner.  */
  2421.   term_puts ("Hello from gdb stub\n");

  2423.   trace_init ();

  2425.   if (trace_entry && !is_attached)
  2426.     {
  2427.       TERM_FAO ("xfer: !XH, imghdr: !XH, ifd: !XH!/",
  2428.                 progxfer, imghdr, imgfile);
  2429.       for (i = -2; i < 8; i++)
  2430.         TERM_FAO ("  at !2SW: !XH!/", i, progxfer[i]);
  2431.     }

  2433.   /* Search for entry point.  */
  2434.   if (!is_attached)
  2435.     {
  2436.       entry_pc = 0;
  2437.       for (i = 0; progxfer[i]; i++)
  2438.         entry_pc = progxfer[i];

  2440.       if (trace_entry)
  2441.         {
  2442.           if (entry_pc == 0)
  2443.             {
  2444.               term_puts ("No entry point\n");
  2445.               return 0;
  2446.             }
  2447.           else
  2448.             TERM_FAO ("Entry: !XH!/",entry_pc);
  2449.         }
  2450.     }
  2451.   else
  2452.     entry_pc = progxfer[0];

  2454.   has_threads = 0;
  2455.   for (imcb = ctl$gl_imglstptr->imcb$l_flink;
  2456.        imcb != ctl$gl_imglstptr;
  2457.        imcb = imcb->imcb$l_flink)
  2458.     {
  2459.       if (ots$strcmp_eql (pthread_rtl_desc.dsc$a_pointer,
  2460.                           pthread_rtl_desc.dsc$w_length,
  2461.                           imcb->imcb$t_log_image_name + 1,
  2462.                           imcb->imcb$t_log_image_name[0]))
  2463.         has_threads = 1;

  2465.       if (trace_images)
  2466.         {
  2467.           unsigned int j;
  2468.           LDRIMG *ldrimg = imcb->imcb$l_ldrimg;
  2469.           LDRISD *ldrisd;

  2471.           TERM_FAO ("!XA-!XA ",
  2472.                     imcb->imcb$l_starting_address,
  2473.                     imcb->imcb$l_end_address);

  2475.           switch (imcb->imcb$b_act_code)
  2476.             {
  2477.             case IMCB$K_MAIN_PROGRAM:
  2478.               term_puts ("prog");
  2479.               break;
  2480.             case IMCB$K_MERGED_IMAGE:
  2481.               term_puts ("mrge");
  2482.               break;
  2483.             case IMCB$K_GLOBAL_IMAGE_SECTION:
  2484.               term_puts ("glob");
  2485.               break;
  2486.             default:
  2487.               term_puts ("????");
  2488.             }
  2489.           TERM_FAO (" !AD !40AC!/",
  2490.                     1, "KESU" + (imcb->imcb$b_access_mode & 3),
  2491.                     imcb->imcb$t_log_image_name);

  2493.           if ((long) ldrimg < 0 || trace_images < 2)
  2494.             continue;
  2495.           ldrisd = ldrimg->ldrimg$l_segments;
  2496.           for (j = 0; j < ldrimg->ldrimg$l_segcount; j++)
  2497.             {
  2498.               unsigned int flags = ldrisd[j].ldrisd$i_flags;
  2499.               term_puts ("   ");
  2500.               term_putc (flags & 0x04 ? 'R' : '-');
  2501.               term_putc (flags & 0x02 ? 'W' : '-');
  2502.               term_putc (flags & 0x01 ? 'X' : '-');
  2503.               term_puts (flags & 0x01000000 ? " Prot" : "     ");
  2504.               term_puts (flags & 0x04000000 ? " Shrt" : "     ");
  2505.               term_puts (flags & 0x08000000 ? " Shrd" : "     ");
  2506.               TERM_FAO (" !XA-!XA!/",
  2507.                         ldrisd[j].ldrisd$p_base,
  2508.                         (unsigned __int64) ldrisd[j].ldrisd$p_base
  2509.                         + ldrisd[j].ldrisd$i_len - 1);
  2510.             }
  2511.           ldrisd = ldrimg->ldrimg$l_dyn_seg;
  2512.           if (ldrisd)
  2513.             TERM_FAO ("   dynamic            !XA-!XA!/",
  2514.                       ldrisd->ldrisd$p_base,
  2515.                       (unsigned __int64) ldrisd->ldrisd$p_base
  2516.                       + ldrisd->ldrisd$i_len - 1);
  2517.         }
  2518.     }

  2520.   if (has_threads)
  2521.     threads_init ();

  2523.   /* Wait for connection.  */
  2524.   sock_init ();

  2526.   /* Set primary exception vector.  */
  2527.   {
  2528.     unsigned int status;
  2529.     status = sys$setexv (0, excp_handler, PSL$C_USER, (__void_ptr32) &prevhnd);
  2530.     if (!(status & STS$M_SUCCESS))
  2531.       LIB$SIGNAL (status);
  2532.   }

  2534.   if (is_attached)
  2535.     {
  2536.       return excp_handler ((struct chf$signal_array *) progxfer[2],
  2537.                            (struct chf$mech_array *) progxfer[3]);
  2538.     }

  2540.   /* Change first instruction to set a breakpoint.  */
  2541.   {
  2542.     /*
  2543.       01 08 00 40 00 00         [MII]       break.m 0x80001
  2544.       00 00 00 02 00 00                     nop.i 0x0
  2545.       00 00 04 00                           nop.i 0x0;;
  2546.     */
  2547.     static const unsigned char initbp[16] =
  2548.       { 0x01, 0x08, 0x00, 0x40, 0x00, 0x00,
  2549.         0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
  2550.         0x00, 0x00, 0x04, 0x00 };
  2551.     unsigned int entry_prot;
  2552.     unsigned int status;

  2554.     status = page_set_rw (entry_pc, 16, &entry_prot);

  2556.     if (!(status & STS$M_SUCCESS))
  2557.       {
  2558.         if ((status & STS$M_COND_ID) == (SS$_NOT_PROCESS_VA & STS$M_COND_ID))
  2559.           {
  2560.             /* Cannot write here.  This can happen when pthreads are
  2561.                used.  */
  2562.             entry_pc = 0;
  2563.             term_puts ("gdbstub: cannot set breakpoint on entry\n");
  2564.           }
  2565.         else
  2566.           LIB$SIGNAL (status);
  2567.       }

  2569.     if (entry_pc != 0)
  2570.       {
  2571.         ots$move (entry_saved, 16, (void *)entry_pc);
  2572.         ots$move ((void *)entry_pc, 16, (void *)initbp);
  2573.         __fc (entry_pc);
  2574.         page_restore_rw (entry_pc, 16, entry_prot);
  2575.       }
  2576.   }

  2578.   /* If it wasn't possible to set a breakpoint on the entry point,
  2579.      accept gdb commands now.  Note that registers are not updated.  */
  2580.   if (entry_pc == 0)
  2581.     {
  2582.       while (one_command () == 0)
  2583.         ;
  2584.     }

  2586.   /* We will see!  */
  2587.   return SS$_CONTINUE;
  2588. }

  2590. /* Declare the entry point of this relocatable module.  */

  2592. ‌struct xfer_vector
  2593. {
  2594.   __int64 impure_start;
  2595.   __int64 impure_end;
  2596.   int (*entry) ();
  2597. };

  2599. #pragma __extern_model save
  2600. #pragma __extern_model strict_refdef "XFER_PSECT"
  2601. ‌struct xfer_vector xfer_vector = {0, 0, stub_start};
  2602. #pragma __extern_model restore