helper.c 11.8 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
/*
 *  sparc helpers
 * 
 *  Copyright (c) 2003 Fabrice Bellard
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
#include "exec.h"

bellard's avatar
bellard committed
22 23
//#define DEBUG_PCALL
//#define DEBUG_MMU
24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64

/* Sparc MMU emulation */
int cpu_sparc_handle_mmu_fault (CPUState *env, uint32_t address, int rw,
                              int is_user, int is_softmmu);

/* thread support */

spinlock_t global_cpu_lock = SPIN_LOCK_UNLOCKED;

void cpu_lock(void)
{
    spin_lock(&global_cpu_lock);
}

void cpu_unlock(void)
{
    spin_unlock(&global_cpu_lock);
}

#if !defined(CONFIG_USER_ONLY) 

#define MMUSUFFIX _mmu
#define GETPC() (__builtin_return_address(0))

#define SHIFT 0
#include "softmmu_template.h"

#define SHIFT 1
#include "softmmu_template.h"

#define SHIFT 2
#include "softmmu_template.h"

#define SHIFT 3
#include "softmmu_template.h"


/* try to fill the TLB and return an exception if error. If retaddr is
   NULL, it means that the function was called in C code (i.e. not
   from generated code or from helper.c) */
/* XXX: fix it to restore all registers */
bellard's avatar
bellard committed
65
void tlb_fill(target_ulong addr, int is_write, int is_user, void *retaddr)
66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111
{
    TranslationBlock *tb;
    int ret;
    unsigned long pc;
    CPUState *saved_env;

    /* XXX: hack to restore env in all cases, even if not called from
       generated code */
    saved_env = env;
    env = cpu_single_env;

    ret = cpu_sparc_handle_mmu_fault(env, addr, is_write, is_user, 1);
    if (ret) {
        if (retaddr) {
            /* now we have a real cpu fault */
            pc = (unsigned long)retaddr;
            tb = tb_find_pc(pc);
            if (tb) {
                /* the PC is inside the translated code. It means that we have
                   a virtual CPU fault */
                cpu_restore_state(tb, env, pc, NULL);
            }
        }
        raise_exception_err(ret, env->error_code);
    }
    env = saved_env;
}
#endif

static const int access_table[8][8] = {
    { 0, 0, 0, 0, 2, 0, 3, 3 },
    { 0, 0, 0, 0, 2, 0, 0, 0 },
    { 2, 2, 0, 0, 0, 2, 3, 3 },
    { 2, 2, 0, 0, 0, 2, 0, 0 },
    { 2, 0, 2, 0, 2, 2, 3, 3 },
    { 2, 0, 2, 0, 2, 0, 2, 0 },
    { 2, 2, 2, 0, 2, 2, 3, 3 },
    { 2, 2, 2, 0, 2, 2, 2, 0 }
};

/* 1 = write OK */
static const int rw_table[2][8] = {
    { 0, 1, 0, 1, 0, 1, 0, 1 },
    { 0, 1, 0, 1, 0, 0, 0, 0 }
};

bellard's avatar
bellard committed
112 113 114
int get_physical_address (CPUState *env, uint32_t *physical, int *prot,
			  int *access_index, uint32_t address, int rw,
			  int is_user)
115
{
bellard's avatar
bellard committed
116 117
    int access_perms = 0;
    target_phys_addr_t pde_ptr;
118
    uint32_t pde, virt_addr;
bellard's avatar
bellard committed
119 120
    int error_code = 0, is_dirty;
    unsigned long page_offset;
121 122 123

    virt_addr = address & TARGET_PAGE_MASK;
    if ((env->mmuregs[0] & MMU_E) == 0) { /* MMU disabled */
bellard's avatar
bellard committed
124 125 126
	*physical = address;
        *prot = PAGE_READ | PAGE_WRITE;
        return 0;
127 128 129 130
    }

    /* SPARC reference MMU table walk: Context table->L1->L2->PTE */
    /* Context base + context number */
bellard's avatar
bellard committed
131
    pde_ptr = (env->mmuregs[1] << 4) + (env->mmuregs[2] << 4);
bellard's avatar
bellard committed
132
    pde = ldl_phys(pde_ptr);
133 134 135

    /* Ctx pde */
    switch (pde & PTE_ENTRYTYPE_MASK) {
bellard's avatar
bellard committed
136
    default:
137
    case 0: /* Invalid */
bellard's avatar
bellard committed
138 139
	return 1;
    case 2: /* L0 PTE, maybe should not happen? */
140
    case 3: /* Reserved */
bellard's avatar
bellard committed
141 142 143
        return 4;
    case 1: /* L0 PDE */
	pde_ptr = ((address >> 22) & ~3) + ((pde & ~3) << 4);
bellard's avatar
bellard committed
144
        pde = ldl_phys(pde_ptr);
145 146

	switch (pde & PTE_ENTRYTYPE_MASK) {
bellard's avatar
bellard committed
147
	default:
148
	case 0: /* Invalid */
bellard's avatar
bellard committed
149
	    return 1;
150
	case 3: /* Reserved */
bellard's avatar
bellard committed
151 152 153
	    return 4;
	case 1: /* L1 PDE */
	    pde_ptr = ((address & 0xfc0000) >> 16) + ((pde & ~3) << 4);
bellard's avatar
bellard committed
154
            pde = ldl_phys(pde_ptr);
155 156

	    switch (pde & PTE_ENTRYTYPE_MASK) {
bellard's avatar
bellard committed
157
	    default:
158
	    case 0: /* Invalid */
bellard's avatar
bellard committed
159
		return 1;
160
	    case 3: /* Reserved */
bellard's avatar
bellard committed
161 162 163
		return 4;
	    case 1: /* L2 PDE */
		pde_ptr = ((address & 0x3f000) >> 10) + ((pde & ~3) << 4);
bellard's avatar
bellard committed
164
                pde = ldl_phys(pde_ptr);
165 166

		switch (pde & PTE_ENTRYTYPE_MASK) {
bellard's avatar
bellard committed
167
		default:
168
		case 0: /* Invalid */
bellard's avatar
bellard committed
169
		    return 1;
170 171
		case 1: /* PDE, should not happen */
		case 3: /* Reserved */
bellard's avatar
bellard committed
172
		    return 4;
173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189
		case 2: /* L3 PTE */
		    virt_addr = address & TARGET_PAGE_MASK;
		    page_offset = (address & TARGET_PAGE_MASK) & (TARGET_PAGE_SIZE - 1);
		}
		break;
	    case 2: /* L2 PTE */
		virt_addr = address & ~0x3ffff;
		page_offset = address & 0x3ffff;
	    }
	    break;
	case 2: /* L1 PTE */
	    virt_addr = address & ~0xffffff;
	    page_offset = address & 0xffffff;
	}
    }

    /* update page modified and dirty bits */
bellard's avatar
bellard committed
190
    is_dirty = (rw & 1) && !(pde & PG_MODIFIED_MASK);
191 192 193 194
    if (!(pde & PG_ACCESSED_MASK) || is_dirty) {
	pde |= PG_ACCESSED_MASK;
	if (is_dirty)
	    pde |= PG_MODIFIED_MASK;
bellard's avatar
bellard committed
195
        stl_phys_notdirty(pde_ptr, pde);
196 197
    }
    /* check access */
bellard's avatar
bellard committed
198
    *access_index = ((rw & 1) << 2) | (rw & 2) | (is_user? 0 : 1);
199
    access_perms = (pde & PTE_ACCESS_MASK) >> PTE_ACCESS_SHIFT;
bellard's avatar
bellard committed
200
    error_code = access_table[*access_index][access_perms];
201
    if (error_code)
bellard's avatar
bellard committed
202
	return error_code;
203 204

    /* the page can be put in the TLB */
bellard's avatar
bellard committed
205
    *prot = PAGE_READ;
206 207 208 209
    if (pde & PG_MODIFIED_MASK) {
        /* only set write access if already dirty... otherwise wait
           for dirty access */
	if (rw_table[is_user][access_perms])
bellard's avatar
bellard committed
210
	        *prot |= PAGE_WRITE;
211 212 213 214
    }

    /* Even if large ptes, we map only one 4KB page in the cache to
       avoid filling it too fast */
bellard's avatar
bellard committed
215 216 217 218 219 220 221 222 223 224 225 226
    *physical = ((pde & PTE_ADDR_MASK) << 4) + page_offset;
    return 0;
}

/* Perform address translation */
int cpu_sparc_handle_mmu_fault (CPUState *env, uint32_t address, int rw,
                              int is_user, int is_softmmu)
{
    int exception = 0;
    uint32_t virt_addr, paddr;
    unsigned long vaddr;
    int error_code = 0, prot, ret = 0, access_index;
227

bellard's avatar
bellard committed
228 229 230 231 232
    if (env->user_mode_only) {
        /* user mode only emulation */
        error_code = -2;
	goto do_fault_user;
    }
233

bellard's avatar
bellard committed
234 235 236 237 238 239 240
    error_code = get_physical_address(env, &paddr, &prot, &access_index, address, rw, is_user);
    if (error_code == 0) {
	virt_addr = address & TARGET_PAGE_MASK;
	vaddr = virt_addr + ((address & TARGET_PAGE_MASK) & (TARGET_PAGE_SIZE - 1));
	ret = tlb_set_page(env, vaddr, paddr, prot, is_user, is_softmmu);
	return ret;
    }
241 242 243 244 245 246

    if (env->mmuregs[3]) /* Fault status register */
	env->mmuregs[3] = 1; /* overflow (not read before another fault) */
    env->mmuregs[3] |= (access_index << 5) | (error_code << 2) | 2;
    env->mmuregs[4] = address; /* Fault address register */

bellard's avatar
bellard committed
247
    if (env->mmuregs[0] & MMU_NF || env->psret == 0) // No fault
248
	return 0;
bellard's avatar
bellard committed
249
 do_fault_user:
250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278
    env->exception_index = exception;
    env->error_code = error_code;
    return error_code;
}

void memcpy32(uint32_t *dst, const uint32_t *src)
{
    dst[0] = src[0];
    dst[1] = src[1];
    dst[2] = src[2];
    dst[3] = src[3];
    dst[4] = src[4];
    dst[5] = src[5];
    dst[6] = src[6];
    dst[7] = src[7];
}

void set_cwp(int new_cwp)
{
    /* put the modified wrap registers at their proper location */
    if (env->cwp == (NWINDOWS - 1))
        memcpy32(env->regbase, env->regbase + NWINDOWS * 16);
    env->cwp = new_cwp;
    /* put the wrap registers at their temporary location */
    if (new_cwp == (NWINDOWS - 1))
        memcpy32(env->regbase + NWINDOWS * 16, env->regbase);
    env->regwptr = env->regbase + (new_cwp * 16);
}

bellard's avatar
bellard committed
279 280 281 282 283 284 285 286 287
void cpu_set_cwp(CPUState *env1, int new_cwp)
{
    CPUState *saved_env;
    saved_env = env;
    env = env1;
    set_cwp(new_cwp);
    env = saved_env;
}

288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303
/*
 * Begin execution of an interruption. is_int is TRUE if coming from
 * the int instruction. next_eip is the EIP value AFTER the interrupt
 * instruction. It is only relevant if is_int is TRUE.  
 */
void do_interrupt(int intno, int is_int, int error_code, 
                  unsigned int next_eip, int is_hw)
{
    int cwp;

#ifdef DEBUG_PCALL
    if (loglevel & CPU_LOG_INT) {
	static int count;
	fprintf(logfile, "%6d: v=%02x e=%04x i=%d pc=%08x npc=%08x SP=%08x\n",
                    count, intno, error_code, is_int,
                    env->pc,
bellard's avatar
bellard committed
304
                    env->npc, env->regwptr[6]);
bellard's avatar
bellard committed
305
#if 1
bellard's avatar
bellard committed
306
	cpu_dump_state(env, logfile, fprintf, 0);
307 308 309
	{
	    int i;
	    uint8_t *ptr;
bellard's avatar
bellard committed
310

311
	    fprintf(logfile, "       code=");
bellard's avatar
bellard committed
312
	    ptr = (uint8_t *)env->pc;
313 314 315 316 317 318 319 320
	    for(i = 0; i < 16; i++) {
		fprintf(logfile, " %02x", ldub(ptr + i));
	    }
	    fprintf(logfile, "\n");
	}
#endif
	count++;
    }
bellard's avatar
bellard committed
321 322 323
#endif
#if !defined(CONFIG_USER_ONLY) 
    if (env->psret == 0) {
bellard's avatar
bellard committed
324
        cpu_abort(cpu_single_env, "Trap while interrupts disabled, Error state");
bellard's avatar
bellard committed
325 326
	return;
    }
327 328 329 330
#endif
    env->psret = 0;
    cwp = (env->cwp - 1) & (NWINDOWS - 1); 
    set_cwp(cwp);
bellard's avatar
bellard committed
331 332
    env->regwptr[9] = env->pc - 4; // XXX?
    env->regwptr[10] = env->pc;
333 334 335 336 337 338 339 340 341 342 343 344
    env->psrps = env->psrs;
    env->psrs = 1;
    env->tbr = (env->tbr & TBR_BASE_MASK) | (intno << 4);
    env->pc = env->tbr;
    env->npc = env->pc + 4;
    env->exception_index = 0;
}

void raise_exception_err(int exception_index, int error_code)
{
    raise_exception(exception_index);
}
bellard's avatar
bellard committed
345 346 347 348 349 350 351 352

uint32_t mmu_probe(uint32_t address, int mmulev)
{
    target_phys_addr_t pde_ptr;
    uint32_t pde;

    /* Context base + context number */
    pde_ptr = (env->mmuregs[1] << 4) + (env->mmuregs[2] << 4);
bellard's avatar
bellard committed
353 354
    pde = ldl_phys(pde_ptr);

bellard's avatar
bellard committed
355 356 357 358 359 360 361 362 363 364
    switch (pde & PTE_ENTRYTYPE_MASK) {
    default:
    case 0: /* Invalid */
    case 2: /* PTE, maybe should not happen? */
    case 3: /* Reserved */
	return 0;
    case 1: /* L1 PDE */
	if (mmulev == 3)
	    return pde;
	pde_ptr = ((address >> 22) & ~3) + ((pde & ~3) << 4);
bellard's avatar
bellard committed
365
        pde = ldl_phys(pde_ptr);
bellard's avatar
bellard committed
366 367 368 369 370 371 372 373 374 375 376 377

	switch (pde & PTE_ENTRYTYPE_MASK) {
	default:
	case 0: /* Invalid */
	case 3: /* Reserved */
	    return 0;
	case 2: /* L1 PTE */
	    return pde;
	case 1: /* L2 PDE */
	    if (mmulev == 2)
		return pde;
	    pde_ptr = ((address & 0xfc0000) >> 16) + ((pde & ~3) << 4);
bellard's avatar
bellard committed
378
            pde = ldl_phys(pde_ptr);
bellard's avatar
bellard committed
379 380 381 382 383 384 385 386 387 388 389 390

	    switch (pde & PTE_ENTRYTYPE_MASK) {
	    default:
	    case 0: /* Invalid */
	    case 3: /* Reserved */
		return 0;
	    case 2: /* L2 PTE */
		return pde;
	    case 1: /* L3 PDE */
		if (mmulev == 1)
		    return pde;
		pde_ptr = ((address & 0x3f000) >> 10) + ((pde & ~3) << 4);
bellard's avatar
bellard committed
391
                pde = ldl_phys(pde_ptr);
bellard's avatar
bellard committed
392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417

		switch (pde & PTE_ENTRYTYPE_MASK) {
		default:
		case 0: /* Invalid */
		case 1: /* PDE, should not happen */
		case 3: /* Reserved */
		    return 0;
		case 2: /* L3 PTE */
		    return pde;
		}
	    }
	}
    }
    return 0;
}

void dump_mmu(void)
{
#ifdef DEBUG_MMU
    uint32_t pa, va, va1, va2;
    int n, m, o;
    target_phys_addr_t pde_ptr;
    uint32_t pde;

    printf("MMU dump:\n");
    pde_ptr = (env->mmuregs[1] << 4) + (env->mmuregs[2] << 4);
bellard's avatar
bellard committed
418
    pde = ldl_phys(pde_ptr);
bellard's avatar
bellard committed
419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443
    printf("Root ptr: 0x%08x, ctx: %d\n", env->mmuregs[1] << 4, env->mmuregs[2]);
    for (n = 0, va = 0; n < 256; n++, va += 16 * 1024 * 1024) {
	pde_ptr = mmu_probe(va, 2);
	if (pde_ptr) {
	    pa = cpu_get_phys_page_debug(env, va);
	    printf("VA: 0x%08x, PA: 0x%08x PDE: 0x%08x\n", va, pa, pde_ptr);
	    for (m = 0, va1 = va; m < 64; m++, va1 += 256 * 1024) {
		pde_ptr = mmu_probe(va1, 1);
		if (pde_ptr) {
		    pa = cpu_get_phys_page_debug(env, va1);
		    printf(" VA: 0x%08x, PA: 0x%08x PDE: 0x%08x\n", va1, pa, pde_ptr);
		    for (o = 0, va2 = va1; o < 64; o++, va2 += 4 * 1024) {
			pde_ptr = mmu_probe(va2, 0);
			if (pde_ptr) {
			    pa = cpu_get_phys_page_debug(env, va2);
			    printf("  VA: 0x%08x, PA: 0x%08x PTE: 0x%08x\n", va2, pa, pde_ptr);
			}
		    }
		}
	    }
	}
    }
    printf("MMU dump ends\n");
#endif
}