loadprg.c

大量的汇编程序源代码

	    proc->p_flags |= PF_EMX_FILE;
	}
	else { /* OLD DJGPP STYLE */
	    scnd_hdr[TEXT].s_vaddr = 0x400000L;
	    scnd_hdr[DATA].s_vaddr =
		0x400000L + ((gnu_hdr.a_text + 0x3FFFFFL) & ~0x3FFFFFL);
	    scnd_hdr[BSS].s_vaddr =
		scnd_hdr[DATA].s_vaddr + gnu_hdr.a_data;
	    scnd_hdr[TEXT].s_scnptr = 0;
	    scnd_hdr[DATA].s_scnptr = (gnu_hdr.a_text + 0xFFFL) & ~0xFFFL;
	    proc->p_flags |= PF_DJGPP_FILE;
	}
    }
    else {	/* not a valid header */
	rm_close(fhandle);
	return EMX_ENOEXEC;
    }

    proc->filehandle = (long) fhandle;
    proc->text_off = headoff + scnd_hdr[TEXT].s_scnptr;
    proc->data_off = headoff + scnd_hdr[DATA].s_scnptr;

    proc->text_start = scnd_hdr[TEXT].s_vaddr;
    proc->text_end = scnd_hdr[TEXT].s_vaddr + scnd_hdr[TEXT].s_size;
    proc->bss_start = scnd_hdr[BSS].s_vaddr;
    proc->bss_end = scnd_hdr[BSS].s_vaddr + scnd_hdr[BSS].s_size;
    proc->data_start = scnd_hdr[DATA].s_vaddr;
    proc->data_end = (proc->bss_end + 4095L) & ~4095L;
    proc->entry = aout_hdr.entry;

    /* compute size of text-data-bss and stack segment for AllocMem() */
    tdbsegm = proc->data_end;
    if (opt_stackval)
	stacksegm = (DWORD) opt_stackval *1024;
    else
	stacksegm = DEFAULT_STACK;

    if (proc == &RSX_PROCESS) { /* emu don't need much stack */
	stacksegm = SHORT_EMX_STACK;
	use_dpmi10 = 0;
    } else
	use_dpmi10 = (dpmi10) ? 1 : 0;

    if (use_dpmi10)
	proc->p_flags |= PF_USEDPMI10;


    /* look for empty space for stack */
    if (aout_hdr.entry == 0x10000L && stacksegm <= SHORT_EMX_STACK) {
	stacksegm = 0;
	/* place stack in the first 64KB segment */
	proc->stack_top = proc->text_start;
	proc->stack_down = 0x1000L;
    } else if (aout_hdr.entry == 0x1020L
	       && stacksegm <= (proc->data_start - proc->text_end)) {
	stacksegm = 0;
	/* place stack between code and data */
	proc->stack_top = proc->data_start;
	proc->stack_down = proc->text_end + 0x1000;
    } else {
	/* put stack after data/bss */
	proc->stack_top = proc->data_end + stacksegm;
	proc->stack_down = proc->data_end;

	/* sorry, work around window bug */
	if ((proc->p_flags & PF_DJGPP_FILE) && proc->stack_down <= 0x11000L
	    && proc != &RSX_PROCESS) {
	    DWORD add_stack = 0x11000L - proc->stack_down;
	    proc->stack_top += add_stack;
	    proc->stack_down += add_stack;
	    stacksegm += add_stack;
	}
    }

    if (use_dpmi10) {
	stacksegm = 0;
	proc->stack_top = DPMI_PRG_DATA;
	proc->stack_down = proc->data_end;
    }
    proc->stacksize = proc->stack_top - proc->stack_down;
    proc->stackp32 = proc->stack_top - 4L;

    proc->init_brk = proc->data_end + stacksegm;
    proc->brk_value = proc->init_brk;
    proc->pagefree = 0;

    /* total memory for process */
    if (use_dpmi10) {
	proc->pagefree = DPMI_PRG_DATA - proc->membytes;
	proc->membytes = DPMI_PRG_ROOM;
    } else {
	proc->membytes = tdbsegm + stacksegm;

	/* prealloc more heap */
	if (opt_memalloc) {
	    proc->pagefree =  (long) opt_memalloc * 1024;
	    proc->membytes += (long) opt_memalloc * 1024;
	} else if (opt_memaccess || (proc->options & OPT_MEMACCESS)) {
	    proc->pagefree =  0x21000;
	    proc->membytes += 0x21000;
	}
    }

    /* since dosmem isn't used by DPMI we put rsx387 in dos memory */
    if (proc == &RSX_PROCESS && rsx387_in_dosmem) {
	UINT segment, selectors;
	if (AllocDosMem((UINT) (proc->membytes >> 4), &segment, &selectors)) {
	    if (AllocMem(proc->membytes, &(proc->memhandle), &(proc->memaddress)))
		return EMX_ENOMEM;
	} else {
	    proc->memaddress = (DWORD) segment << 4;
	    proc->memhandle = (DWORD) selectors;
	}
    }
    /* get memory from DPMI-host */
    else if (!use_dpmi10) {
	if (AllocMem(proc->membytes, &(proc->memhandle), &(proc->memaddress)))
	    return EMX_ENOMEM;
    } else if (AllocLinearMemory(proc->membytes, 0L, 0L, &proc->memhandle, &proc->memaddress))
	return EMX_ENOMEM;

    /* alloc 32bit cs,ds ldt selector */
    if (AllocLDT(3, &(proc->code32sel)))
	return EMX_EIO;
    proc->data32sel = proc->code32sel + sel_incr;
    stack32sel = proc->data32sel + sel_incr;

    /* fill descriptors */
    SetBaseAddress(proc->code32sel, proc->memaddress);
    SetBaseAddress(proc->data32sel, proc->memaddress);
    SetBaseAddress(stack32sel, proc->memaddress);
    SetAccess(proc->code32sel, APP_CODE_SEL, DEFAULT_BIT);
    SetAccess(proc->data32sel, APP_DATA_SEL, BIG_BIT);
    SetAccess(stack32sel, APP_DATA_SEL | EXPAND_BIT, BIG_BIT | GRANULAR_BIT);

    /* allow execute data & stack  (DJGPP / GDB need this) */
    SetLimit(proc->code32sel, proc->membytes - 1L);

    if (!use_dpmi10) {
	if (opt_memaccess || (proc->options & OPT_MEMACCESS))
	    SetLimit(proc->data32sel, 0xFFFFFFFF);
	else
	    SetLimit(proc->data32sel, proc->membytes - 1L);
    } else
	SetLimit(proc->data32sel, DPMI_PRG_ROOM - 1L);

    /* set stack expand down segment to first stack address */
    SetLimit(stack32sel, proc->stack_down - 1L);

    /* map first DOS MB at the end of linear Addressroom (60MB) */
    if (use_dpmi10 && (opt_memaccess || (proc->options & OPT_MEMACCESS)))
	MapDOSMemInMemoryBlock(proc->memhandle, DPMI_PRG_DATA, 256L, 0L);

    if (!use_dpmi10) {
	/* read in code */
	rm_lseek(fhandle, proc->text_off, SEEK_SET);
	readin_file(fhandle,
	    proc->data32sel, scnd_hdr[TEXT].s_vaddr,
	    scnd_hdr[TEXT].s_size);

	/* read in data,bss */
	rm_lseek(fhandle, proc->data_off, SEEK_SET);
	readin_file(fhandle,
	    proc->data32sel, scnd_hdr[DATA].s_vaddr,
	    scnd_hdr[DATA].s_size);
	rm_close(fhandle);

	/* zero bss segment */
	if (scnd_hdr[BSS].s_size)
	    bzero32(proc->data32sel, scnd_hdr[BSS].s_vaddr, scnd_hdr[BSS].s_size);
    } else { /* uncommit first stack page! */
	WORD page = 9;
	ModifyPageAttributes(proc->memhandle, proc->stack_top - 4096, 1, &page);
    }
    return 0;
}

/*  this structure that starts a core file */
struct user_area {
    WORD    u_magic	;
    WORD    u_reserved1 ;
    DWORD   u_data_base ;
    DWORD   u_data_end	;
    DWORD   u_data_off	;
    DWORD   u_heap_base ;
    DWORD   u_heap_end	;
    DWORD   u_heap_off	;
    DWORD   u_heap_brk	;
    DWORD   u_stack_base;
    DWORD   u_stack_end ;
    DWORD   u_stack_off ;
    DWORD   u_stack_low ;
    DWORD   u_ar0	;
    DWORD   u_fpvalid	;
    DWORD   u_fpstate[27] ;
    DWORD   u_fpstatus;
    DWORD   u_reserved3[23];
    REG386  u_regs;
};
#define U_OFFSET 0x400

int write_section(short handle, short r_ds, long r_edx, long count)
{
    long bytes;
    int rc;

    while (count > 0) {
	bytes = (count <= IOBUF_SIZE) ? count : (DWORD) IOBUF_SIZE;
	cpy32_16(r_ds, r_edx, iobuf, bytes);
	rc = rm_write(handle, iobuf, (short) bytes);
	if (bytes != rc)
	    return -1;
	count -= bytes;
	r_edx += bytes;
    }
    return 0;
}

#include "PRINTF.H"

int write_core(unsigned handle, NEWPROCESS *proc)
{
    struct user_area ua;
    DWORD data_size;
    DWORD heap_size;

    memset(& ua, 0, sizeof(ua));
    ua.u_magic = 0x10F;
    ua.u_ar0 = 0xE0000000L + (DWORD)(UINT)&(((struct user_area *)0)->u_regs);
    memcpy(& ua.u_regs, &(proc->regs), sizeof(REG386));

    ua.u_data_base = proc->data_start;
    ua.u_data_end = proc->bss_end;		    /* bss not rounded */
    data_size = proc->data_end - proc->data_start;  /* data is page-aligned */
    ua.u_data_off = U_OFFSET;

    ua.u_heap_base = proc->init_brk;
    ua.u_heap_end = (proc->brk_value + 0xFFFL) & ~0xFFFL;
    ua.u_heap_brk = proc->brk_value;
    heap_size = ua.u_heap_end - ua.u_heap_base;
    ua.u_heap_off = ua.u_data_off + data_size;

    ua.u_stack_base = proc->stack_down;
    ua.u_stack_end = proc->stack_top;
    ua.u_stack_low = proc->regs.esp;
    ua.u_stack_off = ua.u_heap_off + heap_size;

    rm_write(handle, &ua, sizeof(ua));	/* header */
    memset(iobuf, 0, U_OFFSET);
    rm_write(handle, iobuf, U_OFFSET - sizeof(ua));

    rm_lseek(handle, ua.u_data_off, 0);
    if (write_section(handle, proc->data32sel, ua.u_data_base, data_size))
	goto bad_write;

    rm_lseek(handle, ua.u_heap_off, 0);
    if (write_section(handle, proc->data32sel, ua.u_heap_base, heap_size))
	goto bad_write;

    rm_lseek(handle, ua.u_stack_off, 0);
    if (write_section(handle, proc->data32sel, ua.u_stack_low,
	    ua.u_stack_end - ua.u_stack_low))
	goto bad_write;

    rm_close(handle);
    return 0;

  bad_write:
    return -1;
}

int write_core_file(NEWPROCESS *proc)
{
    int handle, ret;
    static char core_name[]="CORE";

    handle = rm_creat(core_name, _A_NORMAL);
    if (handle == -1)
	return -1;

    puts("writing core file");
    ret = write_core(handle, proc);

    rm_close(handle);

    /* if (ret == -1) unlink(core_name); */

    return ret;
}