bochs.h

   1 /////////////////////////////////////////////////////////////////////////
   2 // $Id: bochs.h,v 1.232 2008/06/12 21:02:53 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 #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, 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 #if BX_ASSERT_ENABLE
 407   #define BX_ASSERT(x) do {if (!(x)) BX_PANIC(("failed assertion \"%s\" at %s:%d\n", #x, __FILE__, __LINE__));} while (0)
 408 #else
 409   #define BX_ASSERT(x)
 410 #endif
 411
 412 #endif
 413
 414 BOCHSAPI extern iofunc_t *io;
 415 BOCHSAPI extern logfunc_t *genlog;
 416
 417 #ifndef UNUSED
 418 #  define UNUSED(x) ((void)x)
 419 #endif
 420
 421 #if BX_SUPPORT_X86_64
 422 #define FMT_ADDRX FMT_ADDRX64
 423 #else
 424 #define FMT_ADDRX FMT_ADDRX32
 425 #endif
 426
 427 #if BX_PHY_ADDRESS_LONG
 428   #define FMT_PHY_ADDRX FMT_ADDRX64
 429 #else
 430   #define FMT_PHY_ADDRX FMT_ADDRX32
 431 #endif
 432
 433 #define FMT_LIN_ADDRX FMT_ADDRX
 434
 435 #if BX_GDBSTUB
 436 // defines for GDB stub
 437 void bx_gdbstub_init(void);
 438 void bx_gdbstub_break(void);
 439 int bx_gdbstub_check(unsigned int eip);
 440 #define GDBSTUB_STOP_NO_REASON   (0xac0)
 441
 442 #if BX_SUPPORT_SMP
 443 #error GDB stub was written for single processor support.  If multiprocessor support is added, then we can remove this check.
 444 // The big problem is knowing which CPU gdb is referring to.  In other words,
 445 // what should we put for "n" in BX_CPU(n)->dbg_xlate_linear2phy() and
 446 // BX_CPU(n)->dword.eip, etc.
 447 #endif
 448 #endif
 449
 450 typedef struct {
 451   bx_bool floppy;
 452   bx_bool keyboard;
 453   bx_bool video;
 454   bx_bool disk;
 455   bx_bool pit;
 456   bx_bool pic;
 457   bx_bool bios;
 458   bx_bool cmos;
 459   bx_bool a20;
 460   bx_bool interrupts;
 461   bx_bool exceptions;
 462   bx_bool debugger;
 463   bx_bool mouse;
 464   bx_bool io;
 465   bx_bool dma;
 466   bx_bool unsupported_io;
 467   bx_bool serial;
 468   bx_bool cdrom;
 469   bx_bool print_timestamps;
 470 #if BX_DEBUGGER
 471   bx_bool magic_break_enabled;
 472 #endif
 473 #if BX_GDBSTUB
 474   bx_bool gdbstub_enabled;
 475 #endif
 476 #if BX_SUPPORT_APIC
 477   bx_bool apic;
 478   bx_bool ioapic;
 479 #endif
 480 #if BX_DEBUG_LINUX
 481   bx_bool linux_syscall;
 482 #endif
 483   void* record_io;
 484 } bx_debug_t;
 485
 486 void CDECL bx_signal_handler(int signum);
 487 int bx_atexit(void);
 488 BOCHSAPI extern bx_debug_t bx_dbg;
 489
 490 // memory access type (read/write/rw)
 491 #define BX_READ         0
 492 #define BX_WRITE        1
 493 #define BX_RW           2
 494
 495 #define DATA_ACCESS     0
 496 #define CODE_ACCESS     1
 497
 498 #include "memory/memory.h"
 499 #include "pc_system.h"
 500 #include "plugin.h"
 501 #include "gui/gui.h"
 502 #include "gui/textconfig.h"
 503 #include "gui/keymap.h"
 504
 505 /* --- EXTERNS --- */
 506
 507 #if BX_GUI_SIGHANDLER
 508 extern bx_bool bx_gui_sighandler;
 509 #endif
 510
 511 // This value controls how often each I/O device's periodic() method
 512 // gets called.  The timer is set up in iodev/devices.cc.
 513 #define BX_IODEV_HANDLER_PERIOD 100    // microseconds
 514 //#define BX_IODEV_HANDLER_PERIOD 10    // microseconds
 515
 516 #define BX_PATHNAME_LEN 512
 517
 518 #define BX_KBD_XT_TYPE        0
 519 #define BX_KBD_AT_TYPE        1
 520 #define BX_KBD_MF_TYPE        2
 521
 522 #define BX_N_OPTROM_IMAGES 4
 523 #define BX_N_OPTRAM_IMAGES 4
 524 #define BX_N_SERIAL_PORTS 4
 525 #define BX_N_PARALLEL_PORTS 2
 526 #define BX_N_USB_HUBS 1
 527 #define BX_N_PCI_SLOTS 5
 528
 529 #if BX_SUPPORT_SMP
 530   #define BX_SMP_PROCESSORS (bx_cpu_count)
 531 #else
 532   #define BX_SMP_PROCESSORS 1
 533 #endif
 534
 535 void bx_center_print(FILE *file, const char *line, unsigned maxwidth);
 536
 537 #include "instrument.h"
 538
 539 // These are some convenience macros which abstract out accesses between
 540 // a variable in native byte ordering to/from guest (x86) memory, which is
 541 // always in little endian format.  You must deal with alignment (if your
 542 // system cares) and endian rearranging.  Don't assume anything.  You could
 543 // put some platform specific asm() statements here, to make use of native
 544 // instructions to help perform these operations more efficiently than C++.
 545
 546
 547 #ifdef BX_LITTLE_ENDIAN
 548
 549 #define WriteHostWordToLittleEndian(hostPtr,  nativeVar16) \
 550     *((Bit16u*)(hostPtr)) = (nativeVar16)
 551 #define WriteHostDWordToLittleEndian(hostPtr, nativeVar32) \
 552     *((Bit32u*)(hostPtr)) = (nativeVar32)
 553 #define WriteHostQWordToLittleEndian(hostPtr, nativeVar64) \
 554     *((Bit64u*)(hostPtr)) = (nativeVar64)
 555
 556 #define ReadHostWordFromLittleEndian(hostPtr,  nativeVar16) \
 557     (nativeVar16) = *((Bit16u*)(hostPtr))
 558 #define ReadHostDWordFromLittleEndian(hostPtr, nativeVar32) \
 559     (nativeVar32) = *((Bit32u*)(hostPtr))
 560 #define ReadHostQWordFromLittleEndian(hostPtr, nativeVar64) \
 561     (nativeVar64) = *((Bit64u*)(hostPtr))
 562
 563 #define CopyHostWordLittleEndian(hostAddrDst,  hostAddrSrc)  \
 564     (* (Bit16u *)(hostAddrDst)) = (* (Bit16u *)(hostAddrSrc));
 565 #define CopyHostDWordLittleEndian(hostAddrDst,  hostAddrSrc) \
 566     (* (Bit32u *)(hostAddrDst)) = (* (Bit32u *)(hostAddrSrc));
 567 #define CopyHostQWordLittleEndian(hostAddrDst,  hostAddrSrc) \
 568     (* (Bit64u *)(hostAddrDst)) = (* (Bit64u *)(hostAddrSrc));
 569
 570 #else
 571
 572 #define WriteHostWordToLittleEndian(hostPtr,  nativeVar16) { \
 573     ((Bit8u *)(hostPtr))[0] = (Bit8u)  (nativeVar16);        \
 574     ((Bit8u *)(hostPtr))[1] = (Bit8u) ((nativeVar16)>>8);    \
 575 }
 576 #define WriteHostDWordToLittleEndian(hostPtr, nativeVar32) { \
 577     ((Bit8u *)(hostPtr))[0] = (Bit8u)  (nativeVar32);        \
 578     ((Bit8u *)(hostPtr))[1] = (Bit8u) ((nativeVar32)>>8);    \
 579     ((Bit8u *)(hostPtr))[2] = (Bit8u) ((nativeVar32)>>16);   \
 580     ((Bit8u *)(hostPtr))[3] = (Bit8u) ((nativeVar32)>>24);   \
 581 }
 582 #define WriteHostQWordToLittleEndian(hostPtr, nativeVar64) { \
 583     ((Bit8u *)(hostPtr))[0] = (Bit8u)  (nativeVar64);        \
 584     ((Bit8u *)(hostPtr))[1] = (Bit8u) ((nativeVar64)>>8);    \
 585     ((Bit8u *)(hostPtr))[2] = (Bit8u) ((nativeVar64)>>16);   \
 586     ((Bit8u *)(hostPtr))[3] = (Bit8u) ((nativeVar64)>>24);   \
 587     ((Bit8u *)(hostPtr))[4] = (Bit8u) ((nativeVar64)>>32);   \
 588     ((Bit8u *)(hostPtr))[5] = (Bit8u) ((nativeVar64)>>40);   \
 589     ((Bit8u *)(hostPtr))[6] = (Bit8u) ((nativeVar64)>>48);   \
 590     ((Bit8u *)(hostPtr))[7] = (Bit8u) ((nativeVar64)>>56);   \
 591 }
 592
 593 #define ReadHostWordFromLittleEndian(hostPtr, nativeVar16) {   \
 594     (nativeVar16) =  ((Bit16u) ((Bit8u *)(hostPtr))[0]) |      \
 595                     (((Bit16u) ((Bit8u *)(hostPtr))[1])<<8) ;  \
 596 }
 597 #define ReadHostDWordFromLittleEndian(hostPtr, nativeVar32) {  \
 598     (nativeVar32) =  ((Bit32u) ((Bit8u *)(hostPtr))[0]) |      \
 599                     (((Bit32u) ((Bit8u *)(hostPtr))[1])<<8) |  \
 600                     (((Bit32u) ((Bit8u *)(hostPtr))[2])<<16) | \
 601                     (((Bit32u) ((Bit8u *)(hostPtr))[3])<<24);  \
 602 }
 603 #define ReadHostQWordFromLittleEndian(hostPtr, nativeVar64) {  \
 604     (nativeVar64) =  ((Bit64u) ((Bit8u *)(hostPtr))[0]) |      \
 605                     (((Bit64u) ((Bit8u *)(hostPtr))[1])<<8) |  \
 606                     (((Bit64u) ((Bit8u *)(hostPtr))[2])<<16) | \
 607                     (((Bit64u) ((Bit8u *)(hostPtr))[3])<<24) | \
 608                     (((Bit64u) ((Bit8u *)(hostPtr))[4])<<32) | \
 609                     (((Bit64u) ((Bit8u *)(hostPtr))[5])<<40) | \
 610                     (((Bit64u) ((Bit8u *)(hostPtr))[6])<<48) | \
 611                     (((Bit64u) ((Bit8u *)(hostPtr))[7])<<56);  \
 612 }
 613
 614 #define CopyHostWordLittleEndian(hostAddrDst, hostAddrSrc) {   \
 615     ((Bit8u *)(hostAddrDst))[0] = ((Bit8u *)(hostAddrSrc))[0]; \
 616     ((Bit8u *)(hostAddrDst))[1] = ((Bit8u *)(hostAddrSrc))[1]; \
 617 }
 618 #define CopyHostDWordLittleEndian(hostAddrDst, hostAddrSrc) {  \
 619     ((Bit8u *)(hostAddrDst))[0] = ((Bit8u *)(hostAddrSrc))[0]; \
 620     ((Bit8u *)(hostAddrDst))[1] = ((Bit8u *)(hostAddrSrc))[1]; \
 621     ((Bit8u *)(hostAddrDst))[2] = ((Bit8u *)(hostAddrSrc))[2]; \
 622     ((Bit8u *)(hostAddrDst))[3] = ((Bit8u *)(hostAddrSrc))[3]; \
 623 }
 624 #define CopyHostQWordLittleEndian(hostAddrDst, hostAddrSrc) {  \
 625     ((Bit8u *)(hostAddrDst))[0] = ((Bit8u *)(hostAddrSrc))[0]; \
 626     ((Bit8u *)(hostAddrDst))[1] = ((Bit8u *)(hostAddrSrc))[1]; \
 627     ((Bit8u *)(hostAddrDst))[2] = ((Bit8u *)(hostAddrSrc))[2]; \
 628     ((Bit8u *)(hostAddrDst))[3] = ((Bit8u *)(hostAddrSrc))[3]; \
 629     ((Bit8u *)(hostAddrDst))[4] = ((Bit8u *)(hostAddrSrc))[4]; \
 630     ((Bit8u *)(hostAddrDst))[5] = ((Bit8u *)(hostAddrSrc))[5]; \
 631     ((Bit8u *)(hostAddrDst))[6] = ((Bit8u *)(hostAddrSrc))[6]; \
 632     ((Bit8u *)(hostAddrDst))[7] = ((Bit8u *)(hostAddrSrc))[7]; \
 633 }
 634
 635 #endif
 636
 637 #endif  /* BX_BOCHS_H */