--- np2/i386c/ia32/cpu_mem.c 2005/03/09 17:12:34 1.20 +++ np2/i386c/ia32/cpu_mem.c 2012/01/08 18:26:10 1.31 @@ -1,5 +1,3 @@ -/* $Id: cpu_mem.c,v 1.20 2005/03/09 17:12:34 yui Exp $ */ - /* * Copyright (c) 2002-2004 NONAKA Kimihiro * All rights reserved. @@ -12,8 +10,6 @@ * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. - * 3. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES @@ -35,273 +31,362 @@ /* * memory access check */ -void -cpu_memoryread_check(descriptor_t *sd, UINT32 offset, UINT length, int e) +static int MEMCALL check_limit_upstairs(descriptor_t *sdp, UINT32 offset, UINT len); +static void MEMCALL cpu_memoryread_check(descriptor_t *sdp, UINT32 offset, UINT len, int e); +static void MEMCALL cpu_memorywrite_check(descriptor_t *sdp, UINT32 offset, UINT len, int e); + +static int MEMCALL +check_limit_upstairs(descriptor_t *sdp, UINT32 offset, UINT len) { - UINT32 uplimit; + UINT32 limit; + UINT32 end; - if (CPU_STAT_PM) { - /* invalid */ - if (!sd->valid) { - VERBOSE(("cpu_memoryread_check: invalid")); - EXCEPTION(GP_EXCEPTION, 0); - } + __ASSERT(sdp != NULL); + __ASSERT(len > 0); - /* not present */ - if (!sd->p) { - VERBOSE(("cpu_memoryread_check: not present")); - EXCEPTION(e, 0); + len--; + end = offset + len; + limit = SEG_IS_32BIT(sdp) ? 0xffffffff : 0x0000ffff; + + if (SEG_IS_DATA(sdp) && SEG_IS_EXPANDDOWN_DATA(sdp)) { + /* expand-down data segment */ + if (sdp->u.seg.limit == 0) { + /* + * 32bit 16bit + * +-------+ +-------+ FFFFFFFFh + * | | | | + * | | + [1] + 0000FFFFh + * | valid | | | + * | | +-------+ 0000FFFFh - len -1 + * | | | valid | + * +-------+ +-------+ 00000000h + */ + if (!SEG_IS_32BIT(sdp)) { + if ((len > limit) /* len check */ + || (end > limit)) { /* [1] */ + goto exc; + } + } else { + sdp->flag |= CPU_DESC_FLAG_WHOLEADR; + } + } else { + /* + * 32bit 16bit + * +-------+ +-------+ FFFFFFFFh + * | [2] | | | + * +-------+ +.......+ FFFFFFFFh - len - 1 + * | | | [2] | + * | | +.......+ 0000FFFFh + * | valid | | | + * | | +-------+ 0000FFFFh - len - 1 + * | | | valid | + * +-------+ +-------+ seg.limit + * | [1] | | [1] | + * +-------+ +-------+ 00000000h + */ + if ((len > limit - sdp->u.seg.limit) /* len check */ + || (end < offset) /* wrap check */ + || (offset < sdp->u.seg.limit) /* [1] */ + || (end > limit)) { /* [2] */ + goto exc; + } + } + } else { + /* expand-up data or code segment */ + if (sdp->u.seg.limit == limit) { + /* + * 32bit 16bit + * +-------+ +-------+ FFFFFFFFh + * | | | | + * | | + [1] + 0000FFFFh + * | valid | | | + * | | +-------+ 0000FFFFh - len - 1 + * | | | valid | + * +-------+ +-------+ 00000000h + */ + if (!SEG_IS_32BIT(sdp)) { + if ((len > limit) /* len check */ + || (offset + len > limit)) { /* [1] */ + goto exc; + } + } else { + sdp->flag |= CPU_DESC_FLAG_WHOLEADR; + } + } else { + /* + * 32bit 16bit + * +-------+ +-------+ FFFFFFFFh + * | | | | + * | | +.......+ 0000FFFFh + * | [1] | | [1] | + * +.......+ +.......+ seg.limit + * | | | | + * +-------+ +-------+ seg.limit - len - 1 + * | valid | | valid | + * +-------+ +-------+ 00000000h + */ + if ((len > sdp->u.seg.limit) /* len check */ + || (end < offset) /* wrap check */ + || (end > sdp->u.seg.limit + 1)) { /* [1] */ + goto exc; + } } } + return 1; /* Ok! */ + +exc: + VERBOSE(("check_limit_upstairs: check failure: offset = 0x%08x, len = %d", offset, len + 1)); +#if defined(DEBUG) + segdesc_dump(sdp); +#endif + return 0; +} + +static void MEMCALL +cpu_memoryread_check(descriptor_t *sdp, UINT32 offset, UINT len, int e) +{ + + __ASSERT(sdp != NULL); + __ASSERT(len > 0); + + if (!SEG_IS_VALID(sdp)) { + e = GP_EXCEPTION; + goto exc; + } + if (!SEG_IS_PRESENT(sdp) + || SEG_IS_SYSTEM(sdp) + || (SEG_IS_CODE(sdp) && !SEG_IS_READABLE_CODE(sdp))) { + goto exc; + } - switch (sd->type) { + switch (sdp->type) { case 0: case 1: /* ro */ case 2: case 3: /* rw */ - case 10: case 11: /* rx */ - case 14: case 15: /* rxc */ - if (offset > sd->u.seg.limit - length + 1) { - VERBOSE(("cpu_memoryread_check: offset(%08x) > sd->u.seg.limit(%08x) - length(%08x) + 1", offset, sd->u.seg.limit, length)); - EXCEPTION(e, 0); - } - if (length - 1 > sd->u.seg.limit) { - VERBOSE(("cpu_memoryread_check: length(%08x) - 1 > sd->u.seg.limit(%08x)", length, sd->u.seg.limit)); - EXCEPTION(e, 0); - } - break; - case 4: case 5: /* ro (expand down) */ case 6: case 7: /* rw (expand down) */ - uplimit = sd->d ? 0xffffffff : 0x0000ffff; - if (offset <= sd->u.seg.limit) { - VERBOSE(("cpu_memoryread_check: offset(%08x) <= sd->u.seg.limit(%08x)", offset, sd->u.seg.limit)); - EXCEPTION(e, 0); - } - if (offset > uplimit) { - VERBOSE(("cpu_memoryread_check: offset(%08x) > uplimit(%08x)", offset, uplimit)); - EXCEPTION(e, 0); - } - if (uplimit - offset < length - 1) { - VERBOSE(("cpu_memoryread_check: uplimit(%08x) - offset(%08x) < length(%08x) - 1", uplimit, offset, length)); - EXCEPTION(e, 0); - } + case 10: case 11: /* rx */ + case 14: case 15: /* rxc */ + if (!check_limit_upstairs(sdp, offset, len)) + goto exc; break; default: - VERBOSE(("cpu_memoryread_check: invalid type (type = %d)", sd->type)); - EXCEPTION(e, 0); - break; + goto exc; } - sd->flag |= CPU_DESC_FLAG_READABLE; + sdp->flag |= CPU_DESC_FLAG_READABLE; + return; + +exc: + VERBOSE(("cpu_memoryread_check: check failure: offset = 0x%08x, len = %d", offset, len)); +#if defined(DEBUG) + segdesc_dump(sdp); +#endif + EXCEPTION(e, 0); } -void -cpu_memorywrite_check(descriptor_t *sd, UINT32 offset, UINT length, int e) +static void MEMCALL +cpu_memorywrite_check(descriptor_t *sdp, UINT32 offset, UINT len, int e) { - UINT32 uplimit; - if (CPU_STAT_PM) { - /* invalid */ - if (!sd->valid) { - VERBOSE(("cpu_memorywrite_check: invalid")); - EXCEPTION(GP_EXCEPTION, 0); - } + __ASSERT(sdp != NULL); + __ASSERT(len > 0); - /* not present */ - if (!sd->p) { - VERBOSE(("cpu_memorywrite_check: not present")); - EXCEPTION(e, 0); - } - - if (!sd->s) { - VERBOSE(("cpu_memorywrite_check: system segment")); - EXCEPTION(e, 0); - } + if (!SEG_IS_VALID(sdp)) { + e = GP_EXCEPTION; + goto exc; + } + if (!SEG_IS_PRESENT(sdp) + || SEG_IS_SYSTEM(sdp) + || SEG_IS_CODE(sdp) + || (SEG_IS_DATA(sdp) && !SEG_IS_WRITABLE_DATA(sdp))) { + goto exc; } - switch (sd->type) { + switch (sdp->type) { case 2: case 3: /* rw */ - if (offset > sd->u.seg.limit - length + 1) { - VERBOSE(("cpu_memorywrite_check: offset(%08x) > sd->u.seg.limit(%08x) - length(%08x) + 1", offset, sd->u.seg.limit, length)); - EXCEPTION(e, 0); - } - if (length - 1 > sd->u.seg.limit) { - VERBOSE(("cpu_memorywrite_check: length(%08x) - 1 > sd->u.seg.limit(%08x)", length, sd->u.seg.limit)); - EXCEPTION(e, 0); - } - break; - case 6: case 7: /* rw (expand down) */ - uplimit = sd->d ? 0xffffffff : 0x0000ffff; - if (offset <= sd->u.seg.limit) { - VERBOSE(("cpu_memorywrite_check: offset(%08x) <= sd->u.seg.limit(%08x)", offset, sd->u.seg.limit)); - EXCEPTION(e, 0); - } - if (offset > uplimit) { - VERBOSE(("cpu_memorywrite_check: offset(%08x) > uplimit(%08x)", offset, uplimit)); - EXCEPTION(e, 0); - } - if (uplimit - offset < length - 1) { - VERBOSE(("cpu_memorywrite_check: uplimit(%08x) - offset(%08x) < length(%08x) - 1", uplimit, offset, length)); - EXCEPTION(e, 0); - } + if (!check_limit_upstairs(sdp, offset, len)) + goto exc; break; default: - VERBOSE(("cpu_memorywrite_check: invalid type (type = %d)", sd->type)); - EXCEPTION(e, 0); - break; + goto exc; } - sd->flag |= CPU_DESC_FLAG_WRITABLE; + sdp->flag |= CPU_DESC_FLAG_WRITABLE | CPU_DESC_FLAG_READABLE; + return; + +exc: + VERBOSE(("cpu_memorywrite_check: check failure: offset = 0x%08x, len = %d", offset, len)); +#if defined(DEBUG) + segdesc_dump(sdp); +#endif + EXCEPTION(e, 0); } -void -cpu_stack_push_check(UINT16 s, descriptor_t *sd, UINT32 esp, UINT length) +void MEMCALL +cpu_stack_push_check(UINT16 s, descriptor_t *sdp, UINT32 sp, UINT len) { UINT32 limit; + UINT32 start; - if (CPU_STAT_PM) { - if (!sd->valid || !sd->p) { - VERBOSE(("cpu_stack_push_check: valid = %d, present = %d", sd->valid, sd->p)); - EXCEPTION(SS_EXCEPTION, s & 0xfffc); - } - if (!sd->s || sd->u.seg.c || !sd->u.seg.wr) { - VERBOSE(("cpu_stack_push_check: s = %d, c = %d, wr", sd->s, sd->u.seg.c, sd->u.seg.wr)); - EXCEPTION(SS_EXCEPTION, s & 0xfffc); - } + __ASSERT(sdp != NULL); + __ASSERT(len > 0); - if (!sd->d) { - limit = 0xffff; - } else { - limit = 0xffffffff; - } - if (sd->u.seg.ec) { - /* expand-down stack */ - if ((esp == 0) - || (esp < length) - || (esp - length <= sd->u.seg.limit) - || (esp > limit)) { - VERBOSE(("cpu_stack_push_check: expand-down, esp = %08x, length = %08x", esp, length)); - VERBOSE(("cpu_stack_push_check: limit = %08x, seglimit = %08x", limit, sd->u.seg.limit)); - VERBOSE(("cpu_stack_push_check: segbase = %08x, segend = %08x", sd->u.seg.segbase, sd->u.seg.segend)); - EXCEPTION(SS_EXCEPTION, s & 0xfffc); - } - } else { - /* expand-up stack */ - if (esp == 0) { - if ((sd->d && (sd->u.seg.segend != 0xffffffff)) - || (!sd->d && (sd->u.seg.segend != 0xffff))) { - VERBOSE(("cpu_stack_push_check: expand-up, esp = %08x, length = %08x", esp, length)); - VERBOSE(("cpu_stack_push_check: limit = %08x, seglimit = %08x", limit, sd->u.seg.limit)); - VERBOSE(("cpu_stack_push_check: segbase = %08x, segend = %08x", sd->u.seg.segbase, sd->u.seg.segend)); - EXCEPTION(SS_EXCEPTION, s & 0xfffc); - } - } else { - if ((esp < length) - || (esp - 1 > sd->u.seg.limit)) { - VERBOSE(("cpu_stack_push_check: expand-up, esp = %08x, length = %08x", esp, length)); - VERBOSE(("cpu_stack_push_check: limit = %08x, seglimit = %08x", limit, sd->u.seg.limit)); - VERBOSE(("cpu_stack_push_check: segbase = %08x, segend = %08x", sd->u.seg.segbase, sd->u.seg.segend)); - EXCEPTION(SS_EXCEPTION, s & 0xfffc); - } - } - } + len--; + + if (!SEG_IS_VALID(sdp) + || !SEG_IS_PRESENT(sdp) + || SEG_IS_SYSTEM(sdp) + || SEG_IS_CODE(sdp) + || !SEG_IS_WRITABLE_DATA(sdp)) { + goto exc; } -} -void -cpu_stack_pop_check(UINT16 s, descriptor_t *sd, UINT32 esp, UINT length) -{ - UINT32 limit; + start = sp - len; + limit = SEG_IS_32BIT(sdp) ? 0xffffffff : 0x0000ffff; - if (CPU_STAT_PM) { - if (!sd->valid || !sd->p) { - VERBOSE(("cpu_stack_pop_check: valid = %d, present = %d", sd->valid, sd->p)); - EXCEPTION(SS_EXCEPTION, s & 0xfffc); - } - if (!sd->s || sd->u.seg.c || !sd->u.seg.wr) { - VERBOSE(("cpu_stack_pop_check: s = %d, c = %d, wr", sd->s, sd->u.seg.c, sd->u.seg.wr)); - EXCEPTION(SS_EXCEPTION, s & 0xfffc); + if (SEG_IS_EXPANDDOWN_DATA(sdp)) { + /* expand-down stack */ + if (!SEG_IS_32BIT(sdp)) { + if (sp > limit) { /* [*] */ + goto exc; + } } - - if (!sd->d) { - limit = 0xffff; + if (sdp->u.seg.limit == 0) { + /* + * 32bit 16bit + * +-------+ +-------+ FFFFFFFFh + * | | | [*] | + * | | +-------+ 0000FFFFh + * | valid | | | + * | | | valid | + * | | | | + * +-------+ +-------+ 00000000h + */ + if (!SEG_IS_32BIT(sdp)) { + if (sp > limit) { /* [1] */ + goto exc; + } + } else { + sdp->flag |= CPU_DESC_FLAG_WHOLEADR; + } } else { - limit = 0xffffffff; + /* + * 32bit 16bit + * +-------+ +-------+ FFFFFFFFh + * | | | [*] | + * | valid | +-------+ 0000FFFFh + * | | | valid | + * +-------+ +-------+ seg.limit + len - 1 + * | | | | + * +..[1]..+ +..[1]..+ seg.limit + * | | | | + * +-------+ +-------+ 00000000h + */ + if ((len > limit - sdp->u.seg.limit) /* len check */ + || (start > sp) /* wrap check */ + || (start < sdp->u.seg.limit)) { /* [1] */ + goto exc; + } } - if (sd->u.seg.ec) { - /* expand-down stack */ - if ((esp == limit) - || ((limit - esp) + 1 < length)) { - VERBOSE(("cpu_stack_pop_check: expand-up, esp = %08x, length = %08x", esp, length)); - VERBOSE(("cpu_stack_pop_check: limit = %08x, seglimit = %08x", limit, sd->u.seg.limit)); - VERBOSE(("cpu_stack_pop_check: segbase = %08x, segend = %08x", sd->u.seg.segbase, sd->u.seg.segend)); - EXCEPTION(SS_EXCEPTION, s & 0xfffc); + } else { + /* expand-up stack */ + if (sdp->u.seg.limit == limit) { + /* + * 32bit 16bit + * +-------+ +-------+ FFFFFFFFh + * | | | [1] | + * | | +-------+ 0000FFFFh + * | valid | | | + * | | | valid | + * | | | | + * +-------+ +-------+ 00000000h + */ + if (!SEG_IS_32BIT(sdp)) { + if (sp > limit) { /* [1] */ + goto exc; + } + } else { + sdp->flag |= CPU_DESC_FLAG_WHOLEADR; } } else { - /* expand-up stack */ - if ((esp == limit) - || (sd->u.seg.segend == 0) - || (esp > sd->u.seg.limit) - || ((sd->u.seg.limit - esp) + 1 < length)) { - VERBOSE(("cpu_stack_pop_check: expand-up, esp = %08x, length = %08x", esp, length)); - VERBOSE(("cpu_stack_pop_check: limit = %08x, seglimit = %08x", limit, sd->u.seg.limit)); - VERBOSE(("cpu_stack_pop_check: segbase = %08x, segend = %08x", sd->u.seg.segbase, sd->u.seg.segend)); - EXCEPTION(SS_EXCEPTION, s & 0xfffc); + /* + * 32bit 16bit + * +-------+ +-------+ FFFFFFFFh + * | | | | + * | [1] | + [1] + 0000FFFFh + * | | | | + * +-------+ +-------+ seg.limit + * | valid | | valid | + * +.......+ +.......+ len - 1 + * | [+] | | [+] | + * +-------+ +-------+ 00000000h + * + * [+]: wrap check + */ + if ((len > sdp->u.seg.limit) /* len check */ + || (start > sp) /* wrap check */ + || (sp > sdp->u.seg.limit + 1)) { /* [1] */ + goto exc; } } } + return; + +exc: + VERBOSE(("cpu_stack_push_check: check failure: selector = 0x%04x, sp = 0x%08x, len = %d", s, sp, len)); +#if defined(DEBUG) + segdesc_dump(sdp); +#endif + EXCEPTION(SS_EXCEPTION, s & 0xfffc); } -#if defined(IA32_SUPPORT_DEBUG_REGISTER) -INLINE static void -check_memory_break_point(UINT32 address, UINT length, UINT rw) +void MEMCALL +cpu_stack_pop_check(UINT16 s, descriptor_t *sdp, UINT32 sp, UINT len) { - int i; - if (CPU_STAT_BP && !(CPU_EFLAG & RF_FLAG)) { - for (i = 0; i < CPU_DEBUG_REG_INDEX_NUM; i++) { - if ((CPU_STAT_BP & (1 << i)) - && (CPU_DR7_GET_RW(i) & rw) - - && ((address <= CPU_DR(i) && address + length > CPU_DR(i)) - || (address > CPU_DR(i) && address < CPU_DR(i) + CPU_DR7_GET_LEN(i)))) { - CPU_STAT_BP_EVENT |= CPU_STAT_BP_EVENT_B(i); - } - } + __ASSERT(sdp != NULL); + __ASSERT(len > 0); + + if (!SEG_IS_VALID(sdp) + || !SEG_IS_PRESENT(sdp) + || SEG_IS_SYSTEM(sdp) + || SEG_IS_CODE(sdp) + || !SEG_IS_WRITABLE_DATA(sdp)) { + goto exc; } -} -#else -#define check_memory_break_point(address, length, rw) + + if (!check_limit_upstairs(sdp, sp, len)) + goto exc; + return; + +exc: + VERBOSE(("cpu_stack_pop_check: check failure: selector = 0x%04x, sp = 0x%08x, len = %d", s, sp, len)); +#if defined(DEBUG) + segdesc_dump(sdp); #endif + EXCEPTION(SS_EXCEPTION, s & 0xfffc); +} /* * code fetch */ -#define ucrw (CPU_PAGE_READ_CODE | CPU_STAT_USER_MODE) - UINT8 MEMCALL cpu_codefetch(UINT32 offset) { - descriptor_t *sd; + const int ucrw = CPU_PAGE_READ_CODE | CPU_STAT_USER_MODE; + descriptor_t *sdp; UINT32 addr; -#if defined(IA32_SUPPORT_TLB) - TLB_ENTRY_T *ep; -#endif - sd = &CPU_STAT_SREG(CPU_CS_INDEX); - if (offset <= sd->u.seg.limit) { - addr = sd->u.seg.segbase + offset; - if (!CPU_STAT_PAGING) - return cpu_memoryread(addr); -#if defined(IA32_SUPPORT_TLB) - ep = tlb_lookup(addr, ucrw); - if (ep != NULL && ep->memp != NULL) { - return ep->memp[addr & 0xfff]; - } -#endif - return cpu_linear_memory_read_b(addr, ucrw); - } + sdp = &CPU_CS_DESC; + addr = sdp->u.seg.segbase + offset; + + if (!CPU_STAT_PM) + return cpu_memoryread(addr); + if (offset <= sdp->u.seg.limit) + return cpu_lmemoryread(addr, ucrw); + EXCEPTION(GP_EXCEPTION, 0); return 0; /* compiler happy */ } @@ -309,34 +394,18 @@ cpu_codefetch(UINT32 offset) UINT16 MEMCALL cpu_codefetch_w(UINT32 offset) { - descriptor_t *sd; + const int ucrw = CPU_PAGE_READ_CODE | CPU_STAT_USER_MODE; + descriptor_t *sdp; UINT32 addr; -#if defined(IA32_SUPPORT_TLB) - TLB_ENTRY_T *ep; - UINT16 value; -#endif - sd = &CPU_STAT_SREG(CPU_CS_INDEX); - if (offset <= sd->u.seg.limit - 1) { - addr = sd->u.seg.segbase + offset; - if (!CPU_STAT_PAGING) - return cpu_memoryread_w(addr); -#if defined(IA32_SUPPORT_TLB) - ep = tlb_lookup(addr, ucrw); - if (ep != NULL && ep->memp != NULL) { - if ((addr + 1) & 0x00000fff) { - return LOADINTELWORD(ep->memp + (addr & 0xfff)); - } - value = ep->memp[0xfff]; - ep = tlb_lookup(addr + 1, ucrw); - if (ep != NULL && ep->memp != NULL) { - value += (UINT16)ep->memp[0] << 8; - return value; - } - } -#endif - return cpu_linear_memory_read_w(addr, ucrw); - } + sdp = &CPU_CS_DESC; + addr = sdp->u.seg.segbase + offset; + + if (!CPU_STAT_PM) + return cpu_memoryread_w(addr); + if (offset <= sdp->u.seg.limit - 1) + return cpu_lmemoryread_w(addr, ucrw); + EXCEPTION(GP_EXCEPTION, 0); return 0; /* compiler happy */ } @@ -344,56 +413,19 @@ cpu_codefetch_w(UINT32 offset) UINT32 MEMCALL cpu_codefetch_d(UINT32 offset) { - descriptor_t *sd; + const int ucrw = CPU_PAGE_READ_CODE | CPU_STAT_USER_MODE; + descriptor_t *sdp; UINT32 addr; -#if defined(IA32_SUPPORT_TLB) - TLB_ENTRY_T *ep[2]; - UINT32 value; - UINT remain; -#endif - sd = &CPU_STAT_SREG(CPU_CS_INDEX); - if (offset <= sd->u.seg.limit - 3) { - addr = sd->u.seg.segbase + offset; - if (!CPU_STAT_PAGING) - return cpu_memoryread_d(addr); -#if defined(IA32_SUPPORT_TLB) - ep[0] = tlb_lookup(addr, ucrw); - if (ep[0] != NULL && ep[0]->memp != NULL) { - remain = 0x1000 - (addr & 0xfff); - if (remain >= 4) { - return LOADINTELDWORD(ep[0]->memp + (addr & 0xfff)); - } - ep[1] = tlb_lookup(addr + remain, ucrw); - if (ep[1] != NULL && ep[1]->memp != NULL) { - switch (remain) { - case 3: - value = ep[0]->memp[0xffd]; - value += (UINT32)LOADINTELWORD(ep[0]->memp + 0xffe) << 8; - value += (UINT32)ep[1]->memp[0] << 24; - break; - - case 2: - value = LOADINTELWORD(ep[0]->memp + 0xffe); - value += (UINT32)LOADINTELWORD(ep[1]->memp + 0) << 16; - break; - - case 1: - value = ep[0]->memp[0xfff]; - value += (UINT32)LOADINTELWORD(ep[1]->memp + 0) << 8; - value += (UINT32)ep[1]->memp[2] << 24; - break; - - default: - ia32_panic("cpu_codefetch_d(): out of range. (remain = %d)\n", remain); - return (UINT32)-1; - } - return value; - } - } -#endif - return cpu_linear_memory_read_d(addr, ucrw); - } + sdp = &CPU_CS_DESC; + addr = sdp->u.seg.segbase + offset; + + if (!CPU_STAT_PM) + return cpu_memoryread_d(addr); + + if (offset <= sdp->u.seg.limit - 3) + return cpu_lmemoryread_d(addr, ucrw); + EXCEPTION(GP_EXCEPTION, 0); return 0; /* compiler happy */ } @@ -402,49 +434,52 @@ cpu_codefetch_d(UINT32 offset) * additional physical address memory access functions */ UINT64 MEMCALL -cpu_memoryread_q(UINT32 address) +cpu_memoryread_q(UINT32 paddr) { UINT64 value; - value = cpu_memoryread_d(address); - value += (UINT64)cpu_memoryread_d(address + 4) << 32; + value = cpu_memoryread_d(paddr); + value += (UINT64)cpu_memoryread_d(paddr + 4) << 32; return value; } -REG80 MEMCALL -cpu_memoryread_f(UINT32 address) +void MEMCALL +cpu_memorywrite_q(UINT32 paddr, UINT64 value) { - REG80 value; - UINT i; - for (i = 0; i < sizeof(REG80); ++i) { - value.b[i] = cpu_memoryread(address + i); - } - return value; + cpu_memorywrite_d(paddr, (UINT32)value); + cpu_memorywrite_d(paddr + 4, (UINT32)(value >> 32)); } -void MEMCALL -cpu_memorywrite_q(UINT32 address, UINT64 value) +REG80 MEMCALL +cpu_memoryread_f(UINT32 paddr) { + REG80 value; + int i; - cpu_memorywrite_d(address, (UINT32)value); - cpu_memorywrite_d(address + 4, (UINT32)(value >> 32)); + for (i = 0; i < (int)sizeof(REG80); ++i) { + value.b[i] = cpu_memoryread(paddr + i); + } + return value; } void MEMCALL -cpu_memorywrite_f(UINT32 address, const REG80 *value) +cpu_memorywrite_f(UINT32 paddr, const REG80 *value) { - UINT i; + int i; - for (i = 0; i < sizeof(REG80); ++i) { - cpu_memorywrite(address + i, value->b[i]); + for (i = 0; i < (int)sizeof(REG80); ++i) { + cpu_memorywrite(paddr + i, value->b[i]); } } /* * virtual address memory access functions */ +#define CHOOSE_EXCEPTION(sreg) \ + (((sreg) == CPU_SS_INDEX) ? SS_EXCEPTION : GP_EXCEPTION) + #include "cpu_mem.mcr" VIRTUAL_ADDRESS_MEMORY_ACCESS_FUNCTION(b, UINT8, 1) @@ -454,47 +489,33 @@ VIRTUAL_ADDRESS_MEMORY_ACCESS_FUNCTION(d UINT64 MEMCALL cpu_vmemoryread_q(int idx, UINT32 offset) { - descriptor_t *sd; + descriptor_t *sdp; UINT32 addr; int exc; __ASSERT((unsigned int)idx < CPU_SEGREG_NUM); - sd = &CPU_STAT_SREG(idx); - if (!sd->valid) { + sdp = &CPU_STAT_SREG(idx); + addr = sdp->u.seg.segbase + offset; + + if (!CPU_STAT_PM) + return cpu_memoryread_q(addr); + + if (!SEG_IS_VALID(sdp)) { exc = GP_EXCEPTION; goto err; } - - if (!(sd->flag & CPU_DESC_FLAG_READABLE)) { - cpu_memoryread_check(sd, offset, 8, - (idx == CPU_SS_INDEX) ? SS_EXCEPTION : GP_EXCEPTION); - } else { - switch (sd->type) { - case 4: case 5: case 6: case 7: - if (offset - (8 - 1) <= sd->u.seg.limit) - goto range_failure; - break; - - default: - if (offset > sd->u.seg.limit - (8 - 1)) - goto range_failure; - break; - } + if (!(sdp->flag & CPU_DESC_FLAG_READABLE)) { + cpu_memoryread_check(sdp, offset, 8, CHOOSE_EXCEPTION(idx)); + } else if (!(sdp->flag & CPU_DESC_FLAG_WHOLEADR)) { + if (!check_limit_upstairs(sdp, offset, 8)) + goto range_failure; } - addr = sd->u.seg.segbase + offset; - check_memory_break_point(addr, 8, CPU_DR7_RW_RO); - if (!CPU_STAT_PAGING) - return cpu_memoryread_q(addr); - return cpu_linear_memory_read_q(addr, CPU_PAGE_READ_DATA | CPU_STAT_USER_MODE); + return cpu_lmemoryread_q(addr, CPU_PAGE_READ_DATA | CPU_STAT_USER_MODE); range_failure: - if (idx == CPU_SS_INDEX) { - exc = SS_EXCEPTION; - } else { - exc = GP_EXCEPTION; - } - VERBOSE(("cpu_vmemoryread_q: type = %d, offset = %08x, limit = %08x", sd->type, offset, sd->u.seg.limit)); + VERBOSE(("cpu_vmemoryread_q: type = %d, offset = %08x, limit = %08x", sdp->type, offset, sdp->u.seg.limit)); + exc = CHOOSE_EXCEPTION(idx); err: EXCEPTION(exc, 0); return 0; /* compiler happy */ @@ -503,50 +524,40 @@ err: void MEMCALL cpu_vmemorywrite_q(int idx, UINT32 offset, UINT64 value) { - descriptor_t *sd; + descriptor_t *sdp; UINT32 addr; int exc; __ASSERT((unsigned int)idx < CPU_SEGREG_NUM); - sd = &CPU_STAT_SREG(idx); - if (!sd->valid) { + sdp = &CPU_STAT_SREG(idx); + addr = sdp->u.seg.segbase + offset; + + if (!CPU_STAT_PM) { + cpu_memorywrite_q(addr, value); + return; + } + + if (!SEG_IS_VALID(sdp)) { exc = GP_EXCEPTION; goto err; } - - if (!(sd->flag & CPU_DESC_FLAG_WRITABLE)) { - cpu_memorywrite_check(sd, offset, 8, - (idx == CPU_SS_INDEX) ? SS_EXCEPTION : GP_EXCEPTION); - } else { - switch (sd->type) { - case 6: case 7: - if (offset - (8 - 1) <= sd->u.seg.limit) - goto range_failure; - break; - - default: - if (offset > sd->u.seg.limit - (8 - 1)) - goto range_failure; - break; - } + if (!(sdp->flag & CPU_DESC_FLAG_WRITABLE)) { + cpu_memorywrite_check(sdp, offset, 8, CHOOSE_EXCEPTION(idx)); + } else if (!(sdp->flag & CPU_DESC_FLAG_WHOLEADR)) { + if (!check_limit_upstairs(sdp, offset, 8)) + goto range_failure; } - addr = sd->u.seg.segbase + offset; - check_memory_break_point(addr, 8, CPU_DR7_RW_RW); if (!CPU_STAT_PAGING) { cpu_memorywrite_q(addr, value); } else { - cpu_linear_memory_write_q(addr, value, CPU_PAGE_WRITE_DATA | CPU_STAT_USER_MODE); + cpu_linear_memory_write_q(addr, value, CPU_PAGE_READ_DATA | CPU_STAT_USER_MODE); } return; range_failure: - if (idx == CPU_SS_INDEX) { - exc = SS_EXCEPTION; - } else { - exc = GP_EXCEPTION; - } - VERBOSE(("cpu_vmemorywrite_q: type = %d, offset = %08x, limit = %08x", sd->type, offset, sd->u.seg.limit)); + VERBOSE(("cpu_vmemorywrite_q: type = %d, offset = %08x, limit = %08x", sdp->type, offset, sdp->u.seg.limit)); + exc = CHOOSE_EXCEPTION(idx); err: EXCEPTION(exc, 0); } @@ -554,47 +565,35 @@ err: REG80 MEMCALL cpu_vmemoryread_f(int idx, UINT32 offset) { - descriptor_t *sd; + descriptor_t *sdp; UINT32 addr; int exc; __ASSERT((unsigned int)idx < CPU_SEGREG_NUM); - sd = &CPU_STAT_SREG(idx); - if (!sd->valid) { + sdp = &CPU_STAT_SREG(idx); + addr = sdp->u.seg.segbase + offset; + + if (!CPU_STAT_PM) + return cpu_memoryread_f(addr); + + if (!SEG_IS_VALID(sdp)) { exc = GP_EXCEPTION; goto err; } - - if (!(sd->flag & CPU_DESC_FLAG_READABLE)) { - cpu_memoryread_check(sd, offset, 10, - (idx == CPU_SS_INDEX) ? SS_EXCEPTION : GP_EXCEPTION); - } else { - switch (sd->type) { - case 4: case 5: case 6: case 7: - if (offset - (10 - 1) <= sd->u.seg.limit) - goto range_failure; - break; - - default: - if (offset > sd->u.seg.limit - (10 - 1)) - goto range_failure; - break; - } + if (!(sdp->flag & CPU_DESC_FLAG_READABLE)) { + cpu_memoryread_check(sdp, offset, 10, CHOOSE_EXCEPTION(idx)); + } else if (!(sdp->flag & CPU_DESC_FLAG_WHOLEADR)) { + if (!check_limit_upstairs(sdp, offset, 10)) + goto range_failure; } - addr = sd->u.seg.segbase + offset; - check_memory_break_point(addr, 10, CPU_DR7_RW_RO); if (!CPU_STAT_PAGING) return cpu_memoryread_f(addr); - return cpu_linear_memory_read_f(addr, CPU_PAGE_READ_DATA | CPU_STAT_USER_MODE); + return cpu_linear_memory_read_f(addr, CPU_PAGE_READ_DATA | CPU_PAGE_READ_DATA | CPU_STAT_USER_MODE); range_failure: - if (idx == CPU_SS_INDEX) { - exc = SS_EXCEPTION; - } else { - exc = GP_EXCEPTION; - } - VERBOSE(("cpu_vmemoryread_f: type = %d, offset = %08x, limit = %08x", sd->type, offset, sd->u.seg.limit)); + VERBOSE(("cpu_vmemoryread_f: type = %d, offset = %08x, limit = %08x", sdp->type, offset, sdp->u.seg.limit)); + exc = CHOOSE_EXCEPTION(idx); err: EXCEPTION(exc, 0); { @@ -607,36 +606,30 @@ err: void MEMCALL cpu_vmemorywrite_f(int idx, UINT32 offset, const REG80 *value) { - descriptor_t *sd; + descriptor_t *sdp; UINT32 addr; int exc; __ASSERT((unsigned int)idx < CPU_SEGREG_NUM); - sd = &CPU_STAT_SREG(idx); - if (!sd->valid) { + sdp = &CPU_STAT_SREG(idx); + addr = sdp->u.seg.segbase + offset; + + if (!CPU_STAT_PM) { + cpu_memorywrite_f(addr, value); + return; + } + + if (!SEG_IS_VALID(sdp)) { exc = GP_EXCEPTION; goto err; } - - if (!(sd->flag & CPU_DESC_FLAG_WRITABLE)) { - cpu_memorywrite_check(sd, offset, 10, - (idx == CPU_SS_INDEX) ? SS_EXCEPTION : GP_EXCEPTION); - } else { - switch (sd->type) { - case 6: case 7: - if (offset - (10 - 1) <= sd->u.seg.limit) - goto range_failure; - break; - - default: - if (offset > sd->u.seg.limit - (10 - 1)) - goto range_failure; - break; - } + if (!(sdp->flag & CPU_DESC_FLAG_WRITABLE)) { + cpu_memorywrite_check(sdp, offset, 10, CHOOSE_EXCEPTION(idx)); + } else if (!(sdp->flag & CPU_DESC_FLAG_WHOLEADR)) { + if (!check_limit_upstairs(sdp, offset, 10)) + goto range_failure; } - addr = sd->u.seg.segbase + offset; - check_memory_break_point(addr, 10, CPU_DR7_RW_RW); if (!CPU_STAT_PAGING) { cpu_memorywrite_f(addr, value); } else { @@ -645,12 +638,8 @@ cpu_vmemorywrite_f(int idx, UINT32 offse return; range_failure: - if (idx == CPU_SS_INDEX) { - exc = SS_EXCEPTION; - } else { - exc = GP_EXCEPTION; - } - VERBOSE(("cpu_vmemorywrite_f: type = %d, offset = %08x, limit = %08x", sd->type, offset, sd->u.seg.limit)); + VERBOSE(("cpu_vmemorywrite_f: type = %d, offset = %08x, limit = %08x", sdp->type, offset, sdp->u.seg.limit)); + exc = CHOOSE_EXCEPTION(idx); err: EXCEPTION(exc, 0); }