![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bb8.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Plan 9 NeXT] / lucent / sys / src / libgnot|
Return to bb8.h CVS log | Up to [Plan 9 NeXT] / lucent / sys / src / libgnot |
1.1 ! root 1: /* ! 2: * See the comments at the beginning of bb.c and bbc.h ! 3: * for an outline of how this bitblt works ! 4: ! 5: * The VGA screen on the 386 has an awful bit/byte order: ! 6: * the high order bit of a byte is leftmost, but the low ! 7: * order byte of a word is leftmost. This causes havoc ! 8: * if the source is shifted relative to the destination. ! 9: * So we make a 'word' be a byte. That changes the converting ! 10: * bitblt considerably, so that Ru is no longer needed in ! 11: * the abstract machine. ! 12: */ ! 13: #define WBITS 8 ! 14: #define LWBITS 3 ! 15: #define W2L 4 ! 16: #define WMASK 0xFF ! 17: #define BYTEREV ! 18: typedef uchar *WType; ! 19: ! 20: typedef uchar Type; ! 21: ! 22: /* ! 23: * Registers: ! 24: */ ! 25: #define As 6 /* ESI */ ! 26: #define Ad 7 /* EDI */ ! 27: #define Rs 0 /* EAX: FIELD works better with this here */ ! 28: #define Rd 3 /* EBX */ ! 29: #define Rt 2 /* EDX */ ! 30: #define Ri 1 /* ECX: LOOP depends on this here */ ! 31: #define RX 5 /* EBP */ ! 32: #define SP 4 /* ESP */ ! 33: /* Ro is top-of-stack, if needed */ ! 34: ! 35: /* ! 36: * Macros for assembling 386 instructions ! 37: */ ! 38: #define MODRM(mod,rm,reg) (((mod)<<6)|((reg)<<3)|(rm)) ! 39: #define RMR(rm,reg) MODRM(3,rm,reg) ! 40: #define IRMR(rm,reg) MODRM(0,rm,reg) ! 41: #define DB(b1,b2,b3,b4) ((b1)|((b2)<<8)|((b3)<<16)|((b4)<<24)) ! 42: #define SB(b1,b2) ((b1)|((b2)<<8)) ! 43: ! 44: #define OR(src,dst) SB(0x0B, RMR(src,dst)) ! 45: #define XOR(src,dst) SB(0x31, RMR(dst,src)) ! 46: #define AND(src,dst) SB(0x21, RMR(dst,src)) ! 47: #define NOT(r) SB(0xF7, RMR(r,2)) ! 48: #define MOV(src,dst) SB(0x89, RMR(dst,src)) ! 49: ! 50: #define Immd(v) *(long*)p = (long)(v); p += 4 ! 51: #define Immdb(b1,b2,b3,b4) Immd(DB(b1,b2,b3,b4)) ! 52: #define Imms(v) *(short*)p = (v); p += 2 ! 53: #define Immsb(b1,b2) Imms(SB(b1,b2)) ! 54: ! 55: #define Loadb(areg,dst) Immsb(0x8A, IRMR(areg,dst)) ! 56: #define Loadbzx(areg,dst) Immsb(0x0F, 0xB6); *p++ = IRMR(areg,dst); ! 57: #define Storeb(src,areg) Immsb(0x88, IRMR(areg,src)) ! 58: #define Mov(src,dst) Imms(MOV(src,dst)) ! 59: #define Movd(v,dst) *p++ = (0xB8 + (dst)); Immd(v) ! 60: #define Imovzx(a,i,r) Immdb(0x0F, 0xB6, IRMR(4,r), IRMR(5,i)); Immd(a) ! 61: #define Or(src,dst) Imms(OR(src,dst)) ! 62: #define Xor(src,dst) Imms(XOR(src,dst)) ! 63: #define And(src,dst) Imms(AND(src,dst)) ! 64: #define Andd(v,dst) if(dst==Rs) {\ ! 65: *p++ = 0x25;\ ! 66: } else {\ ! 67: Immsb(0x81, RMR(dst,4));\ ! 68: }\ ! 69: Immd(v) ! 70: #define And8(v,dst) if(dst==Rs) {\ ! 71: *p++ = 0x24;\ ! 72: } else {\ ! 73: Immsb(0x80, RMR(dst,4));\ ! 74: }\ ! 75: *p++ = (v) ! 76: #define Not(r) Imms(NOT(r)) ! 77: #define Inc(r) *p++ = (0x40 + (r)) ! 78: #define Dec(r) *p++ = (0x48 + (r)) ! 79: #define Decsp Immsb(0xFF, IRMR(4,1)); *p++ = 0x24 ! 80: #define Shl(r,sh) Immsb(0xC1, RMR(r,4)); *p++ = (sh) ! 81: #define Shr(r,sh) Immsb(0xC1, RMR(r,5)); *p++ = (sh) ! 82: #define Addd(v,r) Immsb(0x81, RMR(r,0)); Immd(v) ! 83: #define Addsp(v) Immsb(0x83, RMR(4,0)); *p++ = v ! 84: #define Pushd(v) *p++ = 0x68; Immd(v) ! 85: #define Loop(d) *p = 0xE2; *(p+1) = d; p += 2 ! 86: #define Jmp8(d) *p = 0xEB; *(p+1) = d; p += 2 ! 87: #define Jmp(d) *p++ = 0xE9; Immd(d) ! 88: #define Jg8(d) *p = 0x7F; *(p+1) = d; p += 2 ! 89: #define Jle8(d) *p = 0x7E; *(p+1) = d; p += 2 ! 90: ! 91: /* ! 92: * Macros for assembling the operations of the abstract machine. ! 93: * Each assumes that uchar *p points to the next location where ! 94: * an instruction should be assembled. Some of them assume ! 95: * that Arg *a points to the Arg structure describing the current ! 96: * bitblt (see bb.c). ! 97: * Some of the operations only care about the low order bytes of ! 98: * the registers; others have to zero the high order bytes because ! 99: * they might get shifted down. ! 100: */ ! 101: ! 102: #define Ofield(c) Xor(Rd,Rs); And8(c,Rs); Xor(Rd,Rs) ! 103: #define Olsha_RsRt Mov(Rt,Rs); Shl(Rs,sha) ! 104: #define Olshb_RsRt Mov(Rt,Rs); Shl(Rs,shb) ! 105: #define Olsh_RsRd(sh) Mov(Rd,Rs); Shl(Rs,sh) ! 106: #define Olsh_RtRt(sh) Shl(Rt,sh) ! 107: #define Olsha_RtRt Shl(Rt,sha) ! 108: #define Olsha_RtRu /* Ru not needed */ ! 109: #define Olshb_RtRu /* Ru not needed */ ! 110: #define Orsha_RsRt Mov(Rt,Rs); Shr(Rs,sha) ! 111: #define Orshb_RsRt Mov(Rt,Rs); Shr(Rs,shb) ! 112: #define Orsha_RtRu /* Ru not needed */ ! 113: #define Orshb_RtRu /* Ru not needed */ ! 114: #define Oorlsha_RsRt Mov(Rt,RX); Shl(RX,sha); Or(RX,Rs) ! 115: #define Oorlshb_RsRt Mov(Rt,RX); Shl(RX,shb); Or(RX,Rs) ! 116: #define Oorlsh_RsRd(sh) Mov(Rd,RX); Shl(RX,sh); Or(RX,Rs) ! 117: #define Oorrsha_RsRt Mov(Rt,RX); Shr(RX,sha); Or(RX,Rs) ! 118: #define Oorrshb_RsRt Mov(Rt,RX); Shr(RX,shb); Or(RX,Rs) ! 119: #define Oorrsha_RtRu /* Ru not needed */ ! 120: #define Oorrshb_RtRu /* Ru not needed */ ! 121: #define Oor_RsRd Or(Rd,Rs) ! 122: #define Add_As(v) Addd(v,As) ! 123: #define Add_Ad(v) Addd(v,Ad) ! 124: #define Initsd(s,d) Movd(s,As); Movd(d,Ad) ! 125: #define Ilabel(c) Movd(c,Ri) ! 126: #define Olabel(c) Pushd(c) ! 127: #define Iloop(lp) tmp = (lp)-(p+2); \ ! 128: if(tmp > -128) { \ ! 129: Loop(tmp); \ ! 130: } else { \ ! 131: Loop(2); \ ! 132: Jmp8(5); \ ! 133: tmp = (lp) - (p+5); \ ! 134: Jmp(tmp); \ ! 135: } ! 136: #define Oloop(lp) Decsp; \ ! 137: tmp = (lp)-(p+2); \ ! 138: if(tmp > -128) { \ ! 139: Jg8(tmp); \ ! 140: } else { \ ! 141: Jle8(5); \ ! 142: tmp = (lp) - (p+5); \ ! 143: Jmp(tmp); \ ! 144: } \ ! 145: Addsp(4) ! 146: #define Orts *p++ = 0xC3 ! 147: /* load */ ! 148: #define Load_Rs_P Loadb(As,Rs); Inc(As) ! 149: #define Load_Rt_P Loadb(As,Rt); Inc(As) ! 150: #define Loadzx_Rt_P Loadbzx(As,Rt); Inc(As) ! 151: #define Loador_Rt_P Loadb(As,Rt); Inc(As) ! 152: #define Load_Ru_P /* Ru not needed */ ! 153: #define Load_Rd_D(f) Dec(As); Loadb(As,Rd) ! 154: #define Load_Rs_D(f) Dec(As); Loadb(As,Rs) ! 155: #define Load_Rt_D(f) Dec(As); Loadb(As,Rt) ! 156: #define Loadzx_Rt_D(f) Dec(As); Loadbzx(As,Rt) ! 157: #define Load_Rd(f) Loadb(As,Rd) ! 158: #define Load_Rs(f) Loadb(As,Rs) ! 159: #define Load_Rt(f) Loadb(As,Rt) ! 160: #define Loadzx_Rt(f) Loadbzx(As,Rt) ! 161: /* fetch */ ! 162: #define Fetch_Rd_P(f) Loadb(Ad,Rd); Inc(Ad) ! 163: #define Fetch_Rd_D(f) Dec(Ad); Loadb(Ad,Rd) ! 164: #define Fetch_Rd(f) Loadb(Ad,Rd) ! 165: /* store */ ! 166: #define Store_Rs_P Storeb(Rs,Ad); Inc(Ad) ! 167: #define Store_Rs_D Dec(Ad); Storeb(Rs,Ad) ! 168: #define Store_Rs Storeb(Rs,Ad) ! 169: ! 170: #define Inittab(t,s) ! 171: #define Initsh(a,b) ! 172: ! 173: /* emit code to look up n bits of Rt at offset o, answer byte in Rd */ ! 174: /* l is always 0 when WBITS==8 */ ! 175: #define Table_RdRt(o,n,l) \ ! 176: Mov(Rt,Rd); \ ! 177: tmp = 32-((o)+(n)); \ ! 178: if(tmp > 0) { \ ! 179: Shr(Rd,tmp); \ ! 180: } \ ! 181: Andd(((1<<(n))-1),Rd); \ ! 182: Imovzx(tab,Rd,Rd) ! 183: ! 184: #define Table_RsRt(o,n,l) \ ! 185: Mov(Rt,Rs); \ ! 186: tmp = 32-((o)+(n)); \ ! 187: if(tmp > 0) { \ ! 188: Shr(Rs,tmp); \ ! 189: } \ ! 190: Andd(((1<<(n))-1),Rs); \ ! 191: Imovzx(tab,Rs,Rs) ! 192: ! 193: /* emit code to assemble low n bits of Rd into offset o in low byte in Rs */ ! 194: #define Assemble(o,n) \ ! 195: if((o) == 0) { \ ! 196: Olsh_RsRd(8-(n)); \ ! 197: } else if((o) == 8-(n)) { \ ! 198: Or(Rd,Rs); \ ! 199: } else { \ ! 200: Oorlsh_RsRd(8-((o)+(n))); \ ! 201: } ! 202: ! 203: #define Assemblex(o,n) \ ! 204: if((o) == 0) { \ ! 205: Mov(Rs,Rd); \ ! 206: } else { \ ! 207: Shl(Rs,n); \ ! 208: Or(Rd,Rs); \ ! 209: } ! 210: ! 211: #define Nop ! 212: ! 213: #ifdef TEST ! 214: #define Extrainit \ ! 215: Movd(lrand(),Rs); \ ! 216: Movd(lrand(),Rd); \ ! 217: Movd(lrand(),Rt); \ ! 218: Movd(lrand(),Ri); \ ! 219: Movd(lrand(),RX) ! 220: #else ! 221: #define Extrainit ! 222: #endif ! 223: ! 224: #define Execandfree(memstart,onstack) \ ! 225: (*(void (*)(void))memstart)(); \ ! 226: if(!onstack) \ ! 227: bbfree(memstart, (p-memstart) * sizeof(Type)); ! 228: ! 229: /* emit code seq at fi (at most 3 shorts) */ ! 230: #define Emitop \ ! 231: *(long *)p = *(long *)fi; \ ! 232: *(short *)(p+4) = *(short *)(((char *)fi)+4); \ ! 233: p = (Type*)(((char *)p)+fin) ! 234: ! 235: typedef struct Fstr ! 236: { ! 237: short fetchs; ! 238: short fetchd; ! 239: int n; ! 240: short instr[4]; ! 241: } Fstr; ! 242: ! 243: Fstr fstr[16] = ! 244: { ! 245: [0] 0,0,2, /* Zero */ ! 246: { XOR(Rs,Rs), 0, 0, 0 }, ! 247: ! 248: [1] 1,1,4, /* DnorS */ ! 249: { OR(Rd,Rs), NOT(Rs), 0, 0}, ! 250: ! 251: [2] 1,1,4, /* DandnotS */ ! 252: { NOT(Rs), AND(Rd,Rs), 0, 0}, ! 253: ! 254: [3] 1,0,2, /* notS */ ! 255: { NOT(Rs), 0, 0, 0}, ! 256: ! 257: [4] 1,1,6, /* notDandS */ ! 258: { NOT(Rs), OR(Rd,Rs), NOT(Rs), 0}, ! 259: ! 260: [5] 0,1,4, /* notD */ ! 261: { MOV(Rd,Rs), NOT(Rs), 0, 0}, ! 262: ! 263: [6] 1,1,2, /* DxorS */ ! 264: { XOR(Rd,Rs), 0, 0, 0}, ! 265: ! 266: [7] 1,1,4, /* DnandS */ ! 267: { AND(Rd,Rs), NOT(Rs), 0, 0}, ! 268: ! 269: [8] 1,1,2, /* DandS */ ! 270: { AND(Rd,Rs), 0, 0, 0}, ! 271: ! 272: [9] 1,1,4, /* DxnorS */ ! 273: { XOR(Rd,Rs), NOT(Rs), 0, 0}, ! 274: ! 275: [10] 0,1,2, /* D */ ! 276: { MOV(Rd,Rs), 0, 0, 0}, ! 277: ! 278: [11] 1,1,4, /* DornotS */ ! 279: { NOT(Rs), OR(Rd,Rs), 0, 0}, ! 280: ! 281: [12] 1,0,0, /* S */ ! 282: { 0, 0, 0, 0}, ! 283: ! 284: [13] 1,1,6, /* notDorS */ ! 285: { NOT(Rs), AND(Rd,Rs), NOT(Rs), 0}, ! 286: ! 287: [14] 1,1,2, /* DorS */ ! 288: { OR(Rd,Rs), 0, 0, 0}, ! 289: ! 290: [15] 0,0,4, /* F */ ! 291: { XOR(Rs,Rs), NOT(Rs), 0, 0}, ! 292: }; ! 293: ! 294: #include "tabs.h" ! 295: ! 296: static uchar *tabs[4][4] = ! 297: { ! 298: { 0, (uchar*)tab01b, 0, (uchar*)tab03b}, ! 299: {(uchar*)tab10b, 0, 0, 0}, ! 300: { 0, 0, 0, 0}, ! 301: {(uchar*)tab30b, 0, 0, 0}, ! 302: }; ! 303: ! 304: static uchar tabosiz[4][4] = /* size in bytes of entries */ ! 305: { ! 306: { 0, 1, 0, 1}, ! 307: { 1, 0, 0, 0}, ! 308: { 0, 0, 0, 0}, ! 309: { 1, 0, 0, 0}, ! 310: }; ! 311: ! 312: enum { ! 313: Progmax = 1000, /* max number of bytes in a bitblt prog */ ! 314: Progmaxnoconv = 168, /* max number when not converting */ ! 315: }; ! 316: ! 317: #ifdef TEST ! 318: void ! 319: prprog(void) ! 320: { ! 321: abort(); /* use db */ ! 322: } ! 323: ! 324: void ! 325: bbexec(void (*memstart)(void), int len, int onstack) ! 326: { ! 327: memstart(); ! 328: if(!onstack) ! 329: bbfree(memstart, len); ! 330: } ! 331: ! 332: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.