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

Subversion Repositories zet86

[/] [zet86/] [trunk/] [src/] [bochs-diff-2.3.7/] [bochs.h] - Blame information for rev 49

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

Line No. Rev Author Line
1 39 zeus
/////////////////////////////////////////////////////////////////////////
2 43 zeus
// $Id: bochs.h,v 1.5 2009-02-06 03:48:29 zeus Exp $
3 39 zeus
/////////////////////////////////////////////////////////////////////////
4
//
5
//  Copyright (C) 2002  MandrakeSoft S.A.
6
//
7
//    MandrakeSoft S.A.
8
//    43, rue d'Aboukir
9
//    75002 Paris - France
10
//    http://www.linux-mandrake.com/
11
//    http://www.mandrakesoft.com/
12
//
13
//  This library is free software; you can redistribute it and/or
14
//  modify it under the terms of the GNU Lesser General Public
15
//  License as published by the Free Software Foundation; either
16
//  version 2 of the License, or (at your option) any later version.
17
//
18
//  This library is distributed in the hope that it will be useful,
19
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
20
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
21
//  Lesser General Public License for more details.
22
//
23
//  You should have received a copy of the GNU Lesser General Public
24
//  License along with this library; if not, write to the Free Software
25
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
26
 
27
//
28
// bochs.h is the master header file for all C++ code.  It includes all
29
// the system header files needed by bochs, and also includes all the bochs
30
// C++ header files.  Because bochs.h and the files that it includes has
31
// structure and class definitions, it cannot be called from C code.
32
//
33
 
34
#ifndef BX_BOCHS_H
35
#  define BX_BOCHS_H 1
36
 
37
#include "config.h"      /* generated by configure script from config.h.in */
38
 
39
#ifndef __QNXNTO__
40
extern "C" {
41
#endif
42
 
43
#ifdef WIN32
44
// In a win32 compile (including cygwin), windows.h is required for several
45
// files in gui and iodev.  It is important to include it here in a header
46
// file so that WIN32-specific data types can be used in fields of classes.
47
#include <windows.h>
48
#endif
49
 
50
#include <stdarg.h>
51
#include <stdio.h>
52
#include <stdlib.h>
53
#if defined(__sun__)
54
#undef EAX
55
#undef ECX
56
#undef EDX
57
#undef EBX
58
#undef ESP
59
#undef EBP
60
#undef ESI
61
#undef EDI
62
#undef EIP
63
#undef CS
64
#undef DS
65
#undef ES
66
#undef SS
67
#undef FS
68
#undef GS
69
#endif
70
#include <assert.h>
71
#include <errno.h>
72
 
73
#ifndef WIN32
74
#  include <unistd.h>
75
#else
76
#  include <io.h>
77
#endif
78
#include <time.h>
79
#if BX_WITH_MACOS
80
#  include <types.h>
81
#  include <stat.h>
82
#  include <cstdio>
83
#  include <unistd.h>
84
#elif BX_WITH_CARBON
85
#  include <sys/types.h>
86
#  include <sys/stat.h>
87
#  include <sys/param.h> /* for MAXPATHLEN */
88
#  include <sys/time.h>
89
#  include <utime.h>
90
#else
91
#  ifndef WIN32
92
#    include <sys/time.h>
93
#  endif
94
#  include <sys/types.h>
95
#  include <sys/stat.h>
96
#endif
97
#include <ctype.h>
98
#include <string.h>
99
#include <fcntl.h>
100
#include <limits.h>
101
#ifdef macintosh
102
#  define SuperDrive "[fd:]"
103
#endif
104
 
105
#ifndef __QNXNTO__
106
}
107
#endif
108
 
109
#include "osdep.h"       /* platform dependent includes and defines */
110
#include "bx_debug/debug.h"
111
#include "bxversion.h"
112
 
113
#include "gui/siminterface.h"
114
 
115
// BX_SHARE_PATH should be defined by the makefile.  If not, give it
116
// a value of NULL to avoid compile problems.
117
#ifndef BX_SHARE_PATH
118
#define BX_SHARE_PATH NULL
119
#endif
120
 
121
// prototypes
122
int bx_begin_simulation(int argc, char *argv[]);
123
void bx_stop_simulation();
124
char *bx_find_bochsrc(void);
125
int bx_parse_cmdline(int arg, int argc, char *argv[]);
126
int bx_read_configuration(const char *rcfile);
127
int bx_write_configuration(const char *rcfile, int overwrite);
128
void bx_reset_options(void);
129
Bit32u crc32(const Bit8u *buf, int len);
130
// for param-tree testing only
131
void print_tree(bx_param_c *node, int level = 0);
132
 
133
//
134
// some macros to interface the CPU and memory to external environment
135
// so that these functions can be redirected to the debugger when
136
// needed.
137
//
138
 
139
#define BXRS_PARAM_SPECIAL(parent, name, maxvalue, save_handler, restore_handler) \
140
{ \
141
  bx_param_num_c *param = new bx_param_num_c(parent, #name, "", "", 0, maxvalue, 0); \
142
  param->set_base(BASE_HEX); \
143
  param->set_sr_handlers(this, save_handler, restore_handler); \
144
}
145
 
146
#define BXRS_PARAM_SPECIAL64(parent, name, save_handler, restore_handler) \
147
  BXRS_PARAM_SPECIAL(parent, name, BX_MAX_BIT64U, save_handler, restore_handler)
148
#define BXRS_PARAM_SPECIAL32(parent, name, save_handler, restore_handler) \
149
  BXRS_PARAM_SPECIAL(parent, name, BX_MAX_BIT32U, save_handler, restore_handler)
150
#define BXRS_PARAM_SPECIAL16(parent, name, save_handler, restore_handler) \
151
  BXRS_PARAM_SPECIAL(parent, name, BX_MAX_BIT16U, save_handler, restore_handler)
152
#define BXRS_PARAM_SPECIAL8(parent, name, save_handler, restore_handler) \
153
  BXRS_PARAM_SPECIAL(parent, name, BX_MAX_BIT8U,  save_handler, restore_handler)
154
 
155
#define BXRS_HEX_PARAM_SIMPLE32(parent, name) \
156
  new bx_shadow_num_c(parent, #name, (Bit32u*)&(name), BASE_HEX)
157
#define BXRS_HEX_PARAM_SIMPLE64(parent, name) \
158
  new bx_shadow_num_c(parent, #name, (Bit64u*)&(name), BASE_HEX)
159
 
160
#define BXRS_HEX_PARAM_SIMPLE(parent, name) \
161
  new bx_shadow_num_c(parent, #name, &(name), BASE_HEX)
162
#define BXRS_HEX_PARAM_FIELD(parent, name, field) \
163
  new bx_shadow_num_c(parent, #name, &(field), BASE_HEX)
164
 
165
#define BXRS_DEC_PARAM_SIMPLE(parent, name) \
166
  new bx_shadow_num_c(parent, #name, &(name), BASE_DEC)
167
#define BXRS_DEC_PARAM_FIELD(parent, name, field) \
168
  new bx_shadow_num_c(parent, #name, &(field), BASE_DEC)
169
 
170
#define BXRS_PARAM_BOOL(parent, name, field) \
171
  new bx_shadow_bool_c(parent, #name, (bx_bool*)(&(field)))
172
 
173
// =-=-=-=-=-=-=- Normal optimized use -=-=-=-=-=-=-=-=-=-=-=-=-=-=
174
// some pc_systems functions just redirect to the IO devices so optimize
175
// by eliminating call here
176
//
177
// #define BX_INP(addr, len)        bx_pc_system.inp(addr, len)
178
// #define BX_OUTP(addr, val, len)  bx_pc_system.outp(addr, val, len)
179
#define BX_INP(addr, len)           bx_devices.inp(addr, len)
180
#define BX_OUTP(addr, val, len)     bx_devices.outp(addr, val, len)
181
#define BX_TICK1()                  bx_pc_system.tick1()
182
#define BX_TICKN(n)                 bx_pc_system.tickn(n)
183
#define BX_INTR                     bx_pc_system.INTR
184
#define BX_SET_INTR(b)              bx_pc_system.set_INTR(b)
185
#define BX_CPU_C                    bx_cpu_c
186
#define BX_MEM_C                    bx_mem_c
187
#define BX_HRQ                      (bx_pc_system.HRQ)
188
 
189
#if BX_SUPPORT_SMP
190
#define BX_CPU(x)                   (bx_cpu_array[x])
191
#else
192
#define BX_CPU(x)                   (&bx_cpu)
193
#endif
194
 
195
#define BX_MEM(x)                   (&bx_mem)
196
 
197
#define BX_SET_ENABLE_A20(enabled)  bx_pc_system.set_enable_a20(enabled)
198
#define BX_GET_ENABLE_A20()         bx_pc_system.get_enable_a20()
199
 
200
#if BX_SUPPORT_A20
201
#  define A20ADDR(x)                (bx_phy_address(x) & bx_pc_system.a20_mask)
202
#else
203
#  define A20ADDR(x)                (bx_phy_address(x))
204
#endif
205
 
206
#if BX_SUPPORT_SMP
207
#  define BX_TICK1_IF_SINGLE_PROCESSOR() \
208
              if (BX_SMP_PROCESSORS == 1) BX_TICK1()
209
#  define BX_TICKN_IF_SINGLE_PROCESSOR(n) \
210
              if (BX_SMP_PROCESSORS == 1) BX_TICKN(n)
211
#else
212
#  define BX_TICK1_IF_SINGLE_PROCESSOR()  BX_TICK1()
213
#  define BX_TICKN_IF_SINGLE_PROCESSOR(n) BX_TICKN(n)
214
#endif
215
 
216
// you can't use static member functions on the CPU, if there are going
217
// to be 2 cpus.  Check this early on.
218
#if BX_SUPPORT_SMP
219
#  if BX_USE_CPU_SMF
220
#    error For SMP simulation, BX_USE_CPU_SMF must be 0.
221
#  endif
222
#endif
223
 
224
//
225
// Ways for the the external environment to report back information
226
// to the debugger.
227
//
228
 
229
#if BX_DEBUGGER
230
#  define BX_DBG_ASYNC_INTR bx_guard.async.irq
231
#  define BX_DBG_ASYNC_DMA  bx_guard.async.dma
232
 
233
#  define BX_DBG_DMA_REPORT(addr, len, what, val) \
234
        if (bx_guard.report.dma) bx_dbg_dma_report(addr, len, what, val)
235
#  define BX_DBG_IAC_REPORT(vector, irq) \
236
        if (bx_guard.report.irq) bx_dbg_iac_report(vector, irq)
237
#  define BX_DBG_A20_REPORT(val) \
238
        if (bx_guard.report.a20) bx_dbg_a20_report(val)
239
#  define BX_DBG_IO_REPORT(port, size, op, val) \
240
        if (bx_guard.report.io) bx_dbg_io_report(port, size, op, val)
241
#  define BX_DBG_UCMEM_REPORT(addr, size, op, val) \
242
        if (bx_guard.report.ucmem) bx_dbg_ucmem_report(addr, size, op, val)
243
#  define BX_DBG_LIN_MEMORY_ACCESS(cpu, lin, phy, len, pl, rw, data) \
244
        bx_dbg_lin_memory_access(cpu, lin, phy, len, pl, rw, data)
245
#  define BX_DBG_PHY_MEMORY_ACCESS(cpu, phy, len, rw, data) \
246
        bx_dbg_phy_memory_access(cpu, phy, len, rw, data)
247
#else  // #if BX_DEBUGGER
248
// debugger not compiled in, use empty stubs
249
#  define BX_DBG_ASYNC_INTR 1
250
#  define BX_DBG_ASYNC_DMA  1
251
#  define BX_DBG_DMA_REPORT(addr, len, what, val)                    /* empty */
252
#  define BX_DBG_IAC_REPORT(vector, irq)                             /* empty */
253
#  define BX_DBG_A20_REPORT(val)                                     /* empty */
254
#  define BX_DBG_IO_REPORT(addr, size, op, val)                      /* empty */
255
#  define BX_DBG_UCMEM_REPORT(addr, size, op, val)                   /* empty */
256
#  define BX_DBG_LIN_MEMORY_ACCESS(cpu, lin, phy, len, pl, rw, data) /* empty */
257
#  define BX_DBG_PHY_MEMORY_ACCESS(cpu, phy, len, rw, data)          /* empty */
258
#endif  // #if BX_DEBUGGER
259
 
260
#define MAGIC_LOGNUM 0x12345678
261
 
262
typedef class BOCHSAPI logfunctions
263
{
264
  char *prefix;
265
  int type;
266
// values of onoff: 0=ignore, 1=report, 2=ask, 3=fatal
267
#define ACT_IGNORE 0
268
#define ACT_REPORT 1
269
#define ACT_ASK    2
270
#define ACT_FATAL  3
271
#define N_ACT      4
272
  int onoff[N_LOGLEV];
273
  class iofunctions *logio;
274
  // default log actions for all devices, declared and initialized
275
  // in logio.cc.
276
  BOCHSAPI_CYGONLY static int default_onoff[N_LOGLEV];
277
public:
278
  logfunctions(void);
279
  logfunctions(class iofunctions *);
280
 ~logfunctions(void);
281
 
282
  void info(const char *fmt, ...)   BX_CPP_AttrPrintf(2, 3);
283
  void error(const char *fmt, ...)  BX_CPP_AttrPrintf(2, 3);
284
  void panic(const char *fmt, ...)  BX_CPP_AttrPrintf(2, 3);
285
  void pass(const char *fmt, ...)   BX_CPP_AttrPrintf(2, 3);
286
  void ldebug(const char *fmt, ...) BX_CPP_AttrPrintf(2, 3);
287
  void fatal (const char *prefix, const char *fmt, va_list ap, int exit_status);
288
#if BX_EXTERNAL_DEBUGGER
289
  virtual void ask (int level, const char *prefix, const char *fmt, va_list ap);
290
#else
291
  void ask (int level, const char *prefix, const char *fmt, va_list ap);
292
#endif
293
  void put(const char *);
294
  void settype(int);
295
  void setio(class iofunctions *);
296
  void setonoff(int loglev, int value) {
297
    assert (loglev >= 0 && loglev < N_LOGLEV);
298
    onoff[loglev] = value;
299
  }
300
  char *getprefix () { return prefix; }
301
  int getonoff(int level) {
302
    assert (level>=0 && level<N_LOGLEV);
303
    return onoff[level];
304
  }
305
  static void set_default_action (int loglev, int action) {
306
    assert (loglev >= 0 && loglev < N_LOGLEV);
307
    assert (action >= 0 && action < N_ACT);
308
    default_onoff[loglev] = action;
309
  }
310
  static int get_default_action (int loglev) {
311
    assert (loglev >= 0 && loglev < N_LOGLEV);
312
    return default_onoff[loglev];
313
  }
314
} logfunc_t;
315
 
316
#define BX_LOGPREFIX_SIZE 51
317
 
318
enum {
319
  IOLOG=0, FDLOG, GENLOG, CMOSLOG, CDLOG, DMALOG, ETHLOG, G2HLOG, HDLOG, KBDLOG,
320
  NE2KLOG, PARLOG, HDEMULOG, PCILOG, PICLOG, PITLOG, SB16LOG, SERLOG, VGALOG,
321
  DEVLOG, MEMLOG, DISLOG, GUILOG, IOAPICLOG, APICLOG, CPU0LOG, CPU1LOG,
322
  CPU2LOG, CPU3LOG, CPU4LOG, CPU5LOG, CPU6LOG, CPU7LOG, CPU8LOG, CPU9LOG,
323
  CPU10LOG, CPU11LOG, CPU12LOG, CPU13LOG, CPU14LOG, CPU15LOG, CTRLLOG,
324
  UNMAPLOG, SERRLOG, BIOSLOG, PIT81LOG, PIT82LOG, IODEBUGLOG, PCI2ISALOG,
325
  PLUGINLOG, EXTFPUIRQLOG , PCIVGALOG, PCIUSBLOG, VTIMERLOG, STIMERLOG,
326
  PCIIDELOG, PCIDEVLOG, PCIPNICLOG, SPEAKERLOG, BUSMLOG, GAMELOG, ACPILOG
327
};
328
 
329
class BOCHSAPI iofunctions {
330
  int magic;
331
  char logprefix[BX_LOGPREFIX_SIZE];
332
  FILE *logfd;
333
  class logfunctions *log;
334
  void init(void);
335
  void flush(void);
336
 
337
// Log Class types
338
public:
339
  iofunctions(void);
340
  iofunctions(FILE *);
341
  iofunctions(int);
342
  iofunctions(const char *);
343
 ~iofunctions(void);
344
 
345
  void out(int facility, int level, const char *pre, const char *fmt, va_list ap);
346
 
347
  void init_log(const char *fn);
348
  void init_log(int fd);
349
  void init_log(FILE *fs);
350
  void exit_log();
351
  void set_log_prefix(const char *prefix);
352
  int get_n_logfns() { return n_logfn; }
353
  logfunc_t *get_logfn(int index) { return logfn_list[index]; }
354
  void add_logfn(logfunc_t *fn);
355
  void remove_logfn(logfunc_t *fn);
356
  void set_log_action(int loglevel, int action);
357
  const char *getlevel(int i) {
358
    static const char *loglevel[N_LOGLEV] = {
359
      "DEBUG",
360
      "INFO",
361
      "ERROR",
362
      "PANIC",
363
      "PASS"
364
    };
365
    if (i>=0 && i<N_LOGLEV) return loglevel[i];
366
    else return "?";
367
  }
368
  char *getaction(int i) {
369
    static const char *name[] = { "ignore", "report", "ask", "fatal" };
370
    assert (i>=ACT_IGNORE && i<N_ACT);
371
    return (char *) name[i];
372
  }
373
 
374
protected:
375
  int n_logfn;
376
#define MAX_LOGFNS 128
377
  logfunc_t *logfn_list[MAX_LOGFNS];
378
  const char *logfn;
379
};
380
 
381
typedef class BOCHSAPI iofunctions iofunc_t;
382
 
383
#define SAFE_GET_IOFUNC() \
384
  ((io==NULL)? (io=new iofunc_t("/dev/stderr")) : io)
385
#define SAFE_GET_GENLOG() \
386
  ((genlog==NULL)? (genlog=new logfunc_t(SAFE_GET_IOFUNC())) : genlog)
387
 
388
#if BX_NO_LOGGING
389
 
390
#define BX_INFO(x)
391
#define BX_DEBUG(x)
392
#define BX_ERROR(x)
393
#define BX_PANIC(x) (LOG_THIS panic) x
394
#define BX_PASS(x) (LOG_THIS pass) x
395
 
396
#define BX_ASSERT(x)
397
 
398
#else
399
 
400
#define BX_INFO(x)  (LOG_THIS info) x
401
#define BX_DEBUG(x) (LOG_THIS ldebug) x
402
#define BX_ERROR(x) (LOG_THIS error) x
403
#define BX_PANIC(x) (LOG_THIS panic) x
404
#define BX_PASS(x) (LOG_THIS pass) x
405
 
406
#define BX_ASSERT(x) do {if (!(x)) BX_PANIC(("failed assertion \"%s\" at %s:%d\n", #x, __FILE__, __LINE__));} while (0)
407
 
408
#endif
409
 
410
BOCHSAPI extern iofunc_t *io;
411
BOCHSAPI extern logfunc_t *genlog;
412
 
413
#ifndef UNUSED
414
#  define UNUSED(x) ((void)x)
415
#endif
416
 
417
#if BX_SUPPORT_X86_64
418
#define FMT_ADDRX FMT_ADDRX64
419
#else
420
#define FMT_ADDRX FMT_ADDRX32
421
#endif
422
 
423
#if BX_PHY_ADDRESS_LONG
424
  #define FMT_PHY_ADDRX FMT_ADDRX64
425
#else
426
  #define FMT_PHY_ADDRX FMT_ADDRX32
427
#endif
428
 
429
#define FMT_LIN_ADDRX FMT_ADDRX
430
 
431
#if BX_GDBSTUB
432
// defines for GDB stub
433
void bx_gdbstub_init(void);
434
void bx_gdbstub_break(void);
435
int bx_gdbstub_check(unsigned int eip);
436
#define GDBSTUB_STOP_NO_REASON   (0xac0)
437
 
438
#if BX_SUPPORT_SMP
439
#error GDB stub was written for single processor support.  If multiprocessor support is added, then we can remove this check.
440
// The big problem is knowing which CPU gdb is referring to.  In other words,
441
// what should we put for "n" in BX_CPU(n)->dbg_xlate_linear2phy() and
442
// BX_CPU(n)->dword.eip, etc.
443
#endif
444
#endif
445
 
446
typedef struct {
447
  bx_bool floppy;
448
  bx_bool keyboard;
449
  bx_bool video;
450
  bx_bool disk;
451
  bx_bool pit;
452
  bx_bool pic;
453
  bx_bool bios;
454
  bx_bool cmos;
455
  bx_bool a20;
456
  bx_bool interrupts;
457
  bx_bool exceptions;
458
  bx_bool debugger;
459
  bx_bool mouse;
460
  bx_bool io;
461
  bx_bool dma;
462
  bx_bool unsupported_io;
463
  bx_bool serial;
464
  bx_bool cdrom;
465
  bx_bool print_timestamps;
466
#if BX_DEBUGGER
467
  bx_bool magic_break_enabled;
468
#endif
469
#if BX_GDBSTUB
470
  bx_bool gdbstub_enabled;
471
#endif
472
#if BX_SUPPORT_APIC
473
  bx_bool apic;
474
  bx_bool ioapic;
475
#endif
476
#if BX_DEBUG_LINUX
477
  bx_bool linux_syscall;
478
#endif
479
  void* record_io;
480
} bx_debug_t;
481
 
482
void CDECL bx_signal_handler(int signum);
483
int bx_atexit(void);
484
BOCHSAPI extern bx_debug_t bx_dbg;
485
 
486
// memory access type (read/write/rw)
487
#define BX_READ         0
488
#define BX_WRITE        1
489
#define BX_RW           2
490
 
491
#define DATA_ACCESS     0
492
#define CODE_ACCESS     1
493
 
494
#include "memory/memory.h"
495
#include "pc_system.h"
496
#include "plugin.h"
497
#include "gui/gui.h"
498
#include "gui/textconfig.h"
499
#include "gui/keymap.h"
500
 
501
/* --- EXTERNS --- */
502
 
503
#if BX_GUI_SIGHANDLER
504
extern bx_bool bx_gui_sighandler;
505
#endif
506
 
507
// This value controls how often each I/O device's periodic() method
508
// gets called.  The timer is set up in iodev/devices.cc.
509
#define BX_IODEV_HANDLER_PERIOD 100    // microseconds
510
//#define BX_IODEV_HANDLER_PERIOD 10    // microseconds
511
 
512
#define BX_PATHNAME_LEN 512
513
 
514
#define BX_KBD_XT_TYPE        0
515
#define BX_KBD_AT_TYPE        1
516
#define BX_KBD_MF_TYPE        2
517
 
518
#define BX_N_OPTROM_IMAGES 4
519
#define BX_N_OPTRAM_IMAGES 4
520
#define BX_N_SERIAL_PORTS 4
521
#define BX_N_PARALLEL_PORTS 2
522
#define BX_N_USB_HUBS 1
523
#define BX_N_PCI_SLOTS 5
524
 
525
#if BX_SUPPORT_SMP
526
  #define BX_SMP_PROCESSORS (bx_cpu_count)
527
#else
528
  #define BX_SMP_PROCESSORS 1
529
#endif
530
 
531
void bx_center_print(FILE *file, const char *line, unsigned maxwidth);
532
 
533
#include "instrument.h"
534
 
535
// These are some convenience macros which abstract out accesses between
536
// a variable in native byte ordering to/from guest (x86) memory, which is
537
// always in little endian format.  You must deal with alignment (if your
538
// system cares) and endian rearranging.  Don't assume anything.  You could
539
// put some platform specific asm() statements here, to make use of native
540
// instructions to help perform these operations more efficiently than C++.
541
 
542
 
543
#ifdef BX_LITTLE_ENDIAN
544
 
545
#define WriteHostWordToLittleEndian(hostPtr,  nativeVar16) \
546
    *((Bit16u*)(hostPtr)) = (nativeVar16)
547
#define WriteHostDWordToLittleEndian(hostPtr, nativeVar32) \
548
    *((Bit32u*)(hostPtr)) = (nativeVar32)
549
#define WriteHostQWordToLittleEndian(hostPtr, nativeVar64) \
550
    *((Bit64u*)(hostPtr)) = (nativeVar64)
551
 
552
#define ReadHostWordFromLittleEndian(hostPtr,  nativeVar16) \
553
    (nativeVar16) = *((Bit16u*)(hostPtr))
554
#define ReadHostDWordFromLittleEndian(hostPtr, nativeVar32) \
555
    (nativeVar32) = *((Bit32u*)(hostPtr))
556
#define ReadHostQWordFromLittleEndian(hostPtr, nativeVar64) \
557
    (nativeVar64) = *((Bit64u*)(hostPtr))
558
 
559
#define CopyHostWordLittleEndian(hostAddrDst,  hostAddrSrc)  \
560
    (* (Bit16u *)(hostAddrDst)) = (* (Bit16u *)(hostAddrSrc));
561
#define CopyHostDWordLittleEndian(hostAddrDst,  hostAddrSrc) \
562
    (* (Bit32u *)(hostAddrDst)) = (* (Bit32u *)(hostAddrSrc));
563
#define CopyHostQWordLittleEndian(hostAddrDst,  hostAddrSrc) \
564
    (* (Bit64u *)(hostAddrDst)) = (* (Bit64u *)(hostAddrSrc));
565
 
566
#else
567
 
568
#define WriteHostWordToLittleEndian(hostPtr,  nativeVar16) { \
569
    ((Bit8u *)(hostPtr))[0] = (Bit8u)  (nativeVar16);        \
570
    ((Bit8u *)(hostPtr))[1] = (Bit8u) ((nativeVar16)>>8);    \
571
}
572
#define WriteHostDWordToLittleEndian(hostPtr, nativeVar32) { \
573
    ((Bit8u *)(hostPtr))[0] = (Bit8u)  (nativeVar32);        \
574
    ((Bit8u *)(hostPtr))[1] = (Bit8u) ((nativeVar32)>>8);    \
575
    ((Bit8u *)(hostPtr))[2] = (Bit8u) ((nativeVar32)>>16);   \
576
    ((Bit8u *)(hostPtr))[3] = (Bit8u) ((nativeVar32)>>24);   \
577
}
578
#define WriteHostQWordToLittleEndian(hostPtr, nativeVar64) { \
579
    ((Bit8u *)(hostPtr))[0] = (Bit8u)  (nativeVar64);        \
580
    ((Bit8u *)(hostPtr))[1] = (Bit8u) ((nativeVar64)>>8);    \
581
    ((Bit8u *)(hostPtr))[2] = (Bit8u) ((nativeVar64)>>16);   \
582
    ((Bit8u *)(hostPtr))[3] = (Bit8u) ((nativeVar64)>>24);   \
583
    ((Bit8u *)(hostPtr))[4] = (Bit8u) ((nativeVar64)>>32);   \
584
    ((Bit8u *)(hostPtr))[5] = (Bit8u) ((nativeVar64)>>40);   \
585
    ((Bit8u *)(hostPtr))[6] = (Bit8u) ((nativeVar64)>>48);   \
586
    ((Bit8u *)(hostPtr))[7] = (Bit8u) ((nativeVar64)>>56);   \
587
}
588
 
589
#define ReadHostWordFromLittleEndian(hostPtr, nativeVar16) {   \
590
    (nativeVar16) =  ((Bit16u) ((Bit8u *)(hostPtr))[0]) |      \
591
                    (((Bit16u) ((Bit8u *)(hostPtr))[1])<<8) ;  \
592
}
593
#define ReadHostDWordFromLittleEndian(hostPtr, nativeVar32) {  \
594
    (nativeVar32) =  ((Bit32u) ((Bit8u *)(hostPtr))[0]) |      \
595
                    (((Bit32u) ((Bit8u *)(hostPtr))[1])<<8) |  \
596
                    (((Bit32u) ((Bit8u *)(hostPtr))[2])<<16) | \
597
                    (((Bit32u) ((Bit8u *)(hostPtr))[3])<<24);  \
598
}
599
#define ReadHostQWordFromLittleEndian(hostPtr, nativeVar64) {  \
600
    (nativeVar64) =  ((Bit64u) ((Bit8u *)(hostPtr))[0]) |      \
601
                    (((Bit64u) ((Bit8u *)(hostPtr))[1])<<8) |  \
602
                    (((Bit64u) ((Bit8u *)(hostPtr))[2])<<16) | \
603
                    (((Bit64u) ((Bit8u *)(hostPtr))[3])<<24) | \
604
                    (((Bit64u) ((Bit8u *)(hostPtr))[4])<<32) | \
605
                    (((Bit64u) ((Bit8u *)(hostPtr))[5])<<40) | \
606
                    (((Bit64u) ((Bit8u *)(hostPtr))[6])<<48) | \
607
                    (((Bit64u) ((Bit8u *)(hostPtr))[7])<<56);  \
608
}
609
 
610
#define CopyHostWordLittleEndian(hostAddrDst, hostAddrSrc) {   \
611
    ((Bit8u *)(hostAddrDst))[0] = ((Bit8u *)(hostAddrSrc))[0]; \
612
    ((Bit8u *)(hostAddrDst))[1] = ((Bit8u *)(hostAddrSrc))[1]; \
613
}
614
#define CopyHostDWordLittleEndian(hostAddrDst, hostAddrSrc) {  \
615
    ((Bit8u *)(hostAddrDst))[0] = ((Bit8u *)(hostAddrSrc))[0]; \
616
    ((Bit8u *)(hostAddrDst))[1] = ((Bit8u *)(hostAddrSrc))[1]; \
617
    ((Bit8u *)(hostAddrDst))[2] = ((Bit8u *)(hostAddrSrc))[2]; \
618
    ((Bit8u *)(hostAddrDst))[3] = ((Bit8u *)(hostAddrSrc))[3]; \
619
}
620
#define CopyHostQWordLittleEndian(hostAddrDst, hostAddrSrc) {  \
621
    ((Bit8u *)(hostAddrDst))[0] = ((Bit8u *)(hostAddrSrc))[0]; \
622
    ((Bit8u *)(hostAddrDst))[1] = ((Bit8u *)(hostAddrSrc))[1]; \
623
    ((Bit8u *)(hostAddrDst))[2] = ((Bit8u *)(hostAddrSrc))[2]; \
624
    ((Bit8u *)(hostAddrDst))[3] = ((Bit8u *)(hostAddrSrc))[3]; \
625
    ((Bit8u *)(hostAddrDst))[4] = ((Bit8u *)(hostAddrSrc))[4]; \
626
    ((Bit8u *)(hostAddrDst))[5] = ((Bit8u *)(hostAddrSrc))[5]; \
627
    ((Bit8u *)(hostAddrDst))[6] = ((Bit8u *)(hostAddrSrc))[6]; \
628
    ((Bit8u *)(hostAddrDst))[7] = ((Bit8u *)(hostAddrSrc))[7]; \
629
}
630
 
631
#endif
632
 
633
#endif  /* BX_BOCHS_H */

powered by: WebSVN 2.1.0

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