Search
lxdream.org :: lxdream/src/sh4/xltcache.c
lxdream 0.9.1
released Jun 29
Download Now
filename src/sh4/xltcache.c
changeset 376:8c7587af5a5d
prev366:6fb0d05152d7
next383:f597b73474cb
author nkeynes
date Wed Sep 12 09:16:47 2007 +0000 (12 years ago)
permissions -rw-r--r--
last change Add disassembly dump function to xltcache
file annotate diff log raw
nkeynes@359
     1
/**
nkeynes@376
     2
 * $Id: xltcache.c,v 1.3 2007-09-12 09:16:47 nkeynes Exp $
nkeynes@359
     3
 * 
nkeynes@359
     4
 * Translation cache management. This part is architecture independent.
nkeynes@359
     5
 *
nkeynes@359
     6
 * Copyright (c) 2005 Nathan Keynes.
nkeynes@359
     7
 *
nkeynes@359
     8
 * This program is free software; you can redistribute it and/or modify
nkeynes@359
     9
 * it under the terms of the GNU General Public License as published by
nkeynes@359
    10
 * the Free Software Foundation; either version 2 of the License, or
nkeynes@359
    11
 * (at your option) any later version.
nkeynes@359
    12
 *
nkeynes@359
    13
 * This program is distributed in the hope that it will be useful,
nkeynes@359
    14
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
nkeynes@359
    15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
nkeynes@359
    16
 * GNU General Public License for more details.
nkeynes@359
    17
 */
nkeynes@359
    18
nkeynes@359
    19
#include "sh4/xltcache.h"
nkeynes@359
    20
#include "dreamcast.h"
nkeynes@359
    21
#include <sys/mman.h>
nkeynes@359
    22
#include <assert.h>
nkeynes@359
    23
nkeynes@359
    24
#define XLAT_LUT_PAGE_BITS 12
nkeynes@359
    25
#define XLAT_LUT_TOTAL_BITS 28
nkeynes@359
    26
#define XLAT_LUT_PAGE(addr) (((addr)>>13) & 0xFFFF)
nkeynes@359
    27
#define XLAT_LUT_ENTRY(addr) (((addr)&0x1FFE) >> 1)
nkeynes@359
    28
nkeynes@359
    29
#define XLAT_LUT_PAGES (1<<(XLAT_LUT_TOTAL_BITS-XLAT_LUT_PAGE_BITS))
nkeynes@359
    30
#define XLAT_LUT_PAGE_ENTRIES (1<<XLAT_LUT_PAGE_BITS)
nkeynes@359
    31
#define XLAT_LUT_PAGE_SIZE (XLAT_LUT_PAGE_ENTRIES * sizeof(void *))
nkeynes@359
    32
nkeynes@359
    33
#define XLAT_LUT_ENTRY_EMPTY (void *)0
nkeynes@359
    34
#define XLAT_LUT_ENTRY_USED  (void *)1
nkeynes@359
    35
nkeynes@359
    36
#define NEXT(block) ( (xlat_cache_block_t)&((block)->code[(block)->size]))
nkeynes@359
    37
#define BLOCK_FOR_CODE(code) (((xlat_cache_block_t)code)-1)
nkeynes@359
    38
#define IS_ENTRY_POINT(ent) (ent > XLAT_LUT_ENTRY_USED)
nkeynes@359
    39
#define IS_ENTRY_USED(ent) (ent != XLAT_LUT_ENTRY_EMPTY)
nkeynes@359
    40
nkeynes@359
    41
#define MIN_BLOCK_SIZE 32
nkeynes@359
    42
#define MIN_TOTAL_SIZE (sizeof(struct xlat_cache_block)+MIN_BLOCK_SIZE)
nkeynes@359
    43
nkeynes@359
    44
#define BLOCK_INACTIVE 0
nkeynes@359
    45
#define BLOCK_ACTIVE 1
nkeynes@359
    46
#define BLOCK_USED 2
nkeynes@359
    47
nkeynes@359
    48
xlat_cache_block_t xlat_new_cache;
nkeynes@359
    49
xlat_cache_block_t xlat_new_cache_ptr;
nkeynes@359
    50
xlat_cache_block_t xlat_new_create_ptr;
nkeynes@359
    51
xlat_cache_block_t xlat_temp_cache;
nkeynes@359
    52
xlat_cache_block_t xlat_temp_cache_ptr;
nkeynes@359
    53
xlat_cache_block_t xlat_old_cache;
nkeynes@359
    54
xlat_cache_block_t xlat_old_cache_ptr;
nkeynes@359
    55
static void ***xlat_lut;
nkeynes@359
    56
static void **xlat_lut2; /* second-tier page info */
nkeynes@376
    57
static gboolean xlat_initialized = FALSE;
nkeynes@359
    58
nkeynes@359
    59
void xlat_cache_init() 
nkeynes@359
    60
{
nkeynes@376
    61
    if( !xlat_initialized ) {
nkeynes@376
    62
	xlat_initialized = TRUE;
nkeynes@376
    63
	xlat_new_cache = mmap( NULL, XLAT_NEW_CACHE_SIZE, PROT_EXEC|PROT_READ|PROT_WRITE,
nkeynes@376
    64
			       MAP_PRIVATE|MAP_ANONYMOUS, -1, 0 );
nkeynes@376
    65
	xlat_temp_cache = mmap( NULL, XLAT_TEMP_CACHE_SIZE, PROT_EXEC|PROT_READ|PROT_WRITE,
nkeynes@376
    66
				MAP_PRIVATE|MAP_ANONYMOUS, -1, 0 );
nkeynes@376
    67
	xlat_old_cache = mmap( NULL, XLAT_OLD_CACHE_SIZE, PROT_EXEC|PROT_READ|PROT_WRITE,
nkeynes@376
    68
			       MAP_PRIVATE|MAP_ANONYMOUS, -1, 0 );
nkeynes@376
    69
	xlat_new_cache_ptr = xlat_new_cache;
nkeynes@376
    70
	xlat_temp_cache_ptr = xlat_temp_cache;
nkeynes@376
    71
	xlat_old_cache_ptr = xlat_old_cache;
nkeynes@376
    72
	xlat_new_create_ptr = xlat_new_cache;
nkeynes@376
    73
	
nkeynes@376
    74
	xlat_lut = mmap( NULL, XLAT_LUT_PAGES*sizeof(void *), PROT_READ|PROT_WRITE,
nkeynes@376
    75
			 MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
nkeynes@376
    76
	memset( xlat_lut, 0, XLAT_LUT_PAGES*sizeof(void *) );
nkeynes@376
    77
    }
nkeynes@359
    78
    xlat_flush_cache();
nkeynes@359
    79
}
nkeynes@359
    80
nkeynes@359
    81
/**
nkeynes@359
    82
 * Reset the cache structure to its default state
nkeynes@359
    83
 */
nkeynes@359
    84
void xlat_flush_cache() 
nkeynes@359
    85
{
nkeynes@359
    86
    xlat_cache_block_t tmp;
nkeynes@359
    87
    int i;
nkeynes@359
    88
    xlat_new_cache_ptr = xlat_new_cache;
nkeynes@359
    89
    xlat_new_cache_ptr->active = 0;
nkeynes@359
    90
    xlat_new_cache_ptr->size = XLAT_NEW_CACHE_SIZE - 2*sizeof(struct xlat_cache_block);
nkeynes@359
    91
    tmp = NEXT(xlat_new_cache_ptr);
nkeynes@359
    92
    tmp->active = 1;
nkeynes@359
    93
    tmp->size = 0;
nkeynes@359
    94
    xlat_temp_cache_ptr = xlat_temp_cache;
nkeynes@359
    95
    xlat_temp_cache_ptr->active = 0;
nkeynes@359
    96
    xlat_temp_cache_ptr->size = XLAT_TEMP_CACHE_SIZE - 2*sizeof(struct xlat_cache_block);
nkeynes@359
    97
    tmp = NEXT(xlat_temp_cache_ptr);
nkeynes@359
    98
    tmp->active = 1;
nkeynes@359
    99
    tmp->size = 0;
nkeynes@359
   100
    xlat_old_cache_ptr = xlat_old_cache;
nkeynes@359
   101
    xlat_old_cache_ptr->active = 0;
nkeynes@359
   102
    xlat_old_cache_ptr->size = XLAT_OLD_CACHE_SIZE - 2*sizeof(struct xlat_cache_block);
nkeynes@359
   103
    tmp = NEXT(xlat_old_cache_ptr);
nkeynes@359
   104
    tmp->active = 1;
nkeynes@359
   105
    tmp->size = 0;
nkeynes@359
   106
    for( i=0; i<XLAT_LUT_PAGES; i++ ) {
nkeynes@359
   107
	if( xlat_lut[i] != NULL ) {
nkeynes@359
   108
	    memset( xlat_lut[i], 0, XLAT_LUT_PAGE_SIZE );
nkeynes@359
   109
	}
nkeynes@359
   110
    }
nkeynes@359
   111
}
nkeynes@359
   112
nkeynes@359
   113
void xlat_flush_page( sh4addr_t address )
nkeynes@359
   114
{
nkeynes@359
   115
    int i;
nkeynes@359
   116
    void **page = xlat_lut[XLAT_LUT_PAGE(address)];
nkeynes@359
   117
    for( i=0; i<XLAT_LUT_PAGE_ENTRIES; i++ ) {
nkeynes@359
   118
	if( IS_ENTRY_POINT(page[i]) ) {
nkeynes@359
   119
	    BLOCK_FOR_CODE(page[i])->active = 0;
nkeynes@359
   120
	}
nkeynes@359
   121
	page[i] = NULL;
nkeynes@359
   122
    }
nkeynes@359
   123
}
nkeynes@359
   124
nkeynes@359
   125
void *xlat_get_code( sh4addr_t address )
nkeynes@359
   126
{
nkeynes@359
   127
    void **page = xlat_lut[XLAT_LUT_PAGE(address)];
nkeynes@359
   128
    if( page == NULL ) {
nkeynes@359
   129
	return NULL;
nkeynes@359
   130
    }
nkeynes@359
   131
    return page[XLAT_LUT_ENTRY(address)];
nkeynes@359
   132
}
nkeynes@359
   133
nkeynes@366
   134
uint32_t xlat_get_block_size( void *block )
nkeynes@366
   135
{
nkeynes@366
   136
    xlat_cache_block_t xlt = (xlat_cache_block_t)(((char *)block)-sizeof(struct xlat_cache_block));
nkeynes@366
   137
    return xlt->size;
nkeynes@366
   138
}
nkeynes@366
   139
nkeynes@359
   140
/**
nkeynes@359
   141
 * Cut the specified block so that it has the given size, with the remaining data
nkeynes@359
   142
 * forming a new free block. If the free block would be less than the minimum size,
nkeynes@359
   143
 * the cut is not performed.
nkeynes@359
   144
 * @return the next block after the (possibly cut) block.
nkeynes@359
   145
 */
nkeynes@359
   146
static inline xlat_cache_block_t xlat_cut_block( xlat_cache_block_t block, int cutsize )
nkeynes@359
   147
{
nkeynes@359
   148
    if( block->size > cutsize + MIN_TOTAL_SIZE ) {
nkeynes@359
   149
	int oldsize = block->size;
nkeynes@359
   150
	block->size = cutsize;
nkeynes@359
   151
	xlat_cache_block_t next = NEXT(block);
nkeynes@359
   152
	next->active = 0;
nkeynes@359
   153
	next->size = oldsize - cutsize - sizeof(struct xlat_cache_block);
nkeynes@359
   154
	return next;
nkeynes@359
   155
    } else {
nkeynes@359
   156
	return NEXT(block);
nkeynes@359
   157
    }
nkeynes@359
   158
}
nkeynes@359
   159
nkeynes@359
   160
/**
nkeynes@359
   161
 * Promote a block in temp space (or elsewhere for that matter) to old space.
nkeynes@359
   162
 *
nkeynes@359
   163
 * @param block to promote.
nkeynes@359
   164
 */
nkeynes@359
   165
static void xlat_promote_to_old_space( xlat_cache_block_t block )
nkeynes@359
   166
{
nkeynes@359
   167
    int allocation = -sizeof(struct xlat_cache_block);
nkeynes@359
   168
    int size = block->size;
nkeynes@359
   169
    xlat_cache_block_t curr = xlat_old_cache_ptr;
nkeynes@359
   170
    xlat_cache_block_t start_block = curr;
nkeynes@359
   171
    do {
nkeynes@359
   172
	allocation += curr->size + sizeof(struct xlat_cache_block);
nkeynes@359
   173
	curr = NEXT(curr);
nkeynes@359
   174
	if( allocation > size ) {
nkeynes@359
   175
	    break; /* done */
nkeynes@359
   176
	}
nkeynes@359
   177
	if( curr->size == 0 ) { /* End-of-cache Sentinel */
nkeynes@359
   178
	    /* Leave what we just released as free space and start again from the
nkeynes@359
   179
	     * top of the cache
nkeynes@359
   180
	     */
nkeynes@359
   181
	    start_block->active = 0;
nkeynes@359
   182
	    start_block->size = allocation;
nkeynes@359
   183
	    allocation = -sizeof(struct xlat_cache_block);
nkeynes@359
   184
	    start_block = curr = xlat_old_cache;
nkeynes@359
   185
	}
nkeynes@359
   186
    } while(1);
nkeynes@359
   187
    start_block->active = 1;
nkeynes@359
   188
    start_block->size = allocation;
nkeynes@359
   189
    start_block->lut_entry = block->lut_entry;
nkeynes@359
   190
    *block->lut_entry = &start_block->code;
nkeynes@359
   191
    memcpy( start_block->code, block->code, block->size );
nkeynes@359
   192
    xlat_old_cache_ptr = xlat_cut_block(start_block, size );
nkeynes@359
   193
    if( xlat_old_cache_ptr->size == 0 ) {
nkeynes@359
   194
	xlat_old_cache_ptr = xlat_old_cache;
nkeynes@359
   195
    }
nkeynes@359
   196
}
nkeynes@359
   197
nkeynes@359
   198
/**
nkeynes@359
   199
 * Similarly to the above method, promotes a block to temp space.
nkeynes@359
   200
 * TODO: Try to combine these - they're nearly identical
nkeynes@359
   201
 */
nkeynes@359
   202
void xlat_promote_to_temp_space( xlat_cache_block_t block )
nkeynes@359
   203
{
nkeynes@359
   204
    int size = block->size;
nkeynes@359
   205
    int allocation = -sizeof(struct xlat_cache_block);
nkeynes@359
   206
    xlat_cache_block_t curr = xlat_temp_cache_ptr;
nkeynes@359
   207
    xlat_cache_block_t start_block = curr;
nkeynes@359
   208
    do {
nkeynes@359
   209
	if( curr->active == BLOCK_USED ) {
nkeynes@359
   210
	    xlat_promote_to_old_space( curr );
nkeynes@359
   211
	}
nkeynes@359
   212
	allocation += curr->size + sizeof(struct xlat_cache_block);
nkeynes@359
   213
	curr = NEXT(curr);
nkeynes@359
   214
	if( allocation > size ) {
nkeynes@359
   215
	    break; /* done */
nkeynes@359
   216
	}
nkeynes@359
   217
	if( curr->size == 0 ) { /* End-of-cache Sentinel */
nkeynes@359
   218
	    /* Leave what we just released as free space and start again from the
nkeynes@359
   219
	     * top of the cache
nkeynes@359
   220
	     */
nkeynes@359
   221
	    start_block->active = 0;
nkeynes@359
   222
	    start_block->size = allocation;
nkeynes@359
   223
	    allocation = -sizeof(struct xlat_cache_block);
nkeynes@359
   224
	    start_block = curr = xlat_temp_cache;
nkeynes@359
   225
	}
nkeynes@359
   226
    } while(1);
nkeynes@359
   227
    start_block->active = 1;
nkeynes@359
   228
    start_block->size = allocation;
nkeynes@359
   229
    start_block->lut_entry = block->lut_entry;
nkeynes@359
   230
    *block->lut_entry = &start_block->code;
nkeynes@359
   231
    memcpy( start_block->code, block->code, block->size );
nkeynes@359
   232
    xlat_temp_cache_ptr = xlat_cut_block(start_block, size );
nkeynes@359
   233
    if( xlat_temp_cache_ptr->size == 0 ) {
nkeynes@359
   234
	xlat_temp_cache_ptr = xlat_temp_cache;
nkeynes@359
   235
    }
nkeynes@359
   236
    
nkeynes@359
   237
}
nkeynes@359
   238
nkeynes@359
   239
/**
nkeynes@359
   240
 * Returns the next block in the new cache list that can be written to by the
nkeynes@359
   241
 * translator. If the next block is active, it is evicted first.
nkeynes@359
   242
 */
nkeynes@359
   243
xlat_cache_block_t xlat_start_block( sh4addr_t address )
nkeynes@359
   244
{
nkeynes@359
   245
    if( xlat_new_cache_ptr->size == 0 ) {
nkeynes@359
   246
	xlat_new_cache_ptr = xlat_new_cache;
nkeynes@359
   247
    }
nkeynes@359
   248
nkeynes@359
   249
    if( xlat_new_cache_ptr->active ) {
nkeynes@359
   250
	xlat_promote_to_temp_space( xlat_new_cache_ptr );
nkeynes@359
   251
    }
nkeynes@359
   252
    xlat_new_create_ptr = xlat_new_cache_ptr;
nkeynes@359
   253
    xlat_new_create_ptr->active = 1;
nkeynes@359
   254
    xlat_new_cache_ptr = NEXT(xlat_new_cache_ptr);
nkeynes@359
   255
nkeynes@359
   256
    /* Add the LUT entry for the block */
nkeynes@359
   257
    if( xlat_lut[XLAT_LUT_PAGE(address)] == NULL ) {
nkeynes@359
   258
	xlat_lut[XLAT_LUT_PAGE(address)] =
nkeynes@359
   259
	    mmap( NULL, XLAT_LUT_PAGE_SIZE, PROT_READ|PROT_WRITE,
nkeynes@359
   260
		  MAP_PRIVATE|MAP_ANONYMOUS, -1, 0 );
nkeynes@359
   261
	memset( xlat_lut[XLAT_LUT_PAGE(address)], 0, XLAT_LUT_PAGE_SIZE );
nkeynes@359
   262
    }
nkeynes@359
   263
nkeynes@359
   264
    if( IS_ENTRY_POINT(xlat_lut[XLAT_LUT_PAGE(address)][XLAT_LUT_ENTRY(address)]) ) {
nkeynes@359
   265
	xlat_cache_block_t oldblock = BLOCK_FOR_CODE(xlat_lut[XLAT_LUT_PAGE(address)][XLAT_LUT_ENTRY(address)]);
nkeynes@359
   266
	oldblock->active = 0;
nkeynes@359
   267
    }
nkeynes@359
   268
nkeynes@359
   269
    xlat_lut[XLAT_LUT_PAGE(address)][XLAT_LUT_ENTRY(address)] = 
nkeynes@359
   270
	&xlat_new_create_ptr->code;
nkeynes@359
   271
    xlat_new_create_ptr->lut_entry = xlat_lut[XLAT_LUT_PAGE(address)] + XLAT_LUT_ENTRY(address);
nkeynes@359
   272
    
nkeynes@359
   273
    return xlat_new_create_ptr;
nkeynes@359
   274
}
nkeynes@359
   275
nkeynes@359
   276
xlat_cache_block_t xlat_extend_block()
nkeynes@359
   277
{
nkeynes@359
   278
    if( xlat_new_cache_ptr->size == 0 ) {
nkeynes@359
   279
	/* Migrate to the front of the cache to keep it contiguous */
nkeynes@359
   280
	xlat_new_create_ptr->active = 0;
nkeynes@359
   281
	char *olddata = xlat_new_create_ptr->code;
nkeynes@359
   282
	int oldsize = xlat_new_create_ptr->size;
nkeynes@359
   283
	int size = oldsize + MIN_BLOCK_SIZE; /* minimum expansion */
nkeynes@359
   284
	void **lut_entry = xlat_new_create_ptr->lut_entry;
nkeynes@359
   285
	int allocation = -sizeof(struct xlat_cache_block);
nkeynes@359
   286
	xlat_new_cache_ptr = xlat_new_cache;
nkeynes@359
   287
	do {
nkeynes@359
   288
	    if( xlat_new_cache_ptr->active ) {
nkeynes@359
   289
		xlat_promote_to_temp_space( xlat_new_cache_ptr );
nkeynes@359
   290
	    }
nkeynes@359
   291
	    allocation += xlat_new_cache_ptr->size + sizeof(struct xlat_cache_block);
nkeynes@359
   292
	    xlat_new_cache_ptr = NEXT(xlat_new_cache_ptr);
nkeynes@359
   293
	} while( allocation < size );
nkeynes@359
   294
	xlat_new_create_ptr = xlat_new_cache;
nkeynes@359
   295
	xlat_new_create_ptr->active = 1;
nkeynes@359
   296
	xlat_new_create_ptr->size = allocation;
nkeynes@359
   297
	xlat_new_create_ptr->lut_entry = lut_entry;
nkeynes@359
   298
	*lut_entry = &xlat_new_create_ptr->code;
nkeynes@359
   299
	memmove( xlat_new_create_ptr->code, olddata, oldsize );
nkeynes@359
   300
    } else {
nkeynes@359
   301
	if( xlat_new_cache_ptr->active ) {
nkeynes@359
   302
	    xlat_promote_to_temp_space( xlat_new_cache_ptr );
nkeynes@359
   303
	}
nkeynes@359
   304
	xlat_new_create_ptr->size += xlat_new_cache_ptr->size + sizeof(struct xlat_cache_block);
nkeynes@359
   305
	xlat_new_cache_ptr = NEXT(xlat_new_cache_ptr);
nkeynes@359
   306
    }
nkeynes@359
   307
    return xlat_new_create_ptr;
nkeynes@359
   308
nkeynes@359
   309
}
nkeynes@359
   310
nkeynes@359
   311
void xlat_commit_block( uint32_t destsize, uint32_t srcsize )
nkeynes@359
   312
{
nkeynes@359
   313
    void **ptr = xlat_new_create_ptr->lut_entry;
nkeynes@359
   314
    void **endptr = ptr + (srcsize>>2);
nkeynes@359
   315
    while( ptr < endptr ) {
nkeynes@359
   316
	if( *ptr == NULL ) {
nkeynes@359
   317
	    *ptr = XLAT_LUT_ENTRY_USED;
nkeynes@359
   318
	}
nkeynes@359
   319
	ptr++;
nkeynes@359
   320
    }
nkeynes@359
   321
nkeynes@359
   322
    xlat_new_cache_ptr = xlat_cut_block( xlat_new_create_ptr, destsize );
nkeynes@359
   323
}
nkeynes@359
   324
nkeynes@359
   325
void xlat_delete_block( xlat_cache_block_t block ) 
nkeynes@359
   326
{
nkeynes@359
   327
    block->active = 0;
nkeynes@359
   328
    *block->lut_entry = NULL;
nkeynes@359
   329
}
nkeynes@359
   330
nkeynes@359
   331
void xlat_check_cache_integrity( xlat_cache_block_t cache, xlat_cache_block_t ptr, int size )
nkeynes@359
   332
{
nkeynes@359
   333
    int foundptr = 0;
nkeynes@359
   334
    xlat_cache_block_t tail = 
nkeynes@359
   335
	(xlat_cache_block_t)(((char *)cache) + size - sizeof(struct xlat_cache_block));
nkeynes@359
   336
nkeynes@359
   337
    assert( tail->active == 1 );
nkeynes@359
   338
    assert( tail->size == 0 ); 
nkeynes@359
   339
    while( cache < tail ) {
nkeynes@359
   340
	assert( cache->active >= 0 && cache->active <= 2 );
nkeynes@359
   341
	assert( cache->size >= 0 && cache->size < size );
nkeynes@359
   342
	if( cache == ptr ) {
nkeynes@359
   343
	    foundptr = 1;
nkeynes@359
   344
	}
nkeynes@359
   345
	cache = NEXT(cache);
nkeynes@359
   346
    }
nkeynes@359
   347
    assert( cache == tail );
nkeynes@359
   348
    assert( foundptr == 1 );
nkeynes@359
   349
}
nkeynes@359
   350
nkeynes@359
   351
void xlat_check_integrity( )
nkeynes@359
   352
{
nkeynes@359
   353
    xlat_check_cache_integrity( xlat_new_cache, xlat_new_cache_ptr, XLAT_NEW_CACHE_SIZE );
nkeynes@359
   354
    xlat_check_cache_integrity( xlat_temp_cache, xlat_temp_cache_ptr, XLAT_TEMP_CACHE_SIZE );
nkeynes@359
   355
    xlat_check_cache_integrity( xlat_old_cache, xlat_old_cache_ptr, XLAT_OLD_CACHE_SIZE );
nkeynes@359
   356
}
nkeynes@376
   357
nkeynes@376
   358
nkeynes@376
   359
void xlat_disasm_block( FILE *out, void *block )
nkeynes@376
   360
{
nkeynes@376
   361
    uint32_t buflen = xlat_get_block_size(block);
nkeynes@376
   362
    x86_set_symtab( NULL, 0 );
nkeynes@376
   363
    x86_disasm_block( out, block, buflen );
nkeynes@376
   364
}
.