![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sparc-recode.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [The Machine Emulator] / tme / ic / sparc|
Return to sparc-recode.c CVS log | Up to [The Machine Emulator] / tme / ic / sparc |
1.1 ! root 1: /* $Id: sparc-recode.c,v 1.6 2010/06/05 18:42:35 fredette Exp $ */ ! 2: ! 3: /* ic/sparc/sparc-recode.c - recodes SPARC instructions: */ ! 4: ! 5: /* ! 6: * Copyright (c) 2008 Matt Fredette ! 7: * All rights reserved. ! 8: * ! 9: * Redistribution and use in source and binary forms, with or without ! 10: * modification, are permitted provided that the following conditions ! 11: * are met: ! 12: * 1. Redistributions of source code must retain the above copyright ! 13: * notice, this list of conditions and the following disclaimer. ! 14: * 2. Redistributions in binary form must reproduce the above copyright ! 15: * notice, this list of conditions and the following disclaimer in the ! 16: * documentation and/or other materials provided with the distribution. ! 17: * 3. All advertising materials mentioning features or use of this software ! 18: * must display the following acknowledgement: ! 19: * This product includes software developed by Matt Fredette. ! 20: * 4. The name of the author may not be used to endorse or promote products ! 21: * derived from this software without specific prior written permission. ! 22: * ! 23: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR ! 24: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED ! 25: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE ! 26: * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, ! 27: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES ! 28: * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR ! 29: * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 30: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, ! 31: * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ! 32: * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE ! 33: * POSSIBILITY OF SUCH DAMAGE. ! 34: */ ! 35: ! 36: /* includes: */ ! 37: #include "sparc-impl.h" ! 38: ! 39: _TME_RCSID("$Id: sparc-recode.c,v 1.6 2010/06/05 18:42:35 fredette Exp $"); ! 40: ! 41: #if TME_HAVE_RECODE ! 42: ! 43: /* macros: */ ! 44: ! 45: /* this gives the number of recode page bitmap bits needed to cover ! 46: the given number of bytes. this is always a multiple of eight: */ ! 47: #define TME_SPARC_RECODE_PAGE_BITMAP_BITS(ic, size_bytes) \ ! 48: ((((size_bytes) >> (ic)->tme_sparc_tlb_page_size_log2) \ ! 49: + 7) \ ! 50: & (0 - (unsigned long) 8)) ! 51: ! 52: /* this returns a read/write thunk index for an opcode: */ ! 53: #define TME_SPARC_RECODE_RW_THUNK_INDEX(ic, address_size, endian, no_fault, opcode_0_3) \ ! 54: ((opcode_0_3) \ ! 55: + ((TME_SPARC_VERSION(ic) >= 9) \ ! 56: * ((16 * ((no_fault) != 0)) \ ! 57: + (32 * ((endian) == TME_ENDIAN_LITTLE)) \ ! 58: + (64 * (TME_SPARC_RECODE_SIZE(ic) - (address_size)))))) ! 59: ! 60: /* how many source address hash positions are probed: */ ! 61: #define TME_SPARC_RECODE_SRC_HASH_SIZE_PROBE (TME_SPARC_RECODE_SRC_HASH_SIZE_SET * 2) ! 62: ! 63: /* the undefined source address hash key: */ ! 64: #define TME_SPARC_RECODE_SRC_KEY_UNDEF ((tme_sparc_recode_src_key_t) (0 - (tme_sparc_recode_src_key_t) 1)) ! 65: ! 66: /* flags in a source address hash key: */ ! 67: /* NB: an architecture can't have more than two flags, since those are ! 68: the only bits available in a source address hash key (because PCs ! 69: are 32-bit aligned): */ ! 70: #define TME_SPARC64_RECODE_SRC_KEY_FLAG_AM (1 << 0) ! 71: #define TME_SPARC64_RECODE_SRC_KEY_FLAG_CLE (1 << 1) ! 72: ! 73: /* the hit count threshold for recoding a source address: */ ! 74: #define TME_SPARC_RECODE_HIT_COUNT_THRESHOLD (512) ! 75: ! 76: /* this returns the recode size for the architecture size: */ ! 77: #define TME_SPARC_RECODE_SIZE(ic) (TME_RECODE_SIZE_32 + (TME_SPARC_VERSION(ic) >= 9)) ! 78: ! 79: /* fix certain things based on the architecture size: */ ! 80: #undef TME_SPARC_VERSION ! 81: #define TME_SPARC_VERSION(ic) (8 + (_TME_SPARC_RECODE_SIZE(/**/,/**/) == 64)) ! 82: #define tme_sparc_ireg_t _TME_SPARC_RECODE_SIZE(tme_uint,_t) ! 83: #define tme_sparc_ireg _TME_SPARC_RECODE_SIZE(tme_sparc_ireg_uint,/**/) ! 84: #define TME_SPARC_IREG_MSBIT (((tme_sparc_ireg_t) 1) << (sizeof(tme_sparc_ireg_t) * 8 - 1)) ! 85: ! 86: /* the current verify state: */ ! 87: #ifdef _TME_SPARC_RECODE_VERIFY ! 88: static int _tme_sparc_recode_off; ! 89: static int _tme_sparc_recode_verify_on; ! 90: #else /* !_TME_SPARC_RECODE_VERIFY */ ! 91: #define _tme_sparc_recode_off (FALSE) ! 92: #define _tme_sparc_recode_verify_on (FALSE) ! 93: #endif /* !_TME_SPARC_RECODE_VERIFY */ ! 94: ! 95: /* make the sparc32 recode support: */ ! 96: #define _TME_SPARC_RECODE_SIZE(x,y) _TME_CONCAT(_TME_CONCAT(x,32),y) ! 97: #include "sparc-rc-cc.c" ! 98: #include "sparc-rc-chain.c" ! 99: #include "sparc-rc-insns.c" ! 100: #include "sparc-rc-ls.c" ! 101: #undef _TME_SPARC_RECODE_SIZE ! 102: ! 103: #if TME_RECODE_SIZE_GUEST_MAX > TME_RECODE_SIZE_32 ! 104: ! 105: /* make the sparc64 recode support: */ ! 106: #define _TME_SPARC_RECODE_SIZE(x,y) _TME_CONCAT(_TME_CONCAT(x,64),y) ! 107: #include "sparc-rc-cc.c" ! 108: #include "sparc-rc-chain.c" ! 109: #include "sparc-rc-insns.c" ! 110: #include "sparc-rc-ls.c" ! 111: #undef _TME_SPARC_RECODE_SIZE ! 112: ! 113: #endif /* TME_RECODE_SIZE_GUEST_MAX > TME_RECODE_SIZE_32 */ ! 114: ! 115: /* unfix certain things: */ ! 116: #undef TME_SPARC_VERSION ! 117: #define TME_SPARC_VERSION(ic) _TME_SPARC_VERSION(ic) ! 118: #undef tme_sparc_ireg_t ! 119: #undef tme_sparc_ireg ! 120: #undef TME_SPARC_IREG_MSBIT ! 121: ! 122: /* this invalidates pages in the source address hash: */ ! 123: static void ! 124: _tme_sparc_recode_src_hash_invalidate(struct tme_sparc *ic, ! 125: tme_sparc_recode_src_key_t src_key_mask, ! 126: tme_sparc_recode_src_key_t src_key_match) ! 127: { ! 128: signed long src_hash_i; ! 129: tme_sparc_recode_src_key_t src_key; ! 130: tme_recode_thunk_off_t insns_thunk; ! 131: ! 132: /* walk all of the positions in the source address hash: */ ! 133: src_hash_i ! 134: = ((TME_SPARC_RECODE_SRC_HASH_MODULUS ! 135: * TME_SPARC_RECODE_SRC_HASH_SIZE_SET) ! 136: - 1); ! 137: do { ! 138: ! 139: /* if the source address key in this position matches: */ ! 140: src_key ! 141: = (ic->tme_sparc_recode_src_hash ! 142: [src_hash_i / TME_SPARC_RECODE_SRC_HASH_SIZE_ELEMENT] ! 143: .tme_sparc_recode_src_hash_keys ! 144: [src_hash_i % TME_SPARC_RECODE_SRC_HASH_SIZE_ELEMENT]); ! 145: if (((src_key ^ src_key_match) & src_key_mask) == 0) { ! 146: ! 147: /* invalidate this source address key: */ ! 148: (ic->tme_sparc_recode_src_hash ! 149: [src_hash_i / TME_SPARC_RECODE_SRC_HASH_SIZE_ELEMENT] ! 150: .tme_sparc_recode_src_hash_keys ! 151: [src_hash_i % TME_SPARC_RECODE_SRC_HASH_SIZE_ELEMENT]) ! 152: = TME_SPARC_RECODE_SRC_KEY_UNDEF; ! 153: ! 154: /* if this source address key has an instructions thunk: */ ! 155: insns_thunk ! 156: = (ic->tme_sparc_recode_src_hash ! 157: [src_hash_i / TME_SPARC_RECODE_SRC_HASH_SIZE_ELEMENT] ! 158: .tme_sparc_recode_src_hash_values ! 159: [src_hash_i % TME_SPARC_RECODE_SRC_HASH_SIZE_ELEMENT]); ! 160: if ((insns_thunk & TME_BIT(0)) == 0 ! 161: && insns_thunk != 0) { ! 162: ! 163: /* invalidate the instructions thunk: */ ! 164: tme_recode_insns_thunk_invalidate(ic->tme_sparc_recode_ic, ! 165: insns_thunk); ! 166: } ! 167: ! 168: /* reset the value for this position to a hit count of zero: */ ! 169: (ic->tme_sparc_recode_src_hash ! 170: [src_hash_i / TME_SPARC_RECODE_SRC_HASH_SIZE_ELEMENT] ! 171: .tme_sparc_recode_src_hash_values ! 172: [src_hash_i % TME_SPARC_RECODE_SRC_HASH_SIZE_ELEMENT]) ! 173: = TME_BIT(0); ! 174: } ! 175: } while (--src_hash_i >= 0); ! 176: } ! 177: ! 178: /* this invalidates our entire source hash and all instructions ! 179: thunks: */ ! 180: void ! 181: tme_sparc_recode_invalidate_all(struct tme_sparc *ic) ! 182: { ! 183: ! 184: /* invalidate our entire source hash: */ ! 185: _tme_sparc_recode_src_hash_invalidate(ic, 0, 0); ! 186: ! 187: /* invalidate all instructions thunks: */ ! 188: tme_recode_insns_thunk_invalidate_all(ic->tme_sparc_recode_ic); ! 189: ! 190: /* clear the return address stack: */ ! 191: tme_recode_chain_ras_clear(ic->tme_sparc_recode_ic, ! 192: &ic->tme_sparc_ic); ! 193: } ! 194: ! 195: /* include the verify support: */ ! 196: #ifdef _TME_SPARC_RECODE_VERIFY ! 197: #include "sparc-rc-verify.c" ! 198: #endif /* _TME_SPARC_RECODE_VERIFY */ ! 199: ! 200: /* this adds a new cacheable: */ ! 201: static struct tme_sparc_recode_cacheable * ! 202: _tme_sparc_recode_cacheable_new(struct tme_sparc *ic, ! 203: const struct tme_sparc_tlb *itlb, ! 204: const tme_shared tme_uint32_t *src) ! 205: { ! 206: unsigned int page_size_log2; ! 207: tme_uint32_t page_size; ! 208: tme_uint32_t page_byte_offset; ! 209: struct tme_sparc_recode_cacheable *cacheable; ! 210: const struct tme_bus_cacheable *bus_cacheable; ! 211: unsigned long bitmap_bytes_old; ! 212: unsigned long bitmap_bytes; ! 213: ! 214: /* get the page size: */ ! 215: page_size_log2 = ic->tme_sparc_tlb_page_size_log2; ! 216: page_size = (((tme_uint32_t) 1) << page_size_log2); ! 217: ! 218: /* get the offset of the current PC into this page: */ ! 219: page_byte_offset ! 220: = ( ! 221: #if TME_RECODE_SIZE_GUEST_MAX > TME_RECODE_SIZE_32 ! 222: TME_SPARC_VERSION(ic) >= 9 ! 223: ? ic->tme_sparc_ireg_uint64(TME_SPARC_IREG_PC) ! 224: : ! 225: #endif /* TME_RECODE_SIZE_GUEST_MAX > TME_RECODE_SIZE_32 */ ! 226: ic->tme_sparc_ireg_uint32(TME_SPARC_IREG_PC)); ! 227: page_byte_offset %= page_size; ! 228: ! 229: /* if we have run out of cacheables, return failure: */ ! 230: cacheable = ic->tme_sparc_recode_cacheable_first; ! 231: if (cacheable == &ic->tme_sparc_recode_cacheables[TME_SPARC_RECODE_CACHEABLES_MAX - 1]) { ! 232: return (NULL); ! 233: } ! 234: cacheable += (ic->tme_sparc_recode_cacheables[0].tme_sparc_recode_cacheable_size != 0); ! 235: ! 236: /* if this instruction TLB entry isn't for cacheable memory, return ! 237: failure: */ ! 238: bus_cacheable = itlb->tme_sparc_tlb_bus_tlb.tme_bus_tlb_cacheable; ! 239: if (bus_cacheable == NULL) { ! 240: return (NULL); ! 241: } ! 242: ! 243: /* if the cacheable memory doesn't cover some whole number of ! 244: aligned pages, return failure: */ ! 245: assert (bus_cacheable->tme_bus_cacheable_size > 0); ! 246: if ((((((tme_uint8_t *) src) ! 247: - bus_cacheable->tme_bus_cacheable_contents) ! 248: % page_size) ! 249: != page_byte_offset) ! 250: || ((bus_cacheable->tme_bus_cacheable_size ! 251: % page_size) ! 252: != 0)) { ! 253: return (NULL); ! 254: } ! 255: ! 256: /* initialize our cacheable: */ ! 257: /* NB: we round up the first source address key for this cacheable ! 258: so that its page index is a multiple of eight, which will be used ! 259: to index the least-significant bit in the first byte of the ! 260: valids bitmap we allocate below: */ ! 261: cacheable->tme_sparc_recode_cacheable_contents = bus_cacheable->tme_bus_cacheable_contents; ! 262: cacheable->tme_sparc_recode_cacheable_size = bus_cacheable->tme_bus_cacheable_size; ! 263: cacheable->tme_sparc_recode_cacheable_src_key_first ! 264: = (cacheable == &ic->tme_sparc_recode_cacheables[0] ! 265: ? 0 ! 266: : ((cacheable - 1)->tme_sparc_recode_cacheable_src_key_first ! 267: ! 268: + (TME_SPARC_RECODE_PAGE_BITMAP_BITS(ic, (cacheable - 1)->tme_sparc_recode_cacheable_size) ! 269: * page_size))); ! 270: ! 271: /* allocate the valids bitmap, and adjust the pointer to account ! 272: for the first source key in this cacheable: */ ! 273: cacheable->tme_sparc_recode_cacheable_valids ! 274: = ((*bus_cacheable->tme_bus_cacheable_valids_new) ! 275: (bus_cacheable->tme_bus_cacheable_private, ! 276: page_size_log2) ! 277: - ((cacheable->tme_sparc_recode_cacheable_src_key_first ! 278: / page_size) ! 279: / 8)); ! 280: ! 281: /* allocate or reallocate the active recode pages bitmap, and zero ! 282: the new parts of the bitmap: */ ! 283: bitmap_bytes_old ! 284: = (cacheable->tme_sparc_recode_cacheable_src_key_first ! 285: / (page_size * 8)); ! 286: bitmap_bytes ! 287: = (bitmap_bytes_old ! 288: + (TME_SPARC_RECODE_PAGE_BITMAP_BITS(ic, cacheable->tme_sparc_recode_cacheable_size) ! 289: / 8)); ! 290: ic->tme_sparc_recode_cacheable_actives ! 291: = (cacheable == &ic->tme_sparc_recode_cacheables[0] ! 292: ? tme_new(tme_uint8_t, bitmap_bytes) ! 293: : tme_renew(tme_uint8_t, ic->tme_sparc_recode_cacheable_actives, bitmap_bytes)); ! 294: memset((ic->tme_sparc_recode_cacheable_actives + bitmap_bytes_old), ! 295: 0, ! 296: (bitmap_bytes - bitmap_bytes_old)); ! 297: ! 298: /* finish allocating this cacheable: */ ! 299: ic->tme_sparc_recode_cacheable_first = cacheable; ! 300: ! 301: /* return success: */ ! 302: return (cacheable); ! 303: } ! 304: ! 305: tme_recode_thunk_off_t ! 306: tme_sparc_recode(struct tme_sparc *ic, ! 307: const struct tme_sparc_tlb *itlb, ! 308: const tme_shared tme_uint32_t *src) ! 309: { ! 310: ! 311: const struct tme_sparc_recode_cacheable *cacheable; ! 312: tme_sparc_recode_src_key_t src_key; ! 313: tme_uint32_t pstate; ! 314: unsigned long page_index; ! 315: tme_uint8_t page_invalid; ! 316: const tme_shared tme_uint8_t *cacheable_valid_byte; ! 317: unsigned int cacheable_valid_mask; ! 318: signed long src_hash_i; ! 319: signed int src_hash_probe; ! 320: tme_sparc_recode_src_key_t src_key_other; ! 321: tme_recode_thunk_off_t insns_thunk; ! 322: tme_recode_thunk_off_t hit_count; ! 323: ! 324: TME_SPARC_STAT(ic, tme_sparc_stats_recode_calls); ! 325: ! 326: /* if recoding is off: */ ! 327: if (_tme_sparc_recode_off) { ! 328: ! 329: /* we can't recode this source address: */ ! 330: return (0); ! 331: } ! 332: ! 333: /* if this instruction TLB entry doesn't extend to the end of the ! 334: page: */ ! 335: /* XXX FIXME - this isn't right, since it will reject all itlb ! 336: entries that don't end right at a recode page boundary, instead ! 337: of only those that end before the end of the page containing the ! 338: current PC. maybe this check should move to sparc-rc-insns.c or ! 339: sparc-execute.c, where we have the current PC? */ ! 340: if (__tme_predict_false((~itlb->tme_sparc_tlb_addr_last) ! 341: & ((1 << ic->tme_sparc_tlb_page_size_log2) ! 342: - sizeof(tme_uint32_t)))) { ! 343: ! 344: /* we can't recode this source address: */ ! 345: return (0); ! 346: } ! 347: ! 348: /* assume that we will recode at this source address, and save it: */ ! 349: ic->tme_sparc_recode_insns_group.tme_recode_insns_group_src ! 350: = (const tme_shared tme_uint8_t *) src; ! 351: ! 352: /* search for a cacheable that contains this source address: */ ! 353: cacheable = ic->tme_sparc_recode_cacheable_first; ! 354: for (;;) { ! 355: ! 356: /* assume that this cacheable contains this source address, and get the ! 357: source address key relative to the start of the cacheable: */ ! 358: src_key = ((tme_uint8_t *) src) - cacheable->tme_sparc_recode_cacheable_contents; ! 359: ! 360: /* if this cacheable contains this source address: */ ! 361: if (__tme_predict_true(src_key ! 362: < cacheable->tme_sparc_recode_cacheable_size)) { ! 363: ! 364: /* stop now: */ ! 365: break; ! 366: } ! 367: ! 368: /* if we have not run out of cacheables: */ ! 369: if (__tme_predict_true(--cacheable != (&ic->tme_sparc_recode_cacheables[0] - 1))) { ! 370: continue; ! 371: } ! 372: ! 373: /* if this instruction TLB entry isn't for a cacheable, or if we ! 374: can't add this cacheable: */ ! 375: cacheable = _tme_sparc_recode_cacheable_new(ic, itlb, src); ! 376: if (cacheable == NULL) { ! 377: ! 378: /* we can't recode this source address: */ ! 379: return (0); ! 380: } ! 381: } ! 382: ! 383: /* make the absolute source address key by adding in the first ! 384: source address key in this cacheable: */ ! 385: src_key += cacheable->tme_sparc_recode_cacheable_src_key_first; ! 386: assert ((src_key % sizeof(tme_uint32_t)) == 0); ! 387: ! 388: /* if this is a v9 CPU: */ ! 389: if (TME_RECODE_SIZE_GUEST_MAX > TME_RECODE_SIZE_32 ! 390: && TME_SPARC_VERSION(ic) >= 9) { ! 391: ! 392: /* add PSTATE.AM and PSTATE.CLE to the source address key: */ ! 393: pstate = ic->tme_sparc64_ireg_pstate; ! 394: if (pstate & TME_SPARC64_PSTATE_AM) { ! 395: src_key += TME_SPARC64_RECODE_SRC_KEY_FLAG_AM; ! 396: } ! 397: if (pstate & TME_SPARC64_PSTATE_CLE) { ! 398: src_key += TME_SPARC64_RECODE_SRC_KEY_FLAG_CLE; ! 399: } ! 400: } ! 401: ! 402: /* the source address key must be defined: */ ! 403: assert (src_key != TME_SPARC_RECODE_SRC_KEY_UNDEF); ! 404: ! 405: /* make the index for the page containing this source address: */ ! 406: page_index = src_key >> ic->tme_sparc_tlb_page_size_log2; ! 407: ! 408: /* assume that this recode page is still valid: */ ! 409: page_invalid = FALSE; ! 410: ! 411: /* get the cacheable valid byte and mask for this page: */ ! 412: cacheable_valid_byte = &cacheable->tme_sparc_recode_cacheable_valids[page_index / 8]; ! 413: cacheable_valid_mask = TME_BIT(page_index % 8); ! 414: ! 415: /* assume that we will recode at this source address, and save the ! 416: cacheable valid byte and mask for this page: */ ! 417: ic->tme_sparc_recode_insns_group.tme_recode_insns_group_valid_byte = cacheable_valid_byte; ! 418: ic->tme_sparc_recode_insns_group.tme_recode_insns_group_valid_mask = cacheable_valid_mask; ! 419: ! 420: /* if the valid bit for this page is no longer set: */ ! 421: if (__tme_predict_false(((*cacheable_valid_byte) & cacheable_valid_mask) == 0)) { ! 422: ! 423: /* this page is invalid: */ ! 424: page_invalid = TRUE; ! 425: ! 426: /* if this page was active: */ ! 427: if (__tme_predict_false(ic->tme_sparc_recode_cacheable_actives[page_index / 8] ! 428: & TME_BIT(page_index % 8))) { ! 429: ! 430: TME_SPARC_STAT(ic, tme_sparc_stats_recode_page_invalids); ! 431: ! 432: /* mark this page as inactive: */ ! 433: ic->tme_sparc_recode_cacheable_actives[page_index / 8] &= ~TME_BIT(page_index % 8); ! 434: ! 435: /* re-set the valid bit for the page containing this ! 436: source address: */ ! 437: /* NB: we cheat and pass our ! 438: page-index-base-greater-than-zero-relative valids bitmap ! 439: pointer instead of the original pointer returned by the ! 440: allocator. this only works if the re-set function will work ! 441: given arbitrary valids bitmap pointers and page indices: */ ! 442: (*itlb->tme_sparc_tlb_bus_tlb.tme_bus_tlb_cacheable->tme_bus_cacheable_valids_set) ! 443: (itlb->tme_sparc_tlb_bus_tlb.tme_bus_tlb_cacheable->tme_bus_cacheable_private, ! 444: cacheable->tme_sparc_recode_cacheable_valids, ! 445: page_index); ! 446: ! 447: /* invalidate this page in the source address hash: */ ! 448: _tme_sparc_recode_src_hash_invalidate(ic, ! 449: (0 ! 450: - ((tme_sparc_recode_src_key_t) ! 451: (1 << ic->tme_sparc_tlb_page_size_log2))), ! 452: src_key); ! 453: } ! 454: } ! 455: ! 456: /* hash the source address key: */ ! 457: src_hash_i ! 458: = ((((src_key ! 459: / sizeof(tme_uint32_t)) ! 460: % TME_SPARC_RECODE_SRC_HASH_MODULUS) ! 461: * TME_SPARC_RECODE_SRC_HASH_SIZE_SET) ! 462: + (TME_SPARC_RECODE_SRC_HASH_SIZE_SET ! 463: - 1)); ! 464: ! 465: /* search for the source address key in the hash: */ ! 466: src_hash_probe = TME_SPARC_RECODE_SRC_HASH_SIZE_PROBE; ! 467: for (;;) { ! 468: ! 469: TME_SPARC_STAT(ic, tme_sparc_stats_recode_source_hash_probes); ! 470: ! 471: /* get the source address key at this position: */ ! 472: src_key_other ! 473: = (ic->tme_sparc_recode_src_hash ! 474: [src_hash_i / TME_SPARC_RECODE_SRC_HASH_SIZE_ELEMENT] ! 475: .tme_sparc_recode_src_hash_keys ! 476: [src_hash_i % TME_SPARC_RECODE_SRC_HASH_SIZE_ELEMENT]); ! 477: ! 478: /* if we found the source address key, stop now: */ ! 479: if (__tme_predict_true(src_key_other == src_key)) { ! 480: break; ! 481: } ! 482: ! 483: /* if this position in the hash is free: */ ! 484: if (src_key_other == TME_SPARC_RECODE_SRC_KEY_UNDEF) { ! 485: ! 486: /* allocate this position in the hash: */ ! 487: (ic->tme_sparc_recode_src_hash ! 488: [src_hash_i / TME_SPARC_RECODE_SRC_HASH_SIZE_ELEMENT] ! 489: .tme_sparc_recode_src_hash_keys ! 490: [src_hash_i % TME_SPARC_RECODE_SRC_HASH_SIZE_ELEMENT]) ! 491: = src_key; ! 492: ! 493: /* stop now: */ ! 494: break; ! 495: } ! 496: ! 497: /* if we have searched enough: */ ! 498: if (__tme_predict_false(--src_hash_probe < 0)) { ! 499: ! 500: TME_SPARC_STAT(ic, tme_sparc_stats_recode_source_hash_misses); ! 501: ! 502: /* we won't recode this source address: */ ! 503: return (0); ! 504: } ! 505: ! 506: /* move to the next position to search: */ ! 507: if (__tme_predict_false(--src_hash_i < 0)) { ! 508: src_hash_i ! 509: = ((TME_SPARC_RECODE_SRC_HASH_MODULUS ! 510: * TME_SPARC_RECODE_SRC_HASH_SIZE_SET) ! 511: - 1); ! 512: } ! 513: } ! 514: ! 515: /* assume that this source address has been recoded, and get the ! 516: instructions thunk: */ ! 517: insns_thunk ! 518: = (ic->tme_sparc_recode_src_hash ! 519: [src_hash_i / TME_SPARC_RECODE_SRC_HASH_SIZE_ELEMENT] ! 520: .tme_sparc_recode_src_hash_values ! 521: [src_hash_i % TME_SPARC_RECODE_SRC_HASH_SIZE_ELEMENT]); ! 522: ! 523: /* if the source address has not been recoded yet: */ ! 524: if (__tme_predict_false(insns_thunk & TME_BIT(0))) { ! 525: ! 526: /* update the hit count for this source address: */ ! 527: hit_count = insns_thunk + 2; ! 528: ! 529: /* if the hit count for this source address is still less than the ! 530: recode threshold: */ ! 531: if (__tme_predict_true(hit_count ! 532: < ((TME_SPARC_RECODE_HIT_COUNT_THRESHOLD * 2) ! 533: + 1))) { ! 534: ! 535: /* update the hit count for this source address: */ ! 536: (ic->tme_sparc_recode_src_hash ! 537: [src_hash_i / TME_SPARC_RECODE_SRC_HASH_SIZE_ELEMENT] ! 538: .tme_sparc_recode_src_hash_values ! 539: [src_hash_i % TME_SPARC_RECODE_SRC_HASH_SIZE_ELEMENT]) ! 540: = hit_count; ! 541: ! 542: /* we won't recode this source address now: */ ! 543: return (0); ! 544: } ! 545: ! 546: /* mark this page as active: */ ! 547: ic->tme_sparc_recode_cacheable_actives[page_index / 8] |= TME_BIT(page_index % 8); ! 548: ! 549: /* if this page is invalid: */ ! 550: if (page_invalid) { ! 551: ! 552: /* return now and interpret instructions normally - the next ! 553: time we encounter this page again, we will mark this ! 554: page as inactive, re-set the page's valid bit and ! 555: invalidate the page in the source address hash. ! 556: ! 557: this somewhat limits the work we do for pages that are ! 558: both executed from and written to frequently. we will only ! 559: recode an instructions thunk when its page was valid for the ! 560: entire time it took for its hit count to go from zero to the ! 561: threshold, and we will only invalidate an invalid page in the ! 562: source address hash when any hit count in the page reaches ! 563: the threshold: */ ! 564: return (0); ! 565: } ! 566: ! 567: /* recode starting from this source address: */ ! 568: insns_thunk ! 569: = ( ! 570: #if TME_RECODE_SIZE_GUEST_MAX > TME_RECODE_SIZE_32 ! 571: TME_SPARC_VERSION(ic) >= 9 ! 572: ? _tme_sparc64_recode_recode(ic, itlb) ! 573: : ! 574: #endif /* TME_RECODE_SIZE_GUEST_MAX > TME_RECODE_SIZE_32 */ ! 575: _tme_sparc32_recode_recode(ic, itlb)); ! 576: ! 577: /* if we couldn't recode at this source address: */ ! 578: if (__tme_predict_false(insns_thunk < 0)) { ! 579: ! 580: /* the only time we can't recode is when the host runs out of ! 581: memory for instructions thunks. when this happens, the host ! 582: invalidates all previous instructions thunks, so we have to ! 583: invalidate our entire source hash: */ ! 584: tme_sparc_recode_invalidate_all(ic); ! 585: return (0); ! 586: } ! 587: ! 588: /* set the instructions thunk for this source address: */ ! 589: assert ((insns_thunk & TME_BIT(0)) == 0); ! 590: (ic->tme_sparc_recode_src_hash ! 591: [src_hash_i / TME_SPARC_RECODE_SRC_HASH_SIZE_ELEMENT] ! 592: .tme_sparc_recode_src_hash_values ! 593: [src_hash_i % TME_SPARC_RECODE_SRC_HASH_SIZE_ELEMENT]) ! 594: = insns_thunk; ! 595: ! 596: /* we can't run the new instructions thunk without re-checking the ! 597: valid bit for the page containing this source address ! 598: first - if it wasn't set for the entire time we were recoding, ! 599: the instructions thunk might not be consistent with the source ! 600: memory. ! 601: ! 602: to keep things simple, we just return now and interpret ! 603: instructions normally - the next time we get to this source ! 604: address, we'll check the valid bit and either run the ! 605: instructions thunk for the first time, or we'll do the ! 606: invalidate: */ ! 607: return (0); ! 608: } ! 609: ! 610: /* return the instructions thunk offset: */ ! 611: return (insns_thunk); ! 612: } ! 613: ! 614: #ifdef TME_RECODE_DEBUG ! 615: #include <stdio.h> ! 616: ! 617: void tme_sparc_recode_dump_ic _TME_P((const struct tme_sparc *)); ! 618: void ! 619: tme_sparc_recode_dump_ic(const struct tme_sparc *ic) ! 620: { ! 621: const char *conds_integer[] = { ! 622: "n", "e", "le", "l", "leu", "cs", "neg", "vs", ! 623: NULL ! 624: }; ! 625: ! 626: printf("sparc%u add flags thunk %p:\n", ! 627: (1 << TME_SPARC_RECODE_SIZE(ic)), ! 628: ic->tme_sparc_recode_flags_thunk_add); ! 629: tme_recode_flags_thunk_dump(ic->tme_sparc_recode_ic, ! 630: ic->tme_sparc_recode_flags_thunk_add); ! 631: printf("sparc%u sub flags thunk %p:\n", ! 632: (1 << TME_SPARC_RECODE_SIZE(ic)), ! 633: ic->tme_sparc_recode_flags_thunk_sub); ! 634: tme_recode_flags_thunk_dump(ic->tme_sparc_recode_ic, ! 635: ic->tme_sparc_recode_flags_thunk_sub); ! 636: printf("sparc%u logical flags thunk %p:\n", ! 637: (1 << TME_SPARC_RECODE_SIZE(ic)), ! 638: ic->tme_sparc_recode_flags_thunk_logical); ! 639: tme_recode_flags_thunk_dump(ic->tme_sparc_recode_ic, ! 640: ic->tme_sparc_recode_flags_thunk_logical); ! 641: ! 642: if (TME_SPARC_VERSION(ic) >= 9) { ! 643: printf("sparc%u rcc flags thunk %p:\n", ! 644: (1 << TME_SPARC_RECODE_SIZE(ic)), ! 645: ic->tme_sparc_recode_flags_thunk_rcc); ! 646: tme_recode_flags_thunk_dump(ic->tme_sparc_recode_ic, ! 647: ic->tme_sparc_recode_flags_thunk_rcc); ! 648: } ! 649: printf("sparc%u %%icc conds thunk %p:\n", ! 650: (1 << TME_SPARC_RECODE_SIZE(ic)), ! 651: ic->tme_sparc_recode_conds_thunk_icc); ! 652: tme_recode_conds_thunk_dump(ic->tme_sparc_recode_ic, ! 653: ic->tme_sparc_recode_conds_thunk_icc, ! 654: conds_integer); ! 655: if (TME_SPARC_VERSION(ic) >= 9) { ! 656: printf("sparc%u %%xcc conds thunk %p:\n", ! 657: (1 << TME_SPARC_RECODE_SIZE(ic)), ! 658: ic->tme_sparc_recode_conds_thunk_xcc); ! 659: tme_recode_conds_thunk_dump(ic->tme_sparc_recode_ic, ! 660: ic->tme_sparc_recode_conds_thunk_xcc, ! 661: conds_integer); ! 662: printf("sparc%u %%rcc conds thunk %p:\n", ! 663: (1 << TME_SPARC_RECODE_SIZE(ic)), ! 664: ic->tme_sparc_recode_conds_thunk_rcc); ! 665: tme_recode_conds_thunk_dump(ic->tme_sparc_recode_ic, ! 666: ic->tme_sparc_recode_conds_thunk_rcc, ! 667: conds_integer); ! 668: } ! 669: } ! 670: ! 671: void tme_sparc_recode_dump_insns _TME_P((const struct tme_sparc *)); ! 672: void ! 673: tme_sparc_recode_dump_insns(const struct tme_sparc *ic) ! 674: { ! 675: const struct tme_recode_insn *insns; ! 676: const struct tme_recode_insn *insns_end; ! 677: unsigned int insn_i; ! 678: const char *s; ! 679: unsigned int insn_size; ! 680: unsigned int operands_mask; ! 681: unsigned int thunk_i; ! 682: unsigned int operand_i; ! 683: int delim; ! 684: const char *regcs = "goli"; ! 685: const char *conds_integer[] = { ! 686: "n", "e", "le", "l", "leu", "cs", "neg", "vs", ! 687: "a", "ne", "g", "ge", "gu", "cc", "pos", "vc", ! 688: }; ! 689: tme_uint32_t chain_info; ! 690: ! 691: printf("%%pc = "); ! 692: tme_recode_uguest_dump( ! 693: #if TME_RECODE_SIZE_GUEST_MAX > TME_RECODE_SIZE_32 ! 694: TME_SPARC_VERSION(ic) >= 9 ! 695: ? ic->tme_sparc_ireg_uint64(TME_SPARC_IREG_PC) ! 696: : ! 697: #endif /* TME_RECODE_SIZE_GUEST_MAX > TME_RECODE_SIZE_32 */ ! 698: ic->tme_sparc_ireg_uint32(TME_SPARC_IREG_PC)); ! 699: printf("\n"); ! 700: ! 701: insns = ic->tme_sparc_recode_insns_group.tme_recode_insns_group_insns; ! 702: insns_end = ic->tme_sparc_recode_insns_group.tme_recode_insns_group_insns_end; ! 703: for (insn_i = 0; insns < insns_end; insns++, insn_i++) { ! 704: ! 705: printf("%2u: ", insn_i); ! 706: ! 707: s = tme_recode_opcode_dump(insns->tme_recode_insn_opcode); ! 708: insn_size = insns->tme_recode_insn_size; ! 709: switch (insns->tme_recode_insn_opcode) { ! 710: case TME_RECODE_OPCODE_EXTZ: ! 711: case TME_RECODE_OPCODE_EXTS: ! 712: printf("ext%u%c", ! 713: (1 << insns->tme_recode_insn_operand_src[1]), ! 714: (insns->tme_recode_insn_opcode == TME_RECODE_OPCODE_EXTZ ? 'z' : 's')); ! 715: s = ""; ! 716: operands_mask = (1 << 0) | (1 << 2); ! 717: break; ! 718: case TME_RECODE_OPCODE_DEFC: ! 719: printf("defc\t %%%ccc:%s, %%c%u\n", ! 720: (insns->tme_recode_insn_conds_thunk == ic->tme_sparc_recode_conds_thunk_icc ! 721: ? 'i' ! 722: : insns->tme_recode_insn_conds_thunk == ic->tme_sparc_recode_conds_thunk_xcc ! 723: ? 'x' ! 724: : 'r'), ! 725: conds_integer ! 726: [insns->tme_recode_insn_operand_src[0] ! 727: + (TME_SPARC_COND_NOT ! 728: * (insns->tme_recode_insn_operand_src[1] != 0))], ! 729: insns->tme_recode_insn_operand_dst); ! 730: continue; ! 731: case TME_RECODE_OPCODE_IF: ! 732: printf("%s\t %%c%u\n", s, insns->tme_recode_insn_operand_src[0]); ! 733: continue; ! 734: case TME_RECODE_OPCODE_ELSE: ! 735: case TME_RECODE_OPCODE_ENDIF: ! 736: printf("%s\n", s); ! 737: continue; ! 738: case TME_RECODE_OPCODE_RW: ! 739: for (thunk_i = 0;; thunk_i++) { ! 740: assert (thunk_i < TME_ARRAY_ELS(ic->tme_sparc_recode_rw_thunks)); ! 741: if (insns->tme_recode_insn_rw_thunk == ic->tme_sparc_recode_rw_thunks[thunk_i]) { ! 742: break; ! 743: } ! 744: } ! 745: s = "?rw?"; ! 746: switch (thunk_i % 0x10) { ! 747: case 0x0: s = (TME_SPARC_VERSION(ic) >= 9 ? "lduw" : "ld"); break; ! 748: case 0x1: s = "ldub"; break; ! 749: case 0x2: s = "lduh"; break; ! 750: case 0x4: s = (TME_SPARC_VERSION(ic) >= 9 ? "stw" : "st"); break; ! 751: case 0x5: s = "stb"; break; ! 752: case 0x6: s = "sth"; break; ! 753: case 0x8: if (TME_SPARC_VERSION(ic) >= 9) { s = "ldsw"; } break; ! 754: case 0x9: s = "ldsb"; break; ! 755: case 0xa: s = "ldsh"; break; ! 756: case 0xb: if (TME_SPARC_VERSION(ic) >= 9) { s = "ldx"; } break; ! 757: case 0xe: if (TME_SPARC_VERSION(ic) >= 9) { s = "stx"; } break; ! 758: } ! 759: if (thunk_i & 16) { ! 760: printf("%s", s); ! 761: s = ".nf"; ! 762: } ! 763: if (thunk_i & 32) { ! 764: printf("%s", s); ! 765: s = ".el"; ! 766: } ! 767: if (thunk_i & 64) { ! 768: printf("%s", s); ! 769: s = ".am"; ! 770: } ! 771: insn_size = 0; ! 772: operands_mask = (1 << 0); ! 773: if (insns->tme_recode_insn_rw_thunk->tme_recode_rw_thunk_write) { ! 774: operands_mask |= (1 << 1); ! 775: } ! 776: else { ! 777: operands_mask |= (1 << 2); ! 778: } ! 779: break; ! 780: default: ! 781: operands_mask = (1 << 0) | (1 << 1) | (1 << 2); ! 782: break; ! 783: } ! 784: ! 785: printf("%s", s); ! 786: if (insn_size > 0) { ! 787: printf("%u", (1 << insns->tme_recode_insn_size)); ! 788: } ! 789: delim = '\t'; ! 790: for (operand_i = 0; operand_i <= 2; operand_i++) { ! 791: if (operands_mask & (1 << operand_i)) { ! 792: putchar(delim); ! 793: putchar(' '); ! 794: delim = ','; ! 795: switch (insns->tme_recode_insn_operands[operand_i]) { ! 796: case TME_RECODE_OPERAND_UNDEF: ! 797: s = "undef"; ! 798: break; ! 799: case TME_RECODE_OPERAND_IMM: ! 800: tme_recode_uguest_dump(insns->tme_recode_insn_imm_uguest); ! 801: continue; ! 802: #if TME_RECODE_OPERAND_NULL != TME_RECODE_OPERAND_ZERO ! 803: #error "TME_RECODE_OPERAND_ values changed" ! 804: #endif ! 805: case TME_RECODE_OPERAND_ZERO: ! 806: s = "g0"; ! 807: if (operand_i == 2 ! 808: && insns->tme_recode_insn_opcode == TME_RECODE_OPCODE_GUEST) { ! 809: s = "null"; ! 810: } ! 811: break; ! 812: case TME_SPARC_IREG_PC: s = "pc"; break; ! 813: case TME_SPARC_IREG_PC_NEXT: s = "pc_next"; break; ! 814: case TME_SPARC_IREG_PC_NEXT_NEXT: s = "pc_next_next"; break; ! 815: case TME_SPARC_IREG_INSN: s = "insn"; break; ! 816: case TME_SPARC_IREG_TMP(0): s = "tmp0"; break; ! 817: case TME_SPARC_IREG_TMP(1): s = "tmp1"; break; ! 818: case TME_SPARC_IREG_TMP(2): s = "tmp2"; break; ! 819: default: ! 820: if (insns->tme_recode_insn_operands[operand_i] < 32) { ! 821: printf("%%%c%u", ! 822: regcs[insns->tme_recode_insn_operands[operand_i] / 8], ! 823: (insns->tme_recode_insn_operands[operand_i] % 8)); ! 824: continue; ! 825: } ! 826: s = "??"; ! 827: break; ! 828: } ! 829: printf("%%%s", s); ! 830: } ! 831: } ! 832: ! 833: if (insns->tme_recode_insn_opcode < TME_RECODE_OPCODES_INTEGER ! 834: && insns->tme_recode_insn_flags_thunk != NULL) { ! 835: printf(", %%%s", ! 836: (TME_SPARC_VERSION(ic) < 9 ! 837: ? "icc" ! 838: : insns->tme_recode_insn_flags_thunk == ic->tme_sparc_recode_flags_thunk_rcc ! 839: ? "rcc" ! 840: : "ccr")); ! 841: } ! 842: ! 843: putchar('\n'); ! 844: } ! 845: ! 846: chain_info = ic->tme_sparc_recode_insns_group.tme_recode_insns_group_chain_info; ! 847: printf("chain %s %s ", ! 848: ((chain_info & TME_RECODE_CHAIN_INFO_JUMP) ! 849: ? "jump" ! 850: : (chain_info & TME_RECODE_CHAIN_INFO_RETURN) ! 851: ? "return" ! 852: : "call"), ! 853: (((chain_info ! 854: & (TME_RECODE_CHAIN_INFO_NEAR ! 855: | TME_RECODE_CHAIN_INFO_FAR)) ! 856: == TME_RECODE_CHAIN_INFO_NEAR) ! 857: ? "near" ! 858: : "far")); ! 859: if ((chain_info ! 860: & (TME_RECODE_CHAIN_INFO_UNCONDITIONAL ! 861: | TME_RECODE_CHAIN_INFO_CONDITIONAL)) ! 862: == TME_RECODE_CHAIN_INFO_UNCONDITIONAL) { ! 863: printf("unconditional\n"); ! 864: } ! 865: else { ! 866: printf("conditional alternate %s\n", ! 867: (((chain_info ! 868: & (TME_RECODE_CHAIN_INFO_ALTERNATE_NEAR ! 869: | TME_RECODE_CHAIN_INFO_ALTERNATE_FAR)) ! 870: == TME_RECODE_CHAIN_INFO_ALTERNATE_NEAR) ! 871: ? "near" ! 872: : "far")); ! 873: } ! 874: } ! 875: ! 876: #endif /* TME_RECODE_DEBUG */ ! 877: ! 878: #endif /* TME_HAVE_RECODE */ ! 879: ! 880: /* this initializes sparc recoding: */ ! 881: void ! 882: tme_sparc_recode_init(struct tme_sparc *ic) ! 883: { ! 884: #if TME_HAVE_RECODE ! 885: unsigned long reg_guest_count; ! 886: unsigned long reg_guest; ! 887: struct tme_recode_ic *recode_ic; ! 888: ! 889: /* get the number of guest registers: */ ! 890: reg_guest_count = TME_SPARC_IREG_TMP(3); ! 891: ! 892: /* allocate the recode ic: */ ! 893: recode_ic ! 894: = tme_malloc0(sizeof(struct tme_recode_ic) ! 895: + (sizeof(union tme_recode_reginfo) ! 896: * reg_guest_count)); ! 897: ic->tme_sparc_recode_ic = recode_ic; ! 898: ! 899: /* set the register size: */ ! 900: recode_ic->tme_recode_ic_reg_size = TME_SPARC_RECODE_SIZE(ic); ! 901: ! 902: /* set the register count: */ ! 903: recode_ic->tme_recode_ic_reg_count = reg_guest_count; ! 904: ! 905: /* allocate some number of read-uses records: */ ! 906: /* XXX FIXME - this can be anything, and doesn't affect correctness, ! 907: just performance. should it be tunable? */ ! 908: recode_ic->tme_recode_ic_reg_guest_ruses_record_count = 512; ! 909: recode_ic->tme_recode_ic_reg_guest_ruses_records ! 910: = tme_new(tme_uint16_t, ! 911: recode_ic->tme_recode_ic_reg_guest_ruses_record_count + 1); ! 912: recode_ic->tme_recode_ic_reg_guest_ruses_records ! 913: [recode_ic->tme_recode_ic_reg_guest_ruses_record_count] ! 914: = TME_RECODE_REG_RUSES_RECORD_UNDEF; ! 915: ! 916: /* assume that all registers use flat addressing: */ ! 917: for (reg_guest = 0; ! 918: reg_guest < reg_guest_count; ! 919: reg_guest++) { ! 920: (recode_ic->tme_recode_ic_reginfo ! 921: + reg_guest)->tme_recode_reginfo_all = TME_RECODE_REGINFO_TYPE_FLAT; ! 922: } ! 923: ! 924: /* %g0 is fixed: */ ! 925: (recode_ic->tme_recode_ic_reginfo ! 926: + TME_RECODE_REG_GUEST(TME_SPARC_IREG_G0))->tme_recode_reginfo_all ! 927: |= TME_RECODE_REGINFO_TYPE_FIXED; ! 928: ! 929: /* %r8 through %r23 are addressed through window zero, and %r24 ! 930: through %r31 are addressed through window one: */ ! 931: reg_guest = TME_RECODE_REG_GUEST(8); ! 932: do { ! 933: (recode_ic->tme_recode_ic_reginfo ! 934: + reg_guest)->tme_recode_reginfo_all = TME_RECODE_REGINFO_TYPE_WINDOW(0); ! 935: } while (++reg_guest <= TME_RECODE_REG_GUEST(23)); ! 936: do { ! 937: (recode_ic->tme_recode_ic_reginfo ! 938: + reg_guest)->tme_recode_reginfo_all = TME_RECODE_REGINFO_TYPE_WINDOW(1); ! 939: } while (++reg_guest <= TME_RECODE_REG_GUEST(31)); ! 940: ! 941: /* on a v9 CPU, %r1 through %r7 are addressed through window two: */ ! 942: if (TME_SPARC_VERSION(ic) >= 9) { ! 943: reg_guest = TME_RECODE_REG_GUEST(1); ! 944: do { ! 945: (recode_ic->tme_recode_ic_reginfo ! 946: + reg_guest)->tme_recode_reginfo_all = TME_RECODE_REGINFO_TYPE_WINDOW(2); ! 947: } while (++reg_guest <= TME_RECODE_REG_GUEST(7)); ! 948: } ! 949: ! 950: /* the temporary registers are temporary: */ ! 951: reg_guest = TME_RECODE_REG_GUEST(TME_SPARC_IREG_TMP(0)); ! 952: do { ! 953: (recode_ic->tme_recode_ic_reginfo ! 954: + reg_guest)->tme_recode_reginfo_all ! 955: |= TME_RECODE_REGINFO_TYPE_TEMPORARY; ! 956: } while (++reg_guest <= TME_RECODE_REG_GUEST(TME_SPARC_IREG_TMP(2))); ! 957: ! 958: /* set the window base offsets: */ ! 959: recode_ic->tme_recode_ic_window_base_offsets[0] ! 960: = (((char *) &ic->tme_sparc_recode_window_base_offsets[0]) - ((char *) ic)); ! 961: recode_ic->tme_recode_ic_window_base_offsets[1] ! 962: = (((char *) &ic->tme_sparc_recode_window_base_offsets[1]) - ((char *) ic)); ! 963: recode_ic->tme_recode_ic_window_base_offsets[2] ! 964: = (((char *) &ic->tme_sparc_recode_window_base_offsets[2]) - ((char *) ic)); ! 965: ! 966: /* initialize the cacheables: */ ! 967: ic->tme_sparc_recode_cacheables[0].tme_sparc_recode_cacheable_size = 0; ! 968: ic->tme_sparc_recode_cacheable_first = &ic->tme_sparc_recode_cacheables[0]; ! 969: ! 970: /* invalidate the entire source hash: */ ! 971: _tme_sparc_recode_src_hash_invalidate(ic, 0, 0); ! 972: ! 973: /* set the TLB page size: */ ! 974: recode_ic->tme_recode_ic_tlb_page_size ! 975: = (((tme_uint32_t) 1) << ic->tme_sparc_tlb_page_size_log2); ! 976: ! 977: /* set the pointer to the first instruction in a group: */ ! 978: ic->tme_sparc_recode_insns_group.tme_recode_insns_group_insns ! 979: = &ic->tme_sparc_recode_insns[0]; ! 980: ! 981: /* initialize the recode ic: */ ! 982: /* XXX FIXME - this run size should be passed in as an argument. it ! 983: needs to be big enough for the maximum number of non-variable ! 984: thunks (flags, conds, chain, etc.) that we will make, probably ! 985: TME_RECODE_HOST_THUNK_SIZE_MAX times some n? */ ! 986: tme_recode_ic_new(recode_ic, 4 * 1024 * 1024); ! 987: ! 988: /* call the architecture-specific init functions: */ ! 989: if (TME_SPARC_VERSION(ic) >= 9) { ! 990: #if TME_RECODE_SIZE_GUEST_MAX > TME_RECODE_SIZE_32 ! 991: _tme_sparc64_recode_cc_init(ic); ! 992: _tme_sparc64_recode_chain_init(ic); ! 993: _tme_sparc64_recode_ls_init(ic); ! 994: #endif /* TME_RECODE_SIZE_GUEST_MAX > TME_RECODE_SIZE_32 */ ! 995: } ! 996: else { ! 997: _tme_sparc32_recode_cc_init(ic); ! 998: _tme_sparc32_recode_chain_init(ic); ! 999: _tme_sparc32_recode_ls_init(ic); ! 1000: } ! 1001: ! 1002: #ifdef _TME_SPARC_RECODE_VERIFY ! 1003: ! 1004: /* initialize the verifier: */ ! 1005: _tme_sparc_recode_verify_init(ic); ! 1006: ! 1007: #endif /* _TME_SPARC_RECODE_VERIFY */ ! 1008: ! 1009: #else /* !TME_HAVE_RECODE */ ! 1010: /* unused: */ ! 1011: ic = 0; ! 1012: #endif /* !TME_HAVE_RECODE */ ! 1013: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.