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