pragmas.c

小型游戏引擎

	"jz skip1b   \n\t"
	"movsb   \n\t"
	"decl %%ecx   \n\t"
	"skip1b: testl $2, %%edi   \n\t"
	"jz skip2b   \n\t"
	"movsw   \n\t"
	"sub $2, %%ecx   \n\t"
	"skip2b: mov %%ecx, %%ebx   \n\t"
	"shr $2, %%ecx   \n\t"
	"rep   \n\t"
    "movsl   \n\t"
	"testb $2, %%bl   \n\t"
	"jz skip3b   \n\t"
	"movsw   \n\t"
	"skip3b: testb $1, %%bl   \n\t"
	"jz enditb   \n\t"
	"movsb   \n\t"
	"enditb:   \n\t"
   : : "S" (source), "D" (dest), "c" (size) : "ebx", "cc");
}

void copybufreverse(void *source, void *dest, int size) {
  __asm__ __volatile__ (
	"shrl $1, %%ecx   \n\t"
	"jnc skipit1   \n\t"
	"movb (%%esi), %%al   \n\t"
	"decl %%esi   \n\t"
	"movb %%al, (%%edi)   \n\t"
	"incl %%edi   \n\t"
	"skipit1: shrl $1, %%ecx   \n\t"
	"jnc skipit2   \n\t"
	"movw -1(%%esi), %%ax   \n\t"
	"subl $2, %%esi   \n\t"
	"rorw $8, %%ax   \n\t"
	"movw %%ax, (%%edi)   \n\t"
	"addl $2, %%edi   \n\t"
	"skipit2: testl %%ecx, %%ecx   \n\t"
	"jz endloop   \n\t"
	"begloop: movl -3(%%esi), %%eax   \n\t"
	"subl $4, %%esi   \n\t"
	"bswapl %%eax   \n\t"
	"movl %%eax, (%%edi)   \n\t"
	"addl $4, %%edi   \n\t"
	"decl %%ecx   \n\t"
	"jnz begloop   \n\t"
	"endloop:   \n\t"
   : : "S" (source), "D" (dest), "c" (size) : "cc");
}

void qinterpolatedown16 (long *source, int size, int linum, int linum_inc) {
  __asm__ __volatile__ (
	"movl %%ecx, %%ebx   \n\t"
	"shrl $1, %%ecx   \n\t"
	"jz skipbegcalc   \n\t"
	"begqcalc: leal (%%esi, %%edx), %%edi   \n\t"
	"sarl $16, %%edx   \n\t"
	"movl %%edx, (%%eax)   \n\t"
	"leal (%%edi, %%esi), %%edx   \n\t"
	"sarl $16, %%edi   \n\t"
	"movl %%edi, 4(%%eax)   \n\t"
	"addl $8, %%eax   \n\t"
	"decl %%ecx   \n\t"
	"jnz begqcalc   \n\t"
	"testl $1, %%ebx   \n\t"
	"jz skipbegqcalc2   \n\t"
	"skipbegcalc: sarl $16, %%edx   \n\t"
	"movl %%edx, (%%eax)   \n\t"
	"skipbegqcalc2:   \n\t"
  : :"a" (source), "c" (size), "d" (linum), "S" (linum_inc) : "ebx", "edi", "cc", "memory" );
}

void qinterpolatedown16short (long *source, int size, int linum, int linum_inc)
{
  __asm__ __volatile__ (
	"testl %%ecx, %%ecx   \n\t"
	"jz endit   \n\t"
	"testb $2, %%al   \n\t"
	"jz skipalignit   \n\t"
	"movl %%edx, %%ebx   \n\t"
	"sarl $16, %%ebx   \n\t"
	"movw %%bx, (%%eax)   \n\t"
	"addl %%esi, %%edx   \n\t"
	"addl $2, %%eax   \n\t"
	"decl %%ecx   \n\t"
	"jz endit   \n\t"
	"skipalignit: subl $2, %%ecx   \n\t"
	"jc finishit   \n\t"
	"bbegqcalc: movl %%edx, %%ebx   \n\t"
	"addl %%esi, %%edx   \n\t"
	"sarl $16, %%ebx   \n\t"
	"movl %%edx, %%edi   \n\t"
	"andl $0xffff0000, %%edi   \n\t"
	"addl %%esi, %%edx   \n\t"
	"addl %%edi, %%ebx   \n\t"
	"movl %%ebx, (%%eax)   \n\t"
	"addl $4, %%eax   \n\t"
	"subl $2, %%ecx   \n\t"
	"jnc bbegqcalc   \n\t"
	"testb $1, %%cl   \n\t"
	"jz endit   \n\t"
	"finishit: movl %%edx, %%ebx   \n\t"
	"sarl $16, %%ebx   \n\t"
	"movw %%bx, (%%eax)   \n\t"
	"endit:   \n\t"
  : :"a" (source), "c" (size), "d" (linum), "S" (linum_inc) : "ebx", "edi", "cc", "memory");
}

void vlin16first (long i1, long i2) {
  __asm__ __volatile__ (
  	"movb 	(%%edi), %%al   \n\t"
	"movl 	%%ecx, %%eax   \n\t"
	"shrl 	$2, %%ecx   \n\t"
	"   \n\t"
	"begvlin16firsta:   \n\t"
		"movb	%%al, (%%edi)   \n\t"
		"movb 	%%al, 80(%%edi)   \n\t"
		"movb 	%%al, 160(%%edi)   \n\t"
		"movb 	%%al, 240(%%edi)   \n\t"
		"addl 	$320, %%edi   \n\t"
		"decl 	%%ecx   \n\t"
	"jnz 	begvlin16firsta   \n\t"
	"   \n\t"
	"movl 	%%eax, %%ecx   \n\t"
	"andl 	$3, %%ecx   \n\t"
	"jz 	skipfirst   \n\t"
	"begvlin16firstb:   \n\t"
		"movb	%%al, (%%edi)   \n\t"
		"addl 	$80, %%edi   \n\t"
		"decl 	%%ecx   \n\t"
	"jnz begvlin16firstb   \n\t"
	"skipfirst:   \n\t"
  
  : : "D" (i1), "c" (i2) : "cc", "memory");
}

void vlin16 (long i1, long i2) {
  __asm__ __volatile__ (
  	"movl 	%%edi, %%esi   \n\t"
	"begvlin16:   \n\t"
		"movsb   \n\t"
		"addl 	$79, %%edi   \n\t"
		"addl 	$79, %%esi   \n\t"
		"decl 	%%ecx   \n\t"
	"jnz 	begvlin16   \n\t"
  
  : : "D" (i1), "c" (i2) : "cc", "memory");

}

int klabs (int i1) {
  int retval = 0;
  __asm__ __volatile__ (
	"testl %%eax, %%eax   \n\t"
	"jns skipnegate   \n\t"
	"negl %%eax   \n\t"
	"skipnegate:   \n\t"
   : "=a" (retval) : "a" (i1) : "cc");
  return(retval);
}

int ksgn(int i1) {
  int retval = 0;
  __asm__ __volatile__ (
	"addl %%ebx, %%ebx   \n\t"
	"sbbl %%eax, %%eax   \n\t"
	"cmpl %%ebx, %%eax   \n\t"
	"adcb $0, %%al   \n\t"
   : "=a" (retval) : "b" (i1) : "cc");
  return(retval);
}

void swapchar(int i1, int i2) {
  __asm__ __volatile__ (
	"movb (%%eax), %%cl   \n\t"
	"movb (%%ebx), %%ch   \n\t"
	"movb %%cl, (%%ebx)   \n\t"
	"movb %%ch, (%%eax)   \n\t"
   : : "a" (i1), "b" (i2) : "ecx", "cc", "memory");
}

void swapshort(int i1, int i2) {
  __asm__ __volatile__ (
	"movw (%%eax), %%cx   \n\t"
	"movw (%%ebx), %%dx   \n\t"
	"movw %%cx, (%%ebx)   \n\t"
	"movw %%dx, (%%eax)   \n\t"
   : : "a" (i1), "b" (i2) : "ecx", "edx", "cc", "memory");
}


void swaplong(int i1, int i2) {
  __asm__ __volatile__ (
	"movl (%%eax), %%ecx   \n\t"
	"movl (%%ebx), %%edx   \n\t"
	"movl %%ecx, (%%ebx)   \n\t"
	"movl %%edx, (%%eax)   \n\t"
   : : "a" (i1), "b" (i2) : "ecx", "edx", "cc", "memory");
}


/*
#pragma aux swapbuf4 =\
	"begswap:",\
	"mov esi, (%%eax)",\
	"mov edi, (%%ebx)",\
	"mov (%%ebx), esi",\
	"mov (%%eax), edi",\
	"add eax, 4",\
	"add ebx, 4",\
	"dec ecx",\
	"jnz short begswap",\
	parm (%%eax)(%%ebx)[ecx]\
	modify exact [eax ebx ecx esi edi]\

#pragma aux swap64bit =\
	"mov ecx, (%%eax)",\
	"mov edx, (%%ebx)",\
	"mov (%%ebx), ecx",\
	"mov ecx, [eax+4]",\
	"mov (%%eax), edx",\
	"mov edx, [ebx+4]",\
	"mov [ebx+4], ecx",\
	"mov [eax+4], edx",\
	parm (%%eax)(%%ebx)\
	modify exact [ecx edx]\
*/


    /*
	 * swapchar2(ptr1,ptr2,xsiz); is the same as:
	 * swapchar(ptr1,ptr2); swapchar(ptr1+1,ptr2+xsiz);
     */
int swapchar2(int i1, int i2, int i3) {
  int retval = 0;
  __asm__ __volatile__ (
	"addl %%ebx, %%esi   \n\t"
	"movw (%%eax), %%cx   \n\t"
	"movb (%%ebx), %%dl   \n\t"
	"movb %%cl, (%%ebx)   \n\t"
	"movb (%%esi), %%dh   \n\t"
	"movb %%ch, (%%esi)   \n\t"
	"movw %%dx, (%%eax)   \n\t"
   : "=a" (retval) : "a" (i1), "b" (i2), "S" (i3) : "ecx", "edx", "cc", "memory");
    return(retval);
}

/*

	//returns eax%ebx, dmval = eax/edx;
#pragma aux moddiv =\
	"xor edx, edx",\
	"div ebx",\
	"mov dmval, eax",\
	parm [eax][ebx]\
	modify exact [eax edx]\
	value [edx]


	//eax = (unsigned min)umin(eax,ebx)
#pragma aux umin =\
	"sub eax, ebx",\
	"sbb ecx, ecx",\
	"and eax, ecx",\
	"add eax, ebx",\
	parm nomemory [eax][ebx]\
	modify exact [eax ecx]\

	//eax = (unsigned max)umax(eax,ebx)
#pragma aux umax =\
	"sub eax, ebx",\
	"sbb ecx, ecx",\
	"xor ecx, 0xffffffff",\
	"and eax, ecx",\
	"add eax, ebx",\
	parm nomemory [eax][ebx]\
	modify exact [eax ecx]\

#pragma aux kmin =\
	"cmp eax, ebx",\
	"jl skipit",\
	"mov eax, ebx",\
	"skipit:",\
	parm nomemory [eax][ebx]\
	modify exact [eax]\

#pragma aux kmax =\
	"cmp eax, ebx",\
	"jg skipit",\
	"mov eax, ebx",\
	"skipit:",\
	parm nomemory [eax][ebx]\
	modify exact [eax]\

#pragma aux readtimer =\
	"mov al, 0xd2",\
	"out 0x43, al",\
	"in al, 0x40",\
	"shl eax, 24",\
	"in al, 0x40",\
	"rol eax, 8",\
	modify [eax]\

#pragma aux redblueblit = \
	"xor ecx, ecx",\
	"begblit: mov eax, dword ptr [edx+ecx]",\
	"shl eax, 4",\
	"add eax, dword ptr [ebx+ecx]",\
	"mov dword ptr [ecx+0xa0000], eax",\
	"add ecx, 4",\
	"cmp ecx, esi",\
	"jb begblit",\
	parm [ebx][edx][esi]\
	modify exact [eax ecx]\

#pragma aux chainblit =\
	"shr ecx, 1",\
	"jnc prebeg",\
	"mov al, byte ptr [esi+8]",\
	"mov ah, byte ptr [esi+12]",\
	"shl eax, 16",\
	"mov al, byte ptr [esi]",\
	"mov ah, byte ptr [esi+4]",\
	"mov dword ptr [edi], eax",\
	"add esi, 16",\
	"add edi, 4",\
	"test ecx, ecx",\
	"prebeg: jz endit",\
	"beg: mov al, byte ptr [esi+8]",\
	"mov bl, byte ptr [esi+24]",\
	"mov ah, byte ptr [esi+12]",\
	"mov bh, byte ptr [esi+28]",\
	"shl eax, 16",\
	"add edi, 8",\
	"shl ebx, 16",\
	"mov al, byte ptr [esi]",\
	"mov bl, byte ptr [esi+16]",\
	"mov ah, byte ptr [esi+4]",\
	"mov bh, byte ptr [esi+20]",\
	"add esi, 32",\
	"mov dword ptr [edi-8], eax",\
	"dec ecx",\
	"mov dword ptr [edi-4], ebx",\
	"jnz beg",\
	"endit:",\
	parm [esi][edi][ecx]\
	modify exact [eax ebx ecx esi edi]\

static long timeroffs1mhz;
	//accutimeroffs = -8-(t1-t0);
#pragma aux inittimer1mhz =\
	"xor ebx, ebx",\
	"xor ecx, ecx",\
	"in al, 0x61",\
	"or al, 1",\
	"out 0x61, al",\
	"mov al, 0x34",\
	"out 0x43, al",\
	"xor al, al",\
	"out 0x40, al",\
	"mov al, 0xb4",\
	"out 0x43, al",\
	"mov al, 240",\
	"out 0x42, al",\
	"xor al, al",\
	"cli",\
	"out 0x40, al",\
	"dec al",\
	"out 0x42, al",\
	"mov al, 0x04",\
	"out 0x43, al",\
	"in al, 0x40",\
	"mov bl, al",\
	"in al, 0x40",\
	"mov bh, al",\
	"mov al, 0x84",\
	"out 0x43, al",\
	"in al, 0x42",\
	"mov cl, al",\
	"in al, 0x42",\
	"sti",\
	"mov ch, al",\
	"sub ebx, ecx",\
	"sub ebx, 8",\
	"mov timeroffs1mhz, ebx",\
	modify exact [eax ebx ecx]\

#pragma aux uninittimer1mhz =\
	"in al, 0x61",\
	"and al, 252",\
	"out 0x61, al",\
	modify exact [eax]\

	//t = ((ecx-ebx+timeroffs1mhz)&0xfff0)*4095 + ecx;
#pragma aux gettime1mhz =\
	"mov ebx, timeroffs1mhz",\
	"xor ecx, ecx",\
	"mov al, 0x04",\
	"cli",\
	"out 0x43, al",\
	"in al, 0x40",\
	"sub bl, al",\
	"in al, 0x40",\
	"sbb bh, al",\
	"mov al, 0x84",\
	"out 0x43, al",\
	"in al, 0x42",\
	"mov cl, al",\
	"in al, 0x42",\
	"sti",\
	"mov ch, al",\
	"add ebx, ecx",\
	"and ebx, 0x0000fff0",\
	"sub ecx, ebx",\
	"shl ebx, 12",\
	"add ebx, ecx",\
	modify exact [eax ebx ecx]\
	value [ebx]\

	//eax = eax-ebx; if (eax < 0) eax += (1<<28) - (1<<16);
#pragma aux deltatime1mhz =\
	"sub eax, ebx",\
	"jnc skipit",\
	"add eax, 0x0fff0000",\
	"skipit:",\
	parm [ebx][eax]\

*/

#else

/*
 * !!! out of respect to Ken, the ASM version needs to be converted to
 *  portable C, so we can legitimately check this on all platforms.
 */
unsigned long getkensmessagecrc(long param)
{
    return(0x56c764d4);
} /* getkensmessagecrc */

void swapchar(unsigned char *p1, unsigned char *p2)
{
    unsigned char tmp = *p1;
    *p1 = *p2;
    *p2 = tmp;
} /* swapchar */

void swapshort(short *p1, short *p2)
{
    short tmp = *p1;
    *p1 = *p2;
    *p2 = tmp;
} /* swapshort */

void swaplong(long *p1, long *p2)
{
    long tmp = *p1;
    *p1 = *p2;
    *p2 = tmp;
} /* swaplong */

void swapchar2(unsigned char *p1, unsigned char *p2, int xsiz)
{
    swapchar(p1, p2);
    swapchar(p1 + 1, p2 + xsiz);
} /* swapchar2 */


void qinterpolatedown16short (long *source, int size, int linum, int linum_inc)
{
    /* Attempt at a convert to C :/ - DDOI */
    int tmp;

	if (size == 0)
        return;

        /* casting sucks ass.  --ryan. */
	if ( (((unsigned long) source) & 0xFF) != 2)
    {
		*((short *) source) = (short) ( (linum >> 16) & 0xFFFF ) ;
        source = (long *) ( ((short *) source) + 2 );
		linum += linum_inc;
		size--;
	} /* if */

	size -= 2;
	if (size < 0)
        *((short *) source) = (short) ((linum << 16) & 0xFFFF);
    else
    {
        while ( size >= 0)
        {
            tmp = linum;
            linum += linum_inc;
            *source = ((tmp >> 16) + (linum & 0xffff0000));
            linum += linum_inc;
            size -= 2;
            source++;
        } /* while */

        if (size != 1)
            *((short *) source) = (short) ((linum << 16) & 0xFFFF);
    } /* else */
} /* qinterpolatedown16short */

#endif

/* end of pragmas.c ... */