bochs.h

   1 /////////////////////////////////////////////////////////////////////////
   2 // $Id: bochs.h,v 1.236 2008/12/05 22:34:42 sshwarts Exp $
   3 /////////////////////////////////////////////////////////////////////////
   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   void ask (int level, const char *prefix, const char *fmt, va_list ap);
 289   void put(const char *);
 290   void settype(int);
 291   void setio(class iofunctions *);
 292   void setonoff(int loglev, int value) {
 293     assert (loglev >= 0 && loglev < N_LOGLEV);
 294     onoff[loglev] = value;
 295   }
 296   char *getprefix () { return prefix; }
 297   int getonoff(int level) {
 298     assert (level>=0 && level<N_LOGLEV);
 299     return onoff[level];
 300   }
 301   static void set_default_action (int loglev, int action) {
 302     assert (loglev >= 0 && loglev < N_LOGLEV);
 303     assert (action >= 0 && action < N_ACT);
 304     default_onoff[loglev] = action;
 305   }
 306   static int get_default_action (int loglev) {
 307     assert (loglev >= 0 && loglev < N_LOGLEV);
 308     return default_onoff[loglev];
 309   }
 310 } logfunc_t;
 311
 312 #define BX_LOGPREFIX_SIZE 51
 313
 314 enum {
 315   IOLOG=0, FDLOG, GENLOG, CMOSLOG, CDLOG, DMALOG, ETHLOG, G2HLOG, HDLOG, KBDLOG,
 316   NE2KLOG, PARLOG, PCILOG, PICLOG, PITLOG, SB16LOG, SERLOG, VGALOG,
 317   DEVLOG, MEMLOG, DISLOG, GUILOG, IOAPICLOG, APICLOG, CPU0LOG, CPU1LOG,
 318   CPU2LOG, CPU3LOG, CPU4LOG, CPU5LOG, CPU6LOG, CPU7LOG, CPU8LOG, CPU9LOG,
 319   CPU10LOG, CPU11LOG, CPU12LOG, CPU13LOG, CPU14LOG, CPU15LOG, CTRLLOG,
 320   UNMAPLOG, SERRLOG, BIOSLOG, PIT81LOG, PIT82LOG, IODEBUGLOG, PCI2ISALOG,
 321   PLUGINLOG, EXTFPUIRQLOG , PCIVGALOG, PCIUSBLOG, VTIMERLOG, STIMERLOG,
 322   PCIIDELOG, PCIDEVLOG, PCIPNICLOG, SPEAKERLOG, BUSMLOG, GAMELOG, ACPILOG
 323 };
 324
 325 class BOCHSAPI iofunctions {
 326   int magic;
 327   char logprefix[BX_LOGPREFIX_SIZE];
 328   FILE *logfd;
 329   class logfunctions *log;
 330   void init(void);
 331   void flush(void);
 332
 333 // Log Class types
 334 public:
 335   iofunctions(void);
 336   iofunctions(FILE *);
 337   iofunctions(int);
 338   iofunctions(const char *);
 339  ~iofunctions(void);
 340
 341   void out(int facility, int level, const char *pre, const char *fmt, va_list ap);
 342
 343   void init_log(const char *fn);
 344   void init_log(int fd);
 345   void init_log(FILE *fs);
 346   void exit_log();
 347   void set_log_prefix(const char *prefix);
 348   int get_n_logfns() { return n_logfn; }
 349   logfunc_t *get_logfn(int index) { return logfn_list[index]; }
 350   void add_logfn(logfunc_t *fn);
 351   void remove_logfn(logfunc_t *fn);
 352   void set_log_action(int loglevel, int action);
 353   const char *getlevel(int i) {
 354     static const char *loglevel[N_LOGLEV] = {
 355       "DEBUG",
 356       "INFO",
 357       "ERROR",
 358       "PANIC",
 359       "PASS"
 360     };
 361     if (i>=0 && i<N_LOGLEV) return loglevel[i];
 362     else return "?";
 363   }
 364   char *getaction(int i) {
 365     static const char *name[] = { "ignore", "report", "ask", "fatal" };
 366     assert (i>=ACT_IGNORE && i<N_ACT);
 367     return (char *) name[i];
 368   }
 369
 370 protected:
 371   int n_logfn;
 372 #define MAX_LOGFNS 128
 373   logfunc_t *logfn_list[MAX_LOGFNS];
 374   const char *logfn;
 375 };
 376
 377 typedef class BOCHSAPI iofunctions iofunc_t;
 378
 379 #define SAFE_GET_IOFUNC() \
 380   ((io==NULL)? (io=new iofunc_t("/dev/stderr")) : io)
 381 #define SAFE_GET_GENLOG() \
 382   ((genlog==NULL)? (genlog=new logfunc_t(SAFE_GET_IOFUNC())) : genlog)
 383
 384 #if BX_NO_LOGGING
 385
 386 #define BX_INFO(x)
 387 #define BX_DEBUG(x)
 388 #define BX_ERROR(x)
 389 #define BX_PANIC(x) (LOG_THIS panic) x
 390 #define BX_PASS(x) (LOG_THIS pass) x
 391
 392 #define BX_ASSERT(x)
 393
 394 #else
 395
 396 #define BX_INFO(x)  (LOG_THIS info) x
 397 #define BX_DEBUG(x) (LOG_THIS ldebug) x
 398 #define BX_ERROR(x) (LOG_THIS error) x
 399 #define BX_PANIC(x) (LOG_THIS panic) x
 400 #define BX_PASS(x) (LOG_THIS pass) x
 401
 402 #if BX_ASSERT_ENABLE
 403   #define BX_ASSERT(x) do {if (!(x)) BX_PANIC(("failed assertion \"%s\" at %s:%d\n", #x, __FILE__, __LINE__));} while (0)
 404 #else
 405   #define BX_ASSERT(x)
 406 #endif
 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/execute/rw)
 487 #define BX_READ         0
 488 #define BX_WRITE        1
 489 #define BX_EXECUTE      2
 490 #define BX_RW           3
 491
 492 #include "memory/memory.h"
 493 #include "pc_system.h"
 494 #include "plugin.h"
 495 #include "gui/gui.h"
 496 #include "gui/textconfig.h"
 497 #include "gui/keymap.h"
 498
 499 /* --- EXTERNS --- */
 500
 501 #if BX_GUI_SIGHANDLER
 502 extern bx_bool bx_gui_sighandler;
 503 #endif
 504
 505 // This value controls how often each I/O device's periodic() method
 506 // gets called.  The timer is set up in iodev/devices.cc.
 507 #define BX_IODEV_HANDLER_PERIOD 100    // microseconds
 508 //#define BX_IODEV_HANDLER_PERIOD 10    // microseconds
 509
 510 #define BX_PATHNAME_LEN 512
 511
 512 #define BX_KBD_XT_TYPE        0
 513 #define BX_KBD_AT_TYPE        1
 514 #define BX_KBD_MF_TYPE        2
 515
 516 #define BX_N_OPTROM_IMAGES 4
 517 #define BX_N_OPTRAM_IMAGES 4
 518 #define BX_N_SERIAL_PORTS 4
 519 #define BX_N_PARALLEL_PORTS 2
 520 #define BX_N_USB_HUBS 1
 521 #define BX_N_PCI_SLOTS 5
 522
 523 void bx_center_print(FILE *file, const char *line, unsigned maxwidth);
 524
 525 #include "instrument.h"
 526
 527 // These are some convenience macros which abstract out accesses between
 528 // a variable in native byte ordering to/from guest (x86) memory, which is
 529 // always in little endian format.  You must deal with alignment (if your
 530 // system cares) and endian rearranging.  Don't assume anything.  You could
 531 // put some platform specific asm() statements here, to make use of native
 532 // instructions to help perform these operations more efficiently than C++.
 533
 534
 535 #ifdef BX_LITTLE_ENDIAN
 536
 537 #define WriteHostWordToLittleEndian(hostPtr,  nativeVar16) \
 538     *((Bit16u*)(hostPtr)) = (nativeVar16)
 539 #define WriteHostDWordToLittleEndian(hostPtr, nativeVar32) \
 540     *((Bit32u*)(hostPtr)) = (nativeVar32)
 541 #define WriteHostQWordToLittleEndian(hostPtr, nativeVar64) \
 542     *((Bit64u*)(hostPtr)) = (nativeVar64)
 543
 544 #define ReadHostWordFromLittleEndian(hostPtr,  nativeVar16) \
 545     (nativeVar16) = *((Bit16u*)(hostPtr))
 546 #define ReadHostDWordFromLittleEndian(hostPtr, nativeVar32) \
 547     (nativeVar32) = *((Bit32u*)(hostPtr))
 548 #define ReadHostQWordFromLittleEndian(hostPtr, nativeVar64) \
 549     (nativeVar64) = *((Bit64u*)(hostPtr))
 550
 551 #define CopyHostWordLittleEndian(hostAddrDst,  hostAddrSrc)  \
 552     (* (Bit16u *)(hostAddrDst)) = (* (Bit16u *)(hostAddrSrc));
 553 #define CopyHostDWordLittleEndian(hostAddrDst,  hostAddrSrc) \
 554     (* (Bit32u *)(hostAddrDst)) = (* (Bit32u *)(hostAddrSrc));
 555 #define CopyHostQWordLittleEndian(hostAddrDst,  hostAddrSrc) \
 556     (* (Bit64u *)(hostAddrDst)) = (* (Bit64u *)(hostAddrSrc));
 557
 558 #else
 559
 560 #define WriteHostWordToLittleEndian(hostPtr,  nativeVar16) { \
 561     ((Bit8u *)(hostPtr))[0] = (Bit8u)  (nativeVar16);        \
 562     ((Bit8u *)(hostPtr))[1] = (Bit8u) ((nativeVar16)>>8);    \
 563 }
 564 #define WriteHostDWordToLittleEndian(hostPtr, nativeVar32) { \
 565     ((Bit8u *)(hostPtr))[0] = (Bit8u)  (nativeVar32);        \
 566     ((Bit8u *)(hostPtr))[1] = (Bit8u) ((nativeVar32)>>8);    \
 567     ((Bit8u *)(hostPtr))[2] = (Bit8u) ((nativeVar32)>>16);   \
 568     ((Bit8u *)(hostPtr))[3] = (Bit8u) ((nativeVar32)>>24);   \
 569 }
 570 #define WriteHostQWordToLittleEndian(hostPtr, nativeVar64) { \
 571     ((Bit8u *)(hostPtr))[0] = (Bit8u)  (nativeVar64);        \
 572     ((Bit8u *)(hostPtr))[1] = (Bit8u) ((nativeVar64)>>8);    \
 573     ((Bit8u *)(hostPtr))[2] = (Bit8u) ((nativeVar64)>>16);   \
 574     ((Bit8u *)(hostPtr))[3] = (Bit8u) ((nativeVar64)>>24);   \
 575     ((Bit8u *)(hostPtr))[4] = (Bit8u) ((nativeVar64)>>32);   \
 576     ((Bit8u *)(hostPtr))[5] = (Bit8u) ((nativeVar64)>>40);   \
 577     ((Bit8u *)(hostPtr))[6] = (Bit8u) ((nativeVar64)>>48);   \
 578     ((Bit8u *)(hostPtr))[7] = (Bit8u) ((nativeVar64)>>56);   \
 579 }
 580
 581 #define ReadHostWordFromLittleEndian(hostPtr, nativeVar16) {   \
 582     (nativeVar16) =  ((Bit16u) ((Bit8u *)(hostPtr))[0]) |      \
 583                     (((Bit16u) ((Bit8u *)(hostPtr))[1])<<8) ;  \
 584 }
 585 #define ReadHostDWordFromLittleEndian(hostPtr, nativeVar32) {  \
 586     (nativeVar32) =  ((Bit32u) ((Bit8u *)(hostPtr))[0]) |      \
 587                     (((Bit32u) ((Bit8u *)(hostPtr))[1])<<8) |  \
 588                     (((Bit32u) ((Bit8u *)(hostPtr))[2])<<16) | \
 589                     (((Bit32u) ((Bit8u *)(hostPtr))[3])<<24);  \
 590 }
 591 #define ReadHostQWordFromLittleEndian(hostPtr, nativeVar64) {  \
 592     (nativeVar64) =  ((Bit64u) ((Bit8u *)(hostPtr))[0]) |      \
 593                     (((Bit64u) ((Bit8u *)(hostPtr))[1])<<8) |  \
 594                     (((Bit64u) ((Bit8u *)(hostPtr))[2])<<16) | \
 595                     (((Bit64u) ((Bit8u *)(hostPtr))[3])<<24) | \
 596                     (((Bit64u) ((Bit8u *)(hostPtr))[4])<<32) | \
 597                     (((Bit64u) ((Bit8u *)(hostPtr))[5])<<40) | \
 598                     (((Bit64u) ((Bit8u *)(hostPtr))[6])<<48) | \
 599                     (((Bit64u) ((Bit8u *)(hostPtr))[7])<<56);  \
 600 }
 601
 602 #define CopyHostWordLittleEndian(hostAddrDst, hostAddrSrc) {   \
 603     ((Bit8u *)(hostAddrDst))[0] = ((Bit8u *)(hostAddrSrc))[0]; \
 604     ((Bit8u *)(hostAddrDst))[1] = ((Bit8u *)(hostAddrSrc))[1]; \
 605 }
 606 #define CopyHostDWordLittleEndian(hostAddrDst, hostAddrSrc) {  \
 607     ((Bit8u *)(hostAddrDst))[0] = ((Bit8u *)(hostAddrSrc))[0]; \
 608     ((Bit8u *)(hostAddrDst))[1] = ((Bit8u *)(hostAddrSrc))[1]; \
 609     ((Bit8u *)(hostAddrDst))[2] = ((Bit8u *)(hostAddrSrc))[2]; \
 610     ((Bit8u *)(hostAddrDst))[3] = ((Bit8u *)(hostAddrSrc))[3]; \
 611 }
 612 #define CopyHostQWordLittleEndian(hostAddrDst, hostAddrSrc) {  \
 613     ((Bit8u *)(hostAddrDst))[0] = ((Bit8u *)(hostAddrSrc))[0]; \
 614     ((Bit8u *)(hostAddrDst))[1] = ((Bit8u *)(hostAddrSrc))[1]; \
 615     ((Bit8u *)(hostAddrDst))[2] = ((Bit8u *)(hostAddrSrc))[2]; \
 616     ((Bit8u *)(hostAddrDst))[3] = ((Bit8u *)(hostAddrSrc))[3]; \
 617     ((Bit8u *)(hostAddrDst))[4] = ((Bit8u *)(hostAddrSrc))[4]; \
 618     ((Bit8u *)(hostAddrDst))[5] = ((Bit8u *)(hostAddrSrc))[5]; \
 619     ((Bit8u *)(hostAddrDst))[6] = ((Bit8u *)(hostAddrSrc))[6]; \
 620     ((Bit8u *)(hostAddrDst))[7] = ((Bit8u *)(hostAddrSrc))[7]; \
 621 }
 622
 623 #endif
 624
 625 #endif  /* BX_BOCHS_H */