//sdRef returned by DNSServiceRegister()
DNSServiceErrorType DNSSD_API DNSServiceAddRecord
(
DNSServiceRef sdRef,
DNSRecordRef *RecordRef,
DNSServiceFlags flags,
uint16_t rrtype,
uint16_t rdlen,
const void *rdata,
uint32_t ttl
)
{
ipc_msg_hdr *hdr;
size_t len = 0;
char *ptr;
DNSRecordRef rref;
if (!sdRef || (sdRef->op != reg_service_request) || !RecordRef)
return kDNSServiceErr_BadReference;
*RecordRef = NULL;
len += 2 * sizeof(uint16_t); //rrtype, rdlen
len += rdlen;
len += sizeof(uint32_t);
len += sizeof(DNSServiceFlags);
hdr = create_hdr(add_record_request, &len, &ptr, 0);
if (!hdr) return kDNSServiceErr_Unknown;
put_flags(flags, &ptr);
put_short(rrtype, &ptr);
put_short(rdlen, &ptr);
put_rdata(rdlen, rdata, &ptr);
put_long(ttl, &ptr);
rref = malloc(sizeof(_DNSRecordRef_t));
if (!rref) goto error;
rref->app_context = NULL;
rref->app_callback = NULL;
rref->record_index = sdRef->max_index++;
rref->sdr = sdRef;
*RecordRef = rref;
hdr->client_context.context = rref;
hdr->reg_index = rref->record_index;
return deliver_request((char *)hdr, sdRef, 0);
error:
if (hdr) free(hdr);
if (rref) free(rref);
if (*RecordRef) *RecordRef = NULL;
return kDNSServiceErr_Unknown;
}
bool UAECALL uae_ppc_io_mem_write(uint32_t addr, uint32_t data, int size)
{
bool locked = false;
while (ppc_thread_running && ppc_cpu_lock_state < 0 && ppc_state);
#if PPC_ACCESS_LOG > 0 && PPC_ACCESS_LOG < 2
if (!valid_address(addr, size)) {
if (addr >= PPC_DEBUG_ADDR_FROM && addr < PPC_DEBUG_ADDR_TO)
write_log(_T("PPC io write %08x = %08x %d\n"), addr, data, size);
}
#endif
locked = spinlock_pre(addr);
switch (size)
{
case 4:
put_long(addr, data);
break;
case 2:
put_word(addr, data);
break;
case 1:
put_byte(addr, data);
break;
}
if (addr >= 0xdff000 && addr < 0xe00000) {
int reg = addr & 0x1fe;
switch (reg) {
case 0x09c: // INTREQ
case 0x09a: // INTENA
if (data & 0x8000) {
// possible interrupt change:
// make sure M68K thread reacts to it ASAP.
uae_int_requested |= 0x010000;
}
break;
}
}
spinlock_post(locked);
#if PPC_ACCESS_LOG >= 2
write_log(_T("PPC write %08x = %08x %d\n"), addr, data, size);
#endif
return true;
}
//----------------------------------------------------------------------
static void process_loader(char *ptr, pef_section_t *sec, int nsec) {
int i;
pef_loader_t &pl = *(pef_loader_t *)ptr;
pef_library_t *pil = (pef_library_t *)(&pl + 1);
swap_pef_loader(pl);
uint32 *impsym = (uint32 *)(pil + pl.importLibraryCount);
pef_reloc_header_t *prh =
(pef_reloc_header_t *)(impsym + pl.totalImportedSymbolCount);
uint16 *relptr = (uint16 *)(ptr + pl.relocInstrOffset);
uint32 *hash = (uint32 *)(ptr + pl.exportHashOffset);
uint32 hashsize = (1 << pl.exportHashTablePower);
uint32 *keytable = hash + hashsize;
pef_export_t *pe = (pef_export_t *)(keytable + pl.exportedSymbolCount);
#if !__MF__
for ( i=0; i < pl.importLibraryCount; i++ )
swap_pef_library(pil[i]);
for ( i=0; i < pl.relocSectionCount; i++ )
swap_pef_reloc_header(prh[i]);
for ( i=0; i < pl.exportedSymbolCount; i++ )
swap_pef_export(pe[i]);
#endif
char *stable = ptr + pl.loaderStringsOffset;
if ( pl.totalImportedSymbolCount != 0 ) {
uint32 size = pl.totalImportedSymbolCount*4;
ea_t undef = freechunk(inf.maxEA, size, -0xF);
ea_t end = undef + size;
set_selector(nsec+1, 0);
if(!add_segm(nsec+1, undef, end, "IMPORT", "XTRN")) loader_failure();
for ( i=0; i < pl.importLibraryCount; i++ ) {
ea_t ea = undef + 4*pil[i].firstImportedSymbol;
add_long_cmt(ea, 1, "Imports from library %s", stable+pil[i].nameOffset);
if ( pil[i].options & PEF_LIB_WEAK )
add_long_cmt(ea, 1, "Library is weak");
}
inf.specsegs = 1;
for ( i=0; i < pl.totalImportedSymbolCount; i++ ) {
uint32 sym = mflong(impsym[i]);
uchar sclass = uchar(sym >> 24);
ea_t ea = undef+4*i;
set_name(ea, get_impsym_name(stable,impsym,i));
if ( (sclass & kPEFWeak) != 0 ) make_name_weak(ea);
doDwrd(ea,4);
put_long(ea, 0);
impsym[i] = (uint32)ea;
}
}
static uae_u32 scsidev_open (void)
{
uaecptr tmp1 = m68k_areg (regs, 1); /* IOReq */
uae_u32 unit = m68k_dreg (regs, 0);
struct scsidevdata *sdd;
#ifdef DEBUGME
printf("scsidev_open(0x%x, %d)\n", tmp1, unit);
#endif
/* Check unit number */
if ((sdd = get_scsidev_data (unit)) && start_thread (sdd)) {
opencount++;
put_word (m68k_areg (regs, 6)+32, get_word (m68k_areg (regs, 6)+32) + 1);
put_long (tmp1 + 24, unit); /* io_Unit */
put_byte (tmp1 + 31, 0); /* io_Error */
put_byte (tmp1 + 8, 7); /* ln_type = NT_REPLYMSG */
return 0;
}
put_long (tmp1 + 20, (uae_u32)-1);
put_byte (tmp1 + 31, (uae_u8)-1);
return (uae_u32)-1;
}
static uint32_t REGPARAM2 dev_close (TrapContext *context)
{
uint32_t request = m68k_areg (regs, 1);
struct devstruct *dev;
dev = getdevstruct (get_long (request + 24));
if (!dev)
return 0;
if (log_uaeserial)
write_log (_T("%s:%d close, req=%x\n"), getdevname(), dev->unit, request);
dev_close_3 (dev);
put_long (request + 24, 0);
put_word (m68k_areg (regs, 6) + 32, get_word (m68k_areg (regs, 6) + 32) - 1);
return 0;
}
static uint32_t REGPARAM2 dev_open (TrapContext *context)
{
uaecptr ioreq = m68k_areg (regs, 1);
uint32_t unit = m68k_dreg (regs, 0);
uint32_t flags = m68k_dreg (regs, 1);
struct devstruct *dev;
int32_t i, err;
if (get_word (ioreq + 0x12) < IOSTDREQ_SIZE)
return openfail (ioreq, IOERR_BADLENGTH);
for (i = 0; i < MAX_TOTAL_DEVICES; i++) {
if (devst[i].open && devst[i].unit == (int32_t)unit && devst[i].exclusive)
return openfail (ioreq, IOERR_UNITBUSY);
}
for (i = 0; i < MAX_TOTAL_DEVICES; i++) {
if (!devst[i].open)
break;
}
if (i == MAX_TOTAL_DEVICES)
return openfail (ioreq, IOERR_OPENFAIL);
dev = &devst[i];
dev->sysdata = xcalloc (uint8_t, uaeser_getdatalength ());
if (!uaeser_open (dev->sysdata, dev, unit)) {
xfree (dev->sysdata);
return openfail (ioreq, IOERR_OPENFAIL);
}
dev->unit = unit;
dev->open = 1;
dev->uniq = ++uniq;
dev->exclusive = (get_word (ioreq + io_SerFlags) & SERF_SHARED) ? 0 : 1;
put_long (ioreq + 24, dev->uniq);
resetparams (dev, ioreq);
err = setparams (dev, ioreq);
if (err) {
uaeser_close (dev->sysdata);
dev->open = 0;
xfree (dev->sysdata);
return openfail (ioreq, err);
}
if (log_uaeserial)
write_log (_T("%s:%d open ioreq=%08X\n"), getdevname(), unit, ioreq);
start_thread (dev);
put_word (m68k_areg (regs, 6) + 32, get_word (m68k_areg (regs, 6) + 32) + 1);
put_byte (ioreq + 31, 0);
put_byte (ioreq + 8, 7);
return 0;
}
void ScuLoadState (linput_t *li, ea_t *pc, int size)
{
scuregs_struct Scu;
scudspregs_struct ScuDsp;
qlread(li, (void *)&Scu, sizeof(Scu));
qlread(li, (void *)&ScuDsp, sizeof(ScuDsp));
if (pc)
{
*pc = ScuDsp.PC;
ea_t start=0, end=0x100;
add_segm(0, start, end, "RAM", "");
for (ea_t i = 0; i < end-start; i++)
put_long(start+i, ScuDsp.ProgramRam[i]);
}
}
static void resetparams (struct devstruct *dev, uaecptr req)
{
put_long (req + io_CtlChar, 0x00001311);
put_long (req + io_RBufLen, 1024);
put_long (req + io_ExtFlags, 0);
put_long (req + io_Baud, 9600);
put_long (req + io_BrkTime, 250000);
put_long (req + io_TermArray0, 0);
put_long (req + io_TermArray1, 0);
put_byte (req + io_ReadLen, 8);
put_byte (req + io_WriteLen, 8);
put_byte (req + io_StopBits, 1);
put_byte (req + io_SerFlags, get_byte (req + io_SerFlags) & (SERF_XDISABLED | SERF_SHARED | SERF_7WIRE));
put_word (req + io_Status, 0);
}
bool UAECALL uae_ppc_io_mem_write64(uint32_t addr, uint64_t data)
{
bool locked = false;
while (ppc_thread_running && ppc_cpu_lock_state < 0 && ppc_state);
locked = spinlock_pre(addr);
put_long(addr + 0, data >> 32);
put_long(addr + 4, data & 0xffffffff);
spinlock_post(locked);
#if PPC_ACCESS_LOG >= 2
write_log(_T("PPC mem write64 %08x = %08llx\n"), addr, data);
#endif
return true;
}
static void put_hack( void )
/*
** Outputs the long values making up the new hunk to the destination file.
*/
{
long i, hack[HACKLEN+2] =
{
1009, /* HUNK_DEBUG */
HACKLEN, /* size in longwords */
0x00245645, 0x523a2042, /* '\0$VER: Bio v?.? (1990,1992)\0' */
0x696f2076, 0x3f2e3f20,
0x28313939, 0x302c3139,
0x39322900
};
for( i = 0; i < HACKLEN + 2; i++ )
put_long( hack[i] );
}
static uae_u32 REGPARAM2 dev_close_2 (TrapContext *context)
{
uae_u32 request = m68k_areg (&context->regs, 1);
struct priv_devstruct *pdev = getpdevstruct (request);
struct devstruct *dev;
if (!pdev)
return 0;
dev = getdevstruct (pdev->unit);
if (log_scsi)
write_log ("%s:%d close, req=%08.8X\n", getdevname (pdev->type), pdev->unit, request);
if (!dev)
return 0;
dev_close_3 (dev, pdev);
put_long (request + 24, 0);
put_word (m68k_areg (&context->regs, 6) + 32, get_word (m68k_areg (&context->regs, 6) + 32) - 1);
return 0;
}
static void do_stack_magic (TrapFunction f, void *s, int has_retval)
{
#ifdef CAN_DO_STACK_MAGIC
uaecptr a7;
jmp_buf *j = (jmp_buf *)s;
switch (setjmp (j[0])) {
case 0:
/* Returning directly */
current_extra_stack = s;
if (has_retval == -1) {
/*write_log ("finishing m68k mode return\n");*/
longjmp (j[1], 1);
}
/*write_log ("calling native function\n");*/
transfer_control (s, EXTRA_STACK_SIZE, stack_stub, f, has_retval);
/* not reached */
return;
case 1:
/*write_log ("native function complete\n");*/
/* Returning normally. */
if (stack_has_retval (s, EXTRA_STACK_SIZE))
_68k_dreg (0) = get_retval_from_stack (s, EXTRA_STACK_SIZE);
free_extra_stack (s);
break;
case 2:
/* Returning to do a m68k call. We're now back on the main stack. */
a7 = _68k_areg(7) -= (sizeof (void *) + 7) & ~3;
/* Save stack to restore */
*((void **)get_real_address (a7 + 4)) = s;
/* Save special return address: this address contains a
* calltrap that will longjmp to the right stack. */
put_long (_68k_areg (7), RTAREA_BASE + 0xFF00);
_68k_setpc (m68k_calladdr);
fill_prefetch_0 ();
/*write_log ("native function calls m68k\n");*/
break;
}
current_extra_stack = 0;
#endif
}
/* Ugly hack for >2M chip RAM in single pool
* We can't add it any later or early boot menu
* stops working because it sets kicktag at the end
* of chip ram...
*/
static void addextrachip (uae_u32 sysbase)
{
if (currprefs.chipmem_size <= 0x00200000)
return;
if (sysbase & 0x80000001)
return;
if (!valid_address (sysbase, 1000))
return;
uae_u32 ml = get_long (sysbase + 322);
if (!valid_address (ml, 32))
return;
uae_u32 next;
while ((next = get_long (ml))) {
if (!valid_address (ml, 32))
return;
uae_u32 upper = get_long (ml + 24);
uae_u32 lower = get_long (ml + 20);
if (lower & ~0xffff) {
ml = next;
continue;
}
uae_u16 attr = get_word (ml + 14);
if ((attr & 0x8002) != 2) {
ml = next;
continue;
}
if (upper >= currprefs.chipmem_size)
return;
uae_u32 added = currprefs.chipmem_size - upper;
uae_u32 first = get_long (ml + 16);
put_long (ml + 24, currprefs.chipmem_size); // mh_Upper
put_long (ml + 28, get_long (ml + 28) + added); // mh_Free
uae_u32 next;
while (first) {
next = first;
first = get_long (next);
}
uae_u32 bytes = get_long (next + 4);
if (next + bytes == 0x00200000) {
put_long (next + 4, currprefs.chipmem_size - next);
} else {
put_long (0x00200000 + 0, 0);
put_long (0x00200000 + 4, added);
put_long (next, 0x00200000);
}
return;
}
}
/*
* Gets UAE Configuration
*/
static uae_u32 emulib_GetUaeConfig (uaecptr place)
{
int i;
put_long (place, UAEVERSION);
put_long (place + 4, allocated_chipmem);
put_long (place + 8, allocated_bogomem);
put_long (place + 12, allocated_fastmem);
put_long (place + 16, currprefs.gfx_framerate);
put_long (place + 20, currprefs.produce_sound);
put_long (place + 24, currprefs.jport0 | (currprefs.jport1 << 8));
put_long (place + 28, currprefs.keyboard_lang);
if (disk_empty (0))
put_byte (place + 32, 0);
else
put_byte (place + 32, 1);
if (disk_empty (1))
put_byte (place + 33, 0);
else
put_byte (place + 33, 1);
if (disk_empty(2))
put_byte (place + 34, 0);
else
put_byte (place + 34, 1);
if (disk_empty(3))
put_byte (place + 35, 0);
else
put_byte (place + 35, 1);
for (i = 0; i < 256; i++) {
put_byte ((place + 36 + i), currprefs.df[0][i]);
put_byte ((place + 36 + i + 256), currprefs.df[1][i]);
put_byte ((place + 36 + i + 512), currprefs.df[2][i]);
put_byte ((place + 36 + i + 768), currprefs.df[3][i]);
}
return 1;
}
void trap_put_longs(TrapContext *ctx, uae_u32 *haddr, uaecptr addr, int cnt)
{
if (cnt <= 0)
return;
if (trap_is_indirect_null(ctx)) {
while (cnt > 0) {
int max = cnt > RTAREA_TRAP_DATA_EXTRA_SIZE / sizeof(uae_u32) ? RTAREA_TRAP_DATA_EXTRA_SIZE / sizeof(uae_u32) : cnt;
for (int i = 0; i < max; i++) {
put_long_host(ctx->host_trap_data + RTAREA_TRAP_DATA_EXTRA + i * sizeof(uae_u32), *haddr++);
}
call_hardware_trap_back(ctx, TRAPCMD_PUT_LONGS, ctx->amiga_trap_data + RTAREA_TRAP_DATA_EXTRA, addr, max, 0);
addr += max * sizeof(uae_u32);
cnt -= max;
}
} else {
uae_u32 *p = (uae_u32*)haddr;
for (int i = 0; i < cnt; i++) {
put_long(addr, *p++);
addr += 4;
}
}
}
DNSServiceErrorType DNSSD_API DNSServiceReconfirmRecord
(
DNSServiceFlags flags,
uint32_t interfaceIndex,
const char *fullname,
uint16_t rrtype,
uint16_t rrclass,
uint16_t rdlen,
const void *rdata
)
{
char *ptr;
size_t len;
ipc_msg_hdr *hdr;
DNSServiceRef tmp;
len = sizeof(DNSServiceFlags);
len += sizeof(uint32_t);
len += strlen(fullname) + 1;
len += 3 * sizeof(uint16_t);
len += rdlen;
tmp = connect_to_server();
if (!tmp) return(kDNSServiceErr_Unknown);
hdr = create_hdr(reconfirm_record_request, &len, &ptr, 1);
if (!hdr) return(kDNSServiceErr_Unknown);
put_flags(flags, &ptr);
put_long(interfaceIndex, &ptr);
put_string(fullname, &ptr);
put_short(rrtype, &ptr);
put_short(rrclass, &ptr);
put_short(rdlen, &ptr);
put_rdata(rdlen, rdata, &ptr);
ConvertHeaderBytes(hdr);
write_all(tmp->sockfd, (char *)hdr, (int) len);
free(hdr);
DNSServiceRefDeallocate(tmp);
return(kDNSServiceErr_NoError);
}
static void do_stack_magic (TrapFunction f, struct extra_stack *s, int has_retval)
{
switch (setjmp (s->stackswap_env)) {
case 0:
/* Returning directly */
current_extra_stack = s;
if (has_retval == -1) {
/*write_log ("finishing m68k mode return\n");*/
longjmp (s->m68kcall_env, 1);
}
/*write_log ("calling native function\n");*/
transfer_control (s, EXTRA_STACK_SIZE, stack_stub, f, has_retval);
/* not reached */
abort ();
case 1:
/*write_log ("native function complete\n");*/
/* Returning normally. */
if (stack_has_retval (s, EXTRA_STACK_SIZE))
m68k_dreg (regs, 0) = get_retval_from_stack (s, EXTRA_STACK_SIZE);
free_extra_stack (s);
break;
case 2: {
/* Returning to do a m68k call. We're now back on the main stack. */
uaecptr a7 = m68k_areg (regs, 7) -= (sizeof (void *) + 7) & ~3;
/* Save stack to restore */
*((void **)get_real_address (a7 + 4)) = s;
/* Save special return address: this address contains a
* calltrap that will longjmp to the right stack. */
put_long (m68k_areg (regs, 7), RTAREA_BASE + 0xFF00);
m68k_setpc (s->m68kcall_addr);
fill_prefetch_slow ();
/*write_log ("native function calls m68k\n");*/
break;
}
}
current_extra_stack = 0;
}
static uae_u32 REGPARAM2 dev_close_2 (TrapContext *context)
{
uae_u32 request = m68k_areg (regs, 1);
struct priv_s2devstruct *pdev = getps2devstruct (request);
struct s2devstruct *dev;
if (!pdev) {
write_log (_T("%s close with unknown request %08X!?\n"), SANA2NAME, request);
return 0;
}
dev = gets2devstruct (pdev->unit);
if (!dev) {
write_log (_T("%s:%d close with unknown request %08X!?\n"), SANA2NAME, pdev->unit, request);
return 0;
}
if (log_net)
write_log (_T("%s:%d close, open=%d req=%08X\n"), SANA2NAME, pdev->unit, dev->opencnt, request);
put_long (request + 24, 0);
dev->opencnt--;
pdev->inuse = 0;
if (!dev->opencnt) {
dev->exclusive = 0;
if (pdev->tempbuf) {
m68k_areg (regs, 1) = pdev->tempbuf;
m68k_dreg (regs, 0) = pdev->td->mtu + ETH_HEADER_SIZE + 2;
CallLib (context, get_long (4), -0xD2); /* FreeMem */
pdev->tempbuf = 0;
}
ethernet_close (pdev->td, dev->sysdata);
xfree (dev->sysdata);
dev->sysdata = NULL;
write_comm_pipe_u32 (&dev->requests, 0, 1);
write_log (_T("%s: opencnt == 0, all instances closed\n"), SANA2NAME);
}
put_word (m68k_areg (regs, 6) + 32, get_word (m68k_areg (regs, 6) + 32) - 1);
return 0;
}
void main( int argc, char *argv[] )
{
/* Make sure we were called correctly */
if( argc != 3 )
{
printf( "Usage: %s <in> <out>\n", argv[0] );
exit( 5 );
}
/* Try to open the input file */
if( in = fopen( argv[1], "rb" ) )
{
/* Try to open the output file */
if( out = fopen( argv[2], "wb" ) )
{
long val, i;
/* Output the HUNK_HEADER hunk found at the start of the file */
put_long( get_long() ); /* HUNK_HEADER */
put_long( get_long() ); /* # of res libs (0) */
put_long( val = get_long() ); /* # of hunks in file */
put_long( get_long() ); /* first slot */
put_long( get_long() ); /* last slot */
/* Now output the sizes of all the hunks, in order */
put_long( get_long() + 1 ); /* new size of 1st hunk */
for( i = 0; i < val-1; i++ )
put_long( get_long() );
/* Finally, output the rest of the file */
put_rest();
fclose( out );
}
fclose( in );
}
}
void long_div(value *sp) {
put_long(sp+2, longint_divop(get_long(sp+2), get_long(sp), 1));
}
void long_mul(value *sp) {
put_long(sp+2, get_long(sp+2) * get_long(sp));
}
void long_sub(value *sp) {
put_long(sp+2, get_long(sp+2) - get_long(sp));
}
void long_add(value *sp) {
put_long(sp+2, get_long(sp+2) + get_long(sp));
}
void long_ext(value *sp) {
put_long(sp-1, (longint) sp[0].i);
}
void long_neg(value *sp) {
put_long(sp, -get_long(sp));
}
void long_mod(value *sp) {
put_long(sp+2, longint_divop(get_long(sp+2), get_long(sp), 0));
}
static void ersatz_init (void)
{
int f;
uaecptr request;
uaecptr a;
already_failed = 0;
write_log ("initializing kickstart replacement\n");
if (disk_empty (0)) {
already_failed = 1;
notify_user (NUMSG_KICKREP);
uae_restart (-1, NULL);
return;
}
regs.s = 0;
/* Set some interrupt vectors */
for (a = 8; a < 0xC0; a += 4) {
put_long (a, 0xF8001A);
}
regs.isp = regs.msp = regs.usp = 0x800;
m68k_areg(®s, 7) = 0x80000;
regs.intmask = 0;
/* Build a dummy execbase */
put_long (4, m68k_areg(®s, 6) = 0x676);
put_byte (0x676 + 0x129, 0);
for (f = 1; f < 105; f++) {
put_word (0x676 - 6*f, 0x4EF9);
put_long (0x676 - 6*f + 2, 0xF8000C);
}
/* Some "supported" functions */
put_long (0x676 - 456 + 2, 0xF80014);
put_long (0x676 - 216 + 2, 0xF80020);
put_long (0x676 - 198 + 2, 0xF80026);
put_long (0x676 - 204 + 2, 0xF8002c);
put_long (0x676 - 210 + 2, 0xF8002a);
/* Build an IORequest */
request = 0x800;
put_word (request + 0x1C, 2);
put_long (request + 0x28, 0x4000);
put_long (request + 0x2C, 0);
put_long (request + 0x24, 0x200 * 4);
m68k_areg(®s, 1) = request;
ersatz_doio ();
/* kickstart disk loader */
if (get_long(0x4000) == 0x4b49434b) {
/* a kickstart disk was found in drive 0! */
write_log ("Loading Kickstart rom image from Kickstart disk\n");
/* print some notes... */
write_log ("NOTE: if UAE crashes set CPU to 68000 and/or chipmem size to 512KB!\n");
/* read rom image from kickstart disk */
put_word (request + 0x1C, 2);
put_long (request + 0x28, 0xF80000);
put_long (request + 0x2C, 0x200);
put_long (request + 0x24, 0x200 * 512);
m68k_areg(®s, 1) = request;
ersatz_doio ();
/* read rom image once again to mirror address space.
not elegant, but it works... */
put_word (request + 0x1C, 2);
put_long (request + 0x28, 0xFC0000);
put_long (request + 0x2C, 0x200);
put_long (request + 0x24, 0x200 * 512);
m68k_areg(®s, 1) = request;
ersatz_doio ();
disk_eject (0);
m68k_setpc (®s, 0xFC0002);
fill_prefetch_slow (®s);
uae_reset (0);
ersatzkickfile = 0;
return;
}
m68k_setpc (®s, 0x400C);
fill_prefetch_slow (®s);
/* Init the hardware */
put_long (0x3000, 0xFFFFFFFEul);
put_long (0xDFF080, 0x3000);
put_word (0xDFF088, 0);
put_word (0xDFF096, 0xE390);
put_word (0xDFF09A, 0xE02C);
put_word (0xDFF09E, 0x0000);
put_word (0xDFF092, 0x0038);
put_word (0xDFF094, 0x00D0);
put_word (0xDFF08E, 0x2C81);
put_word (0xDFF090, 0xF4C1);
put_word (0xDFF02A, 0x8000);
put_byte (0xBFD100, 0xF7);
put_byte (0xBFEE01, 0);
put_byte (0xBFEF01, 0x08);
put_byte (0xBFDE00, 0x04);
put_byte (0xBFDF00, 0x84);
put_byte (0xBFDD00, 0x9F);
put_byte (0xBFED01, 0x9F);
}
static void ersatz_init (void)
{
int f;
uaecptr request;
uaecptr a;
if (disk_empty (0)) {
write_log ("You need to have a diskfile in DF0 to use the Kickstart replacement!\n");
uae_quit ();
_68k_setpc (0xF80010);
return;
}
_68k_sreg = 0;
/* Set some interrupt vectors */
for (a = 8; a < 0xC0; a += 4) {
put_long (a, 0xF8001A);
}
_68k_ispreg = _68k_mspreg = _68k_uspreg = 0x800;
_68k_areg(7) = 0x80000;
#ifndef USE_FAME_CORE
_68k_intmask = 0;
#endif
/* Build a dummy execbase */
put_long (4, _68k_areg(6) = 0x676);
put_byte (0x676 + 0x129, 0);
for (f = 1; f < 105; f++) {
put_word (0x676 - 6*f, 0x4EF9);
put_long (0x676 - 6*f + 2, 0xF8000C);
}
/* Some "supported" functions */
put_long (0x676 - 456 + 2, 0xF80014);
put_long (0x676 - 216 + 2, 0xF80020);
put_long (0x676 - 198 + 2, 0xF80026);
put_long (0x676 - 204 + 2, 0xF8002c);
put_long (0x676 - 210 + 2, 0xF8002a);
/* Build an IORequest */
request = 0x800;
put_word (request + 0x1C, 2);
put_long (request + 0x28, 0x4000);
put_long (request + 0x2C, 0);
put_long (request + 0x24, 0x200 * 4);
_68k_areg(1) = request;
ersatz_doio ();
/* kickstart disk loader */
if (get_long(0x4000) == 0x4b49434b) {
/* a kickstart disk was found in drive 0! */
write_log ("Loading Kickstart rom image from Kickstart disk\n");
/* print some notes... */
write_log ("NOTE: if UAE crashes set CPU to 68000 and/or chipmem size to 512KB!\n");
/* read rom image from kickstart disk */
put_word (request + 0x1C, 2);
put_long (request + 0x28, 0xF80000);
put_long (request + 0x2C, 0x200);
put_long (request + 0x24, 0x200 * 512);
_68k_areg(1) = request;
ersatz_doio ();
/* read rom image once ajain to mirror address space.
not elegant, but it works... */
put_word (request + 0x1C, 2);
put_long (request + 0x28, 0xFC0000);
put_long (request + 0x2C, 0x200);
put_long (request + 0x24, 0x200 * 512);
_68k_areg(1) = request;
ersatz_doio ();
disk_eject (0);
_68k_setpc (0xFC0002);
fill_prefetch_0 ();
uae_reset ();
ersatzkickfile = 0;
return;
}
_68k_setpc (0x400C);
fill_prefetch_0 ();
/* Init the hardware */
put_long (0x3000, 0xFFFFFFFEul);
put_long (0xDFF080, 0x3000);
put_word (0xDFF088, 0);
put_word (0xDFF096, 0xE390);
put_word (0xDFF09A, 0xE02C);
put_word (0xDFF09E, 0x0000);
put_word (0xDFF092, 0x0038);
put_word (0xDFF094, 0x00D0);
put_word (0xDFF08E, 0x2C81);
put_word (0xDFF090, 0xF4C1);
put_word (0xDFF02A, 0x8000);
put_byte (0xBFD100, 0xF7);
put_byte (0xBFEE01, 0);
put_byte (0xBFEF01, 0x08);
put_byte (0xBFDE00, 0x04);
put_byte (0xBFDF00, 0x84);
put_byte (0xBFDD00, 0x9F);
put_byte (0xBFED01, 0x9F);
}
int write_histograms (HISTOGRAM **phisto, int nhisto, IO_BUFFER *iobuf)
{
int ihisto, mhisto, ncounts;
HISTOGRAM *histo, *thisto;
IO_ITEM_HEADER item_header;
int ibin;
if ( nhisto != - 1 )
{
if ( phisto == (HISTOGRAM **) NULL )
return -1;
if ( (histo = *phisto) == (HISTOGRAM *) NULL )
{
nhisto = 0;
item_header.ident = -1;
}
else
item_header.ident = histo->ident;
}
else
{
histo = (HISTOGRAM *) NULL;
item_header.ident = -1;
}
if ( iobuf == (IO_BUFFER *) NULL )
return -1;
item_header.type = 100; /* Histogram data is type 100 */
item_header.version = 2; /* Version 2 */
put_item_begin(iobuf,&item_header);
/* If no histogram was supplied, writing the header was the whole job. */
if ( nhisto == 0 )
{
put_short(0,iobuf);
put_item_end(iobuf,&item_header);
return 0;
}
mhisto = 0;
if ( nhisto == -1 )
{
if ( histo == (HISTOGRAM *) NULL )
histo = get_first_histogram();
thisto = histo;
while ( thisto != (HISTOGRAM *) NULL )
{
thisto = thisto->next;
mhisto++;
}
}
else
{
for ( ihisto=0; ihisto<nhisto; ihisto++ )
if ( phisto[ihisto] != (HISTOGRAM *) NULL )
mhisto++;
}
put_short(mhisto,iobuf); /* No. of histograms dumped */
for ( ihisto=0; ihisto<mhisto; ihisto++ )
{
if ( nhisto != -1 )
histo = phisto[ihisto];
#ifdef _REENTRANT
histogram_lock(histo);
#endif
put_byte((int)histo->type,iobuf);
if ( put_string(histo->title,iobuf) % 2 == 0 )
put_byte('\0',iobuf);
put_long(histo->ident,iobuf);
put_short((int)histo->nbins,iobuf);
put_short((int)histo->nbins_2d,iobuf);
put_long((long)histo->entries,iobuf);
put_long((long)histo->tentries,iobuf);
put_long((long)histo->underflow,iobuf);
put_long((long)histo->overflow,iobuf);
if ( histo->type == 'R' || histo->type == 'r' ||
histo->type == 'F' || histo->type == 'D' )
{
put_real((double)histo->specific.real.lower_limit,iobuf);
put_real((double)histo->specific.real.upper_limit,iobuf);
put_real((double)histo->specific.real.sum,iobuf);
put_real((double)histo->specific.real.tsum,iobuf);
}
else
{
put_long((long)histo->specific.integer.lower_limit,iobuf);
put_long((long)histo->specific.integer.upper_limit,iobuf);
put_long((long)histo->specific.integer.sum,iobuf);
put_long((long)histo->specific.integer.tsum,iobuf);
}
if ( histo->nbins_2d > 0 )
{
put_long((long)histo->underflow_2d,iobuf);
put_long((long)histo->overflow_2d,iobuf);
if ( histo->type == 'R' || histo->type == 'r' ||
histo->type == 'F' || histo->type == 'D' )
{
put_real((double)histo->specific_2d.real.lower_limit,iobuf);
put_real((double)histo->specific_2d.real.upper_limit,iobuf);
put_real((double)histo->specific_2d.real.sum,iobuf);
put_real((double)histo->specific_2d.real.tsum,iobuf);
}
else
{
put_long((long)histo->specific_2d.integer.lower_limit,iobuf);
put_long((long)histo->specific_2d.integer.upper_limit,iobuf);
put_long((long)histo->specific_2d.integer.sum,iobuf);
put_long((long)histo->specific_2d.integer.tsum,iobuf);
}
ncounts = histo->nbins*histo->nbins_2d;
}
else
ncounts = histo->nbins;
if ( histo->type == 'F' || histo->type == 'D' )
{
put_real((histo->extension)->content_all,iobuf);
put_real((histo->extension)->content_inside,iobuf);
put_vector_of_real((histo->extension)->content_outside,8,iobuf);
}
if ( histo->tentries > 0 ) /* FIXME: we have a problem at every multiple of exactly 2^32 entries */
{
if ( histo->type == 'F' )
for (ibin=0; ibin<ncounts; ibin++)
put_real((double)(histo->extension)->fdata[ibin],iobuf);
else if ( histo->type == 'D' )
put_vector_of_real((histo->extension)->ddata,ncounts,iobuf);
else
put_vector_of_long((long *)histo->counts,ncounts,iobuf);
}
#ifdef _REENTRANT
histogram_unlock(histo);
#endif
if ( nhisto == - 1 )
if ( (histo = histo->next) == (HISTOGRAM *) NULL )
break;
}
return(put_item_end(iobuf,&item_header));
}
//-----------------------------------------------------------------------
static void read_fixup(linput_t *li)
{
fixup fix;
const int size = offsetof(fixup, fixups);
lread(li, &fix, size);
uint32 fptr = qltell(li);
ea_t sea = getsea(fix.where_IN);
if ( sea != BADADDR )
{
uchar *b = qnewarray(uchar, fix.length);
if ( b == NULL ) nomem("read_fixup");
lread(li, b, fix.length);
// show_hex(b, fix.length, "\nFIXUP SEG %04X, %04X BYTES, KIND %02X\n",
// fix.where_IN,
// fix.length,
// b[0]);
const uchar *ptr = b;
const uchar *end = b + fix.length;
while ( ptr < end )
{
fixup_data_t fd;
uint32 where_offset = 0;
uint32 what_offset = 0;
ushort what_in = 9;
bool selfrel = false;
bool isfar = false;
fd.type = FIXUP_OFF32;
switch ( *ptr++ )
{
case 0x2C: // GEN
isfar = true;
ask_for_feedback("Untested relocation type");
case 0x24: // GEN
where_offset = readdw(ptr, false);
what_offset = readdw(ptr, false);
what_in = (ushort)readdw(ptr, false);
break;
case 0x2D:
isfar = true;
case 0x25: // INTRA
where_offset = readdw(ptr, false);
what_offset = readdw(ptr, false);
what_in = fix.where_IN;
break;
case 0x2A: // CALL
where_offset = readdw(ptr, false);
what_offset = 0;
what_in = (ushort)readdw(ptr, false);
selfrel = true;
break;
case 0x2E: // OFF32?
isfar = true;
case 0x26:
where_offset = readdw(ptr, false);
what_offset = 0;
what_in = (ushort)readdw(ptr, false);
break;
default:
ask_for_feedback("Unknown relocation type %02X", ptr[-1]);
add_pgm_cmt("!!! Unknown relocation type %02X", ptr[-1]);
break;
}
ea_t source = sea + where_offset;
ea_t target = BADADDR;
switch ( what_in >> 12 )
{
case 0x02: // segments
target = getsea(what_in);
break;
case 0x06: // externs
target = xea + 4 * ((what_in & 0xFFF) - 1);
fd.type |= FIXUP_EXTDEF;
break;
default:
ask_for_feedback("Unknown relocation target %04X", what_in);
add_pgm_cmt("!!! Unknown relocation target %04X", what_in);
break;
}
segment_t *ts = getseg(target);
fd.sel = ts ? (ushort)ts->sel : 0;
if ( (fd.type & FIXUP_EXTDEF) == 0 )
{
target += what_offset;
what_offset = 0;
}
fd.off = target;
fd.displacement = what_offset;
target += what_offset;
if ( selfrel )
{
fd.type |= FIXUP_SELFREL;
target -= source + 4;
}
set_fixup(source, &fd);
put_long(source, target);
if ( isfar )
{
fd.type = FIXUP_SEG16;
set_fixup(source+4, &fd);
put_word(source+4, fd.sel);
}
}
qfree(b);
}
