OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gdb-7.2/] [gdb/] [gdbserver/] [server.h] - Blame information for rev 835

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.