gdb/gdbserver/server.h

   1 /* Common definitions for remote server for GDB.
   2    Copyright (C) 1993, 1995, 1997, 1998, 1999, 2000, 2002, 2003, 2004, 2005,
   3    2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #ifndef SERVER_H
  21 #define SERVER_H
  22
  23 #include "config.h"
  24
  25 #ifdef __MINGW32CE__
  26 #include "wincecompat.h"
  27 #endif
  28
  29 #include <stdarg.h>
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #ifdef HAVE_ERRNO_H
  33 #include <errno.h>
  34 #endif
  35 #include <setjmp.h>
  36
  37 #ifdef HAVE_STRING_H
  38 #include <string.h>
  39 #endif
  40
  41 #ifdef HAVE_ALLOCA_H
  42 #include <alloca.h>
  43 #endif
  44 /* On some systems such as MinGW, alloca is declared in malloc.h
  45    (there is no alloca.h).  */
  46 #if HAVE_MALLOC_H
  47 #include <malloc.h>
  48 #endif
  49
  50 #if !HAVE_DECL_STRERROR
  51 #ifndef strerror
  52 extern char *strerror (int);    /* X3.159-1989  4.11.6.2 */
  53 #endif
  54 #endif
  55
  56 #if !HAVE_DECL_PERROR
  57 #ifndef perror
  58 extern void perror (const char *);
  59 #endif
  60 #endif
  61
  62 #if !HAVE_DECL_MEMMEM
  63 extern void *memmem (const void *, size_t , const void *, size_t);
  64 #endif
  65
  66 #if !HAVE_DECL_VASPRINTF
  67 extern int vasprintf(char **strp, const char *fmt, va_list ap);
  68 #endif
  69 #if !HAVE_DECL_VSNPRINTF
  70 int vsnprintf(char *str, size_t size, const char *format, va_list ap);
  71 #endif
  72
  73 #ifndef ATTR_NORETURN
  74 #if defined(__GNUC__) && (__GNUC__ > 2 \
  75                           || (__GNUC__ == 2 && __GNUC_MINOR__ >= 7))
  76 #define ATTR_NORETURN __attribute__ ((noreturn))
  77 #else
  78 #define ATTR_NORETURN           /* nothing */
  79 #endif
  80 #endif
  81
  82 #ifndef ATTR_FORMAT
  83 #if defined(__GNUC__) && (__GNUC__ > 2 \
  84                           || (__GNUC__ == 2 && __GNUC_MINOR__ >= 4))
  85 #define ATTR_FORMAT(type, x, y) __attribute__ ((format(type, x, y)))
  86 #else
  87 #define ATTR_FORMAT(type, x, y) /* nothing */
  88 #endif
  89 #endif
  90
  91 #ifndef ATTR_MALLOC
  92 #if defined(__GNUC__) && (__GNUC__ >= 3)
  93 #define ATTR_MALLOC __attribute__ ((__malloc__))
  94 #else
  95 #define ATTR_MALLOC             /* nothing */
  96 #endif
  97 #endif
  98
  99 /* Define underscore macro, if not available, to be able to use it inside
 100    code shared with gdb in common directory.  */
 101 #ifndef _
 102 #define _(String) (String)
 103 #endif
 104
 105 /* A type used for binary buffers.  */
 106 typedef unsigned char gdb_byte;
 107
 108 /* FIXME: This should probably be autoconf'd for.  It's an integer type at
 109    least the size of a (void *).  */
 110 typedef long long CORE_ADDR;
 111
 112 typedef long long LONGEST;
 113 typedef unsigned long long ULONGEST;
 114
 115 /* The ptid struct is a collection of the various "ids" necessary
 116    for identifying the inferior.  This consists of the process id
 117    (pid), thread id (tid), and other fields necessary for uniquely
 118    identifying the inferior process/thread being debugged.  When
 119    manipulating ptids, the constructors, accessors, and predicate
 120    declared in server.h should be used.  These are as follows:
 121
 122       ptid_build        - Make a new ptid from a pid, lwp, and tid.
 123       pid_to_ptid       - Make a new ptid from just a pid.
 124       ptid_get_pid      - Fetch the pid component of a ptid.
 125       ptid_get_lwp      - Fetch the lwp component of a ptid.
 126       ptid_get_tid      - Fetch the tid component of a ptid.
 127       ptid_equal        - Test to see if two ptids are equal.
 128
 129    Please do NOT access the struct ptid members directly (except, of
 130    course, in the implementation of the above ptid manipulation
 131    functions).  */
 132
 133 struct ptid
 134   {
 135     /* Process id */
 136     int pid;
 137
 138     /* Lightweight process id */
 139     long lwp;
 140
 141     /* Thread id */
 142     long tid;
 143   };
 144
 145 typedef struct ptid ptid_t;
 146
 147 /* The -1 ptid, often used to indicate either an error condition or a
 148    "don't care" condition, i.e, "run all threads".  */
 149 extern ptid_t minus_one_ptid;
 150
 151 /* The null or zero ptid, often used to indicate no process.  */
 152 extern ptid_t null_ptid;
 153
 154 /* Attempt to find and return an existing ptid with the given PID,
 155    LWP, and TID components.  If none exists, create a new one and
 156    return that.  */
 157 ptid_t ptid_build (int pid, long lwp, long tid);
 158
 159 /* Create a ptid from just a pid.  */
 160 ptid_t pid_to_ptid (int pid);
 161
 162 /* Fetch the pid (process id) component from a ptid.  */
 163 int ptid_get_pid (ptid_t ptid);
 164
 165 /* Fetch the lwp (lightweight process) component from a ptid.  */
 166 long ptid_get_lwp (ptid_t ptid);
 167
 168 /* Fetch the tid (thread id) component from a ptid.  */
 169 long ptid_get_tid (ptid_t ptid);
 170
 171 /* Compare two ptids to see if they are equal.  */
 172 extern int ptid_equal (ptid_t p1, ptid_t p2);
 173
 174 /* Return true if this ptid represents a process id.  */
 175 extern int ptid_is_pid (ptid_t ptid);
 176
 177 /* Generic information for tracking a list of ``inferiors'' - threads,
 178    processes, etc.  */
 179 struct inferior_list
 180 {
 181   struct inferior_list_entry *head;
 182   struct inferior_list_entry *tail;
 183 };
 184 struct inferior_list_entry
 185 {
 186   ptid_t id;
 187   struct inferior_list_entry *next;
 188 };
 189
 190 struct thread_info;
 191 struct process_info;
 192 struct regcache;
 193
 194 #include "regcache.h"
 195 #include "gdb/signals.h"
 196 #include "gdb_signals.h"
 197 #include "target.h"
 198 #include "mem-break.h"
 199
 200 struct thread_info
 201 {
 202   struct inferior_list_entry entry;
 203   void *target_data;
 204   void *regcache_data;
 205
 206   /* The last resume GDB requested on this thread.  */
 207   enum resume_kind last_resume_kind;
 208
 209   /* The last wait status reported for this thread.  */
 210   struct target_waitstatus last_status;
 211
 212   /* Given `while-stepping', a thread may be collecting data for more
 213      than one tracepoint simultaneously.  E.g.:
 214
 215     ff0001  INSN1 <-- TP1, while-stepping 10 collect $regs
 216     ff0002  INSN2
 217     ff0003  INSN3 <-- TP2, collect $regs
 218     ff0004  INSN4 <-- TP3, while-stepping 10 collect $regs
 219     ff0005  INSN5
 220
 221    Notice that when instruction INSN5 is reached, the while-stepping
 222    actions of both TP1 and TP3 are still being collected, and that TP2
 223    had been collected meanwhile.  The whole range of ff0001-ff0005
 224    should be single-stepped, due to at least TP1's while-stepping
 225    action covering the whole range.
 226
 227    On the other hand, the same tracepoint with a while-stepping action
 228    may be hit by more than one thread simultaneously, hence we can't
 229    keep the current step count in the tracepoint itself.
 230
 231    This is the head of the list of the states of `while-stepping'
 232    tracepoint actions this thread is now collecting; NULL if empty.
 233    Each item in the list holds the current step of the while-stepping
 234    action.  */
 235   struct wstep_state *while_stepping;
 236 };
 237
 238 struct dll_info
 239 {
 240   struct inferior_list_entry entry;
 241   char *name;
 242   CORE_ADDR base_addr;
 243 };
 244
 245 struct sym_cache;
 246 struct breakpoint;
 247 struct raw_breakpoint;
 248 struct fast_tracepoint_jump;
 249 struct process_info_private;
 250
 251 struct process_info
 252 {
 253   struct inferior_list_entry head;
 254
 255   /* Nonzero if this child process was attached rather than
 256      spawned.  */
 257   int attached;
 258
 259   /* True if GDB asked us to detach from this process, but we remained
 260      attached anyway.  */
 261   int gdb_detached;
 262
 263   /* The symbol cache.  */
 264   struct sym_cache *symbol_cache;
 265
 266   /* The list of memory breakpoints.  */
 267   struct breakpoint *breakpoints;
 268
 269   /* The list of raw memory breakpoints.  */
 270   struct raw_breakpoint *raw_breakpoints;
 271
 272   /* The list of installed fast tracepoints.  */
 273   struct fast_tracepoint_jump *fast_tracepoint_jumps;
 274
 275   /* Private target data.  */
 276   struct process_info_private *private;
 277 };
 278
 279 /* Return a pointer to the process that corresponds to the current
 280    thread (current_inferior).  It is an error to call this if there is
 281    no current thread selected.  */
 282
 283 struct process_info *current_process (void);
 284 struct process_info *get_thread_process (struct thread_info *);
 285
 286 /* Target-specific functions */
 287
 288 void initialize_low ();
 289
 290 /* From inferiors.c.  */
 291
 292 extern struct inferior_list all_processes;
 293 extern struct inferior_list all_threads;
 294 extern struct inferior_list all_dlls;
 295 extern int dlls_changed;
 296
 297 void initialize_inferiors (void);
 298
 299 void add_inferior_to_list (struct inferior_list *list,
 300                            struct inferior_list_entry *new_inferior);
 301 void for_each_inferior (struct inferior_list *list,
 302                         void (*action) (struct inferior_list_entry *));
 303
 304 extern struct thread_info *current_inferior;
 305 void remove_inferior (struct inferior_list *list,
 306                       struct inferior_list_entry *entry);
 307 void remove_thread (struct thread_info *thread);
 308 void add_thread (ptid_t ptid, void *target_data);
 309
 310 struct process_info *add_process (int pid, int attached);
 311 void remove_process (struct process_info *process);
 312 struct process_info *find_process_pid (int pid);
 313 int have_started_inferiors_p (void);
 314 int have_attached_inferiors_p (void);
 315
 316 struct thread_info *find_thread_ptid (ptid_t ptid);
 317
 318 ptid_t thread_id_to_gdb_id (ptid_t);
 319 ptid_t thread_to_gdb_id (struct thread_info *);
 320 ptid_t gdb_id_to_thread_id (ptid_t);
 321 struct thread_info *gdb_id_to_thread (unsigned int);
 322 void clear_inferiors (void);
 323 struct inferior_list_entry *find_inferior
 324      (struct inferior_list *,
 325       int (*func) (struct inferior_list_entry *,
 326                    void *),
 327       void *arg);
 328 struct inferior_list_entry *find_inferior_id (struct inferior_list *list,
 329                                               ptid_t id);
 330 void *inferior_target_data (struct thread_info *);
 331 void set_inferior_target_data (struct thread_info *, void *);
 332 void *inferior_regcache_data (struct thread_info *);
 333 void set_inferior_regcache_data (struct thread_info *, void *);
 334 void add_pid_to_list (struct inferior_list *list, unsigned long pid);
 335 int pull_pid_from_list (struct inferior_list *list, unsigned long pid);
 336
 337 void loaded_dll (const char *name, CORE_ADDR base_addr);
 338 void unloaded_dll (const char *name, CORE_ADDR base_addr);
 339
 340 /* Public variables in server.c */
 341
 342 extern ptid_t cont_thread;
 343 extern ptid_t general_thread;
 344 extern ptid_t step_thread;
 345
 346 extern int server_waiting;
 347 extern int debug_threads;
 348 extern int debug_hw_points;
 349 extern int pass_signals[];
 350
 351 extern jmp_buf toplevel;
 352
 353 extern int disable_packet_vCont;
 354 extern int disable_packet_Tthread;
 355 extern int disable_packet_qC;
 356 extern int disable_packet_qfThreadInfo;
 357
 358 extern int run_once;
 359 extern int multi_process;
 360 extern int non_stop;
 361
 362 #if USE_WIN32API
 363 #include <winsock2.h>
 364 typedef SOCKET gdb_fildes_t;
 365 #else
 366 typedef int gdb_fildes_t;
 367 #endif
 368
 369 /* Functions from event-loop.c.  */
 370 typedef void *gdb_client_data;
 371 typedef int (handler_func) (int, gdb_client_data);
 372 typedef int (callback_handler_func) (gdb_client_data);
 373
 374 extern void delete_file_handler (gdb_fildes_t fd);
 375 extern void add_file_handler (gdb_fildes_t fd, handler_func *proc,
 376                               gdb_client_data client_data);
 377 extern int append_callback_event (callback_handler_func *proc,
 378                                    gdb_client_data client_data);
 379 extern void delete_callback_event (int id);
 380
 381 extern void start_event_loop (void);
 382
 383 /* Functions from server.c.  */
 384 extern int handle_serial_event (int err, gdb_client_data client_data);
 385 extern int handle_target_event (int err, gdb_client_data client_data);
 386
 387 extern void push_event (ptid_t ptid, struct target_waitstatus *status);
 388
 389 /* Functions from hostio.c.  */
 390 extern int handle_vFile (char *, int, int *);
 391
 392 /* Functions from hostio-errno.c.  */
 393 extern void hostio_last_error_from_errno (char *own_buf);
 394
 395 /* From remote-utils.c */
 396
 397 extern int remote_debug;
 398 extern int noack_mode;
 399 extern int transport_is_reliable;
 400
 401 int gdb_connected (void);
 402
 403 ptid_t read_ptid (char *buf, char **obuf);
 404 char *write_ptid (char *buf, ptid_t ptid);
 405
 406 int putpkt (char *buf);
 407 int putpkt_binary (char *buf, int len);
 408 int putpkt_notif (char *buf);
 409 int getpkt (char *buf);
 410 void remote_prepare (char *name);
 411 void remote_open (char *name);
 412 void remote_close (void);
 413 void write_ok (char *buf);
 414 void write_enn (char *buf);
 415 void initialize_async_io (void);
 416 void enable_async_io (void);
 417 void disable_async_io (void);
 418 void check_remote_input_interrupt_request (void);
 419 void convert_ascii_to_int (const char *from, unsigned char *to, int n);
 420 void convert_int_to_ascii (const unsigned char *from, char *to, int n);
 421 void new_thread_notify (int id);
 422 void dead_thread_notify (int id);
 423 void prepare_resume_reply (char *buf, ptid_t ptid,
 424                            struct target_waitstatus *status);
 425
 426 const char *decode_address_to_semicolon (CORE_ADDR *addrp, const char *start);
 427 void decode_address (CORE_ADDR *addrp, const char *start, int len);
 428 void decode_m_packet (char *from, CORE_ADDR * mem_addr_ptr,
 429                       unsigned int *len_ptr);
 430 void decode_M_packet (char *from, CORE_ADDR * mem_addr_ptr,
 431                       unsigned int *len_ptr, unsigned char **to_p);
 432 int decode_X_packet (char *from, int packet_len, CORE_ADDR * mem_addr_ptr,
 433                      unsigned int *len_ptr, unsigned char **to_p);
 434 int decode_xfer_write (char *buf, int packet_len,
 435                        CORE_ADDR *offset, unsigned int *len,
 436                        unsigned char *data);
 437 int decode_search_memory_packet (const char *buf, int packet_len,
 438                                  CORE_ADDR *start_addrp,
 439                                  CORE_ADDR *search_space_lenp,
 440                                  gdb_byte *pattern,
 441                                  unsigned int *pattern_lenp);
 442
 443 int unhexify (char *bin, const char *hex, int count);
 444 int hexify (char *hex, const char *bin, int count);
 445 int remote_escape_output (const gdb_byte *buffer, int len,
 446                           gdb_byte *out_buf, int *out_len,
 447                           int out_maxlen);
 448 char *unpack_varlen_hex (char *buff,  ULONGEST *result);
 449
 450 void clear_symbol_cache (struct sym_cache **symcache_p);
 451 int look_up_one_symbol (const char *name, CORE_ADDR *addrp, int may_ask_gdb);
 452
 453 int relocate_instruction (CORE_ADDR *to, CORE_ADDR oldloc);
 454
 455 void monitor_output (const char *msg);
 456
 457 char *xml_escape_text (const char *text);
 458
 459 /* Simple growing buffer.  */
 460
 461 struct buffer
 462 {
 463   char *buffer;
 464   size_t buffer_size; /* allocated size */
 465   size_t used_size; /* actually used size */
 466 };
 467
 468 /* Append DATA of size SIZE to the end of BUFFER.  Grows the buffer to
 469    accommodate the new data.  */
 470 void buffer_grow (struct buffer *buffer, const char *data, size_t size);
 471
 472 /* Release any memory held by BUFFER.  */
 473 void buffer_free (struct buffer *buffer);
 474
 475 /* Initialize BUFFER.  BUFFER holds no memory afterwards.  */
 476 void buffer_init (struct buffer *buffer);
 477
 478 /* Return a pointer into BUFFER data, effectivelly transfering
 479    ownership of the buffer memory to the caller.  Calling buffer_free
 480    afterwards has no effect on the returned data.  */
 481 char* buffer_finish (struct buffer *buffer);
 482
 483 /* Simple printf to BUFFER function.  Current implemented formatters:
 484    %s - grow an xml escaped text in OBSTACK.  */
 485 void buffer_xml_printf (struct buffer *buffer, const char *format, ...)
 486   ATTR_FORMAT (printf, 2, 3);
 487
 488 #define buffer_grow_str(BUFFER,STRING)         \
 489   buffer_grow (BUFFER, STRING, strlen (STRING))
 490 #define buffer_grow_str0(BUFFER,STRING)                        \
 491   buffer_grow (BUFFER, STRING, strlen (STRING) + 1)
 492
 493 /* Functions from utils.c */
 494
 495 void *xmalloc (size_t) ATTR_MALLOC;
 496 void *xrealloc (void *, size_t);
 497 void *xcalloc (size_t, size_t) ATTR_MALLOC;
 498 char *xstrdup (const char *) ATTR_MALLOC;
 499 int xsnprintf (char *str, size_t size, const char *format, ...)
 500   ATTR_FORMAT (printf, 3, 4);;
 501 void freeargv (char **argv);
 502 void perror_with_name (const char *string);
 503 void error (const char *string,...) ATTR_NORETURN ATTR_FORMAT (printf, 1, 2);
 504 void fatal (const char *string,...) ATTR_NORETURN ATTR_FORMAT (printf, 1, 2);
 505 void internal_error (const char *file, int line, const char *, ...)
 506      ATTR_NORETURN ATTR_FORMAT (printf, 3, 4);
 507 void warning (const char *string,...) ATTR_FORMAT (printf, 1, 2);
 508 char *paddress (CORE_ADDR addr);
 509 char *pulongest (ULONGEST u);
 510 char *plongest (LONGEST l);
 511 char *phex_nz (ULONGEST l, int sizeof_l);
 512 char *pfildes (gdb_fildes_t fd);
 513
 514 #define gdb_assert(expr)                                                      \
 515   ((void) ((expr) ? 0 :                                                       \
 516            (gdb_assert_fail (#expr, __FILE__, __LINE__, ASSERT_FUNCTION), 0)))
 517
 518 /* Version 2.4 and later of GCC define a magical variable `__PRETTY_FUNCTION__'
 519    which contains the name of the function currently being defined.
 520    This is broken in G++ before version 2.6.
 521    C9x has a similar variable called __func__, but prefer the GCC one since
 522    it demangles C++ function names.  */
 523 #if (GCC_VERSION >= 2004)
 524 #define ASSERT_FUNCTION         __PRETTY_FUNCTION__
 525 #else
 526 #if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L
 527 #define ASSERT_FUNCTION         __func__
 528 #endif
 529 #endif
 530
 531 /* This prints an "Assertion failed" message, and exits.  */
 532 #if defined (ASSERT_FUNCTION)
 533 #define gdb_assert_fail(assertion, file, line, function)                \
 534   internal_error (file, line, "%s: Assertion `%s' failed.",             \
 535                   function, assertion)
 536 #else
 537 #define gdb_assert_fail(assertion, file, line, function)                \
 538   internal_error (file, line, "Assertion `%s' failed.",                 \
 539                   assertion)
 540 #endif
 541
 542 /* Maximum number of bytes to read/write at once.  The value here
 543    is chosen to fill up a packet (the headers account for the 32).  */
 544 #define MAXBUFBYTES(N) (((N)-32)/2)
 545
 546 /* Buffer sizes for transferring memory, registers, etc.   Set to a constant
 547    value to accomodate multiple register formats.  This value must be at least
 548    as large as the largest register set supported by gdbserver.  */
 549 #define PBUFSIZ 16384
 550
 551 /* Functions from tracepoint.c */
 552
 553 int in_process_agent_loaded (void);
 554
 555 void initialize_tracepoint (void);
 556
 557 extern int tracing;
 558 extern int disconnected_tracing;
 559
 560 void tracepoint_look_up_symbols (void);
 561
 562 void stop_tracing (void);
 563
 564 int handle_tracepoint_general_set (char *own_buf);
 565 int handle_tracepoint_query (char *own_buf);
 566
 567 int tracepoint_finished_step (struct thread_info *tinfo, CORE_ADDR stop_pc);
 568 int tracepoint_was_hit (struct thread_info *tinfo, CORE_ADDR stop_pc);
 569
 570 void release_while_stepping_state_list (struct thread_info *tinfo);
 571
 572 extern int current_traceframe;
 573
 574 int in_readonly_region (CORE_ADDR addr, ULONGEST length);
 575 int traceframe_read_mem (int tfnum, CORE_ADDR addr,
 576                          unsigned char *buf, ULONGEST length,
 577                          ULONGEST *nbytes);
 578 int fetch_traceframe_registers (int tfnum,
 579                                 struct regcache *regcache,
 580                                 int regnum);
 581
 582 int traceframe_read_sdata (int tfnum, ULONGEST offset,
 583                            unsigned char *buf, ULONGEST length,
 584                            ULONGEST *nbytes);
 585
 586 int traceframe_read_info (int tfnum, struct buffer *buffer);
 587
 588 /* If a thread is determined to be collecting a fast tracepoint, this
 589    structure holds the collect status.  */
 590
 591 struct fast_tpoint_collect_status
 592 {
 593   /* The tracepoint that is presently being collected.  */
 594   int tpoint_num;
 595   CORE_ADDR tpoint_addr;
 596
 597   /* The address range in the jump pad of where the original
 598      instruction the tracepoint jump was inserted was relocated
 599      to.  */
 600   CORE_ADDR adjusted_insn_addr;
 601   CORE_ADDR adjusted_insn_addr_end;
 602 };
 603
 604 int fast_tracepoint_collecting (CORE_ADDR thread_area,
 605                                 CORE_ADDR stop_pc,
 606                                 struct fast_tpoint_collect_status *status);
 607 void force_unlock_trace_buffer (void);
 608
 609 int handle_tracepoint_bkpts (struct thread_info *tinfo, CORE_ADDR stop_pc);
 610
 611 #ifdef IN_PROCESS_AGENT
 612 void initialize_low_tracepoint (void);
 613 void supply_fast_tracepoint_registers (struct regcache *regcache,
 614                                        const unsigned char *regs);
 615 void supply_static_tracepoint_registers (struct regcache *regcache,
 616                                          const unsigned char *regs,
 617                                          CORE_ADDR pc);
 618 #else
 619 void stop_tracing (void);
 620 #endif
 621
 622 /* Bytecode compilation function vector.  */
 623
 624 struct emit_ops
 625 {
 626   void (*emit_prologue) (void);
 627   void (*emit_epilogue) (void);
 628   void (*emit_add) (void);
 629   void (*emit_sub) (void);
 630   void (*emit_mul) (void);
 631   void (*emit_lsh) (void);
 632   void (*emit_rsh_signed) (void);
 633   void (*emit_rsh_unsigned) (void);
 634   void (*emit_ext) (int arg);
 635   void (*emit_log_not) (void);
 636   void (*emit_bit_and) (void);
 637   void (*emit_bit_or) (void);
 638   void (*emit_bit_xor) (void);
 639   void (*emit_bit_not) (void);
 640   void (*emit_equal) (void);
 641   void (*emit_less_signed) (void);
 642   void (*emit_less_unsigned) (void);
 643   void (*emit_ref) (int size);
 644   void (*emit_if_goto) (int *offset_p, int *size_p);
 645   void (*emit_goto) (int *offset_p, int *size_p);
 646   void (*write_goto_address) (CORE_ADDR from, CORE_ADDR to, int size);
 647   void (*emit_const) (LONGEST num);
 648   void (*emit_call) (CORE_ADDR fn);
 649   void (*emit_reg) (int reg);
 650   void (*emit_pop) (void);
 651   void (*emit_stack_flush) (void);
 652   void (*emit_zero_ext) (int arg);
 653   void (*emit_swap) (void);
 654   void (*emit_stack_adjust) (int n);
 655
 656   /* Emit code for a generic function that takes one fixed integer
 657      argument and returns a 64-bit int (for instance, tsv getter).  */
 658   void (*emit_int_call_1) (CORE_ADDR fn, int arg1);
 659
 660   /* Emit code for a generic function that takes one fixed integer
 661      argument and a 64-bit int from the top of the stack, and returns
 662      nothing (for instance, tsv setter).  */
 663   void (*emit_void_call_2) (CORE_ADDR fn, int arg1);
 664 };
 665
 666 /* Returns the address of the get_raw_reg function in the IPA.  */
 667 CORE_ADDR get_raw_reg_func_addr (void);
 668
 669 CORE_ADDR current_insn_ptr;
 670 int emit_error;
 671
 672 /* Version information, from version.c.  */
 673 extern const char version[];
 674 extern const char host_name[];
 675
 676 #endif /* SERVER_H */