--- uae/src/include/memory.h	2018/04/24 16:42:26	1.1.1.4
+++ uae/src/include/memory.h	2018/04/24 17:18:48	1.1.1.13
@@ -6,14 +6,8 @@
   * Copyright 1995 Bernd Schmidt
   */
 
-/* Enabling this adds one additional native memory reference per 68k memory
- * access, but saves one shift (on the x86). Enabling this is probably
- * better for the cache. My favourite benchmark (PP2) doesn't show a
- * difference, so I leave this enabled. */
-
-#if 1 || defined SAVE_MEMORY
-#define SAVE_MEMORY_BANKS
-#endif
+extern void memory_reset (void);
+extern void a1000_reset (void);
 
 typedef uae_u32 (*mem_get_func)(uaecptr) REGPARAM;
 typedef void (*mem_put_func)(uaecptr, uae_u32) REGPARAM;
@@ -49,6 +43,11 @@ extern uae_u32 allocated_a3000mem;
 #define kickmem_start 0x00F80000
 
 extern int ersatzkickfile;
+extern int cloanto_rom;
+extern uae_u16 kickstart_version;
+extern int uae_boot_rom, uae_boot_rom_size;
+
+extern uae_u8* baseaddr[];
 
 typedef struct {
     /* These ones should be self-explanatory... */
@@ -64,9 +63,16 @@ typedef struct {
      * that the pointer points to an area of at least the specified size.
      * This is used for example to translate bitplane pointers in custom.c */
     check_func check;
+    /* For those banks that refer to real memory, we can save the whole trouble
+       of going through function calls, and instead simply grab the memory
+       ourselves. This holds the memory address where the start of memory is
+       for this particular bank. */
+    uae_u8 *baseaddr;
+    const char *name;
 } addrbank;
 
-extern uae_u8 filesysory[65536];
+extern uae_u8 *filesysory;
+extern uae_u8 *rtarea;
 
 extern addrbank chipmem_bank;
 extern addrbank kickmem_bank;
@@ -77,6 +83,10 @@ extern addrbank rtarea_bank;
 extern addrbank expamem_bank;
 extern addrbank fastmem_bank;
 extern addrbank gfxmem_bank;
+extern addrbank gayle_bank;
+extern addrbank gayle2_bank;
+extern addrbank gayle_attr_bank;
+extern addrbank mbres_bank;
 
 extern void rtarea_init (void);
 extern void rtarea_setup (void);
@@ -95,18 +105,21 @@ extern uae_u8 *default_xlate(uaecptr add
 
 #define bankindex(addr) (((uaecptr)(addr)) >> 16)
 
-#ifdef SAVE_MEMORY_BANKS
 extern addrbank *mem_banks[65536];
+extern uae_u8 *baseaddr[65536];
 #define get_mem_bank(addr) (*mem_banks[bankindex(addr)])
-#define put_mem_bank(addr, b) (mem_banks[bankindex(addr)] = (b))
-#else
-extern addrbank mem_banks[65536];
-#define get_mem_bank(addr) (mem_banks[bankindex(addr)])
-#define put_mem_bank(addr, b) (mem_banks[bankindex(addr)] = *(b))
-#endif
-
-extern void memory_init(void);
-extern void map_banks(addrbank *bank, int first, int count);
+#define put_mem_bank(addr, b, realstart) do { \
+    (mem_banks[bankindex(addr)] = (b)); \
+    if ((b)->baseaddr) \
+	baseaddr[bankindex(addr)] = (b)->baseaddr - (realstart); \
+    else \
+	baseaddr[bankindex(addr)] = (uae_u8*)(((long)b)+1); \
+} while (0)
+
+extern void memory_init (void);
+extern void memory_cleanup (void);
+extern void map_banks (addrbank *bank, int first, int count, int realsize);
+extern void map_overlay (int chip);
 
 #ifndef NO_INLINE_MEMORY_ACCESS
 
@@ -141,37 +154,135 @@ extern void byteput(uaecptr addr, uae_u3
 
 #endif
 
-static __inline__ uae_u32 get_long(uaecptr addr)
+STATIC_INLINE uae_u32 get_long (uaecptr addr)
 {
     return longget_1(addr);
 }
-static __inline__ uae_u32 get_word(uaecptr addr)
+STATIC_INLINE uae_u32 get_word (uaecptr addr)
 {
     return wordget_1(addr);
 }
-static __inline__ uae_u32 get_byte(uaecptr addr)
+STATIC_INLINE uae_u32 get_byte (uaecptr addr)
 {
     return byteget_1(addr);
 }
-static __inline__ void put_long(uaecptr addr, uae_u32 l)
+
+/*
+ * Read a host pointer from addr
+ */
+#if SIZEOF_VOID_P == 4
+# define get_pointer(addr) ((void *)get_long (addr))
+#else
+# if SIZEOF_VOID_P == 8
+STATIC_INLINE void *get_pointer (uaecptr addr)
+{
+    const unsigned int n = SIZEOF_VOID_P / 4;
+    union {
+	void *ptr;
+	uae_u32  longs[SIZEOF_VOID_P / 4];
+    } p;
+    unsigned int i;
+
+    for (i = 0; i < n; i++) {
+#ifdef WORDS_BIGENDIAN
+	p.longs[i] = get_long (addr + i * 4);
+#else
+	p.longs[n - 1 - i] = get_long (addr + i * 4);
+#endif
+    }
+    return p.ptr;
+}
+# else
+#  error "Unknown or unsupported pointer size."
+# endif
+#endif
+
+STATIC_INLINE void put_long (uaecptr addr, uae_u32 l)
 {
     longput_1(addr, l);
 }
-static __inline__ void put_word(uaecptr addr, uae_u32 w)
+STATIC_INLINE void put_word (uaecptr addr, uae_u32 w)
 {
     wordput_1(addr, w);
 }
-static __inline__ void put_byte(uaecptr addr, uae_u32 b)
+STATIC_INLINE void put_byte (uaecptr addr, uae_u32 b)
 {
     byteput_1(addr, b);
 }
 
-static __inline__ uae_u8 *get_real_address(uaecptr addr)
+/*
+ * Store host pointer v at addr
+ */
+#if SIZEOF_VOID_P == 4
+# define put_pointer(addr, p) (put_long ((addr), (uae_u32)(p)))
+#else
+# if SIZEOF_VOID_P == 8
+STATIC_INLINE void put_pointer (uaecptr addr, void *v)
+{
+    const unsigned int n = SIZEOF_VOID_P / 4;
+    union {
+	void *ptr;
+	uae_u32 longs[SIZEOF_VOID_P / 4];
+    } p;
+    unsigned int i;
+
+    p.ptr = v;
+
+    for (i = 0; i < n; i++) {
+#ifdef WORDS_BIGENDIAN
+	put_long (addr + i * 4, p.longs[i]);
+#else
+	put_long (addr + i * 4, p.longs[n - 1 - i]);
+#endif
+    }
+}
+# endif
+#endif
+
+STATIC_INLINE uae_u8 *get_real_address (uaecptr addr)
 {
     return get_mem_bank(addr).xlateaddr(addr);
 }
 
-static __inline__ int valid_address(uaecptr addr, uae_u32 size)
+STATIC_INLINE int valid_address(uaecptr addr, uae_u32 size)
 {
     return get_mem_bank(addr).check(addr, size);
 }
+
+/* For faster access in custom chip emulation.  */
+extern uae_u32 chipmem_lget (uaecptr) REGPARAM;
+extern uae_u32 chipmem_wget (uaecptr) REGPARAM;
+extern uae_u32 chipmem_bget (uaecptr) REGPARAM;
+extern void chipmem_lput (uaecptr, uae_u32) REGPARAM;
+extern void chipmem_wput (uaecptr, uae_u32) REGPARAM;
+extern void chipmem_bput (uaecptr, uae_u32) REGPARAM;
+
+extern uae_u32 chipmem_agnus_wget (uaecptr) REGPARAM;
+extern void chipmem_agnus_wput (uaecptr, uae_u32) REGPARAM;
+
+#ifdef NATMEM_OFFSET
+
+typedef struct shmpiece_reg {
+    uae_u8 *native_address;
+    int id;
+    uae_u32 size;
+    struct shmpiece_reg *next;
+    struct shmpiece_reg *prev;
+} shmpiece;
+
+extern shmpiece *shm_start;
+extern int canbang;
+
+#endif
+
+extern uae_u8 *mapped_malloc (size_t, char *);
+extern void mapped_free (uae_u8 *);
+extern void memory_hardreset (void);
+
+uaecptr strcpyha_safe (uaecptr dst, const char *src);
+uaecptr strncpyha_safe (uaecptr dst, const char *src, int size);
+extern char *strcpyah_safe (char *dst, uaecptr src);
+extern void memcpyha_safe (uaecptr dst, const uae_u8 *src, int size);
+extern void memcpyha (uaecptr dst, const uae_u8 *src, int size);
+extern void memcpyah_safe (uae_u8 *dst, uaecptr src, int size);
+extern void memcpyah (uae_u8 *dst, uaecptr src, int size);