![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bbk.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 bbk.h CVS log | Up to [Plan 9 NeXT] / lucent / sys / src / libgnot |
1.1 ! root 1: typedef long Type; ! 2: ! 3: /* ! 4: * See the comments at the beginning of bb.c and bbc.h ! 5: * for an outline of how this bitblt works ! 6: ! 7: * Registers ! 8: * in addition to the registers of the abstract machine, ! 9: * we use RF to hold ~0 always, RX as a scratch register, ! 10: * Rc as a scratch register for forming constants, and ! 11: * AT to hold the address of the table given in Inittab. ! 12: */ ! 13: #define R0 0 ! 14: #define As 19 ! 15: #define Ad 20 ! 16: #define Rs 21 ! 17: #define Rd 22 ! 18: #define Rt 23 ! 19: #define Ru 24 ! 20: #define Ri 25 ! 21: #define Ro 26 ! 22: #define Rc 27 /* const temporary */ ! 23: #define RF 16 /* ~0 */ ! 24: #define RX 17 /* scratch */ ! 25: #define AT 18 /* conversion table */ ! 26: ! 27: /* ! 28: * Instructions ! 29: */ ! 30: /* Inst2a */ ! 31: #define SETHI 0x04 ! 32: /* Inst2b */ ! 33: #define BG 0x0A ! 34: /* Inst3 2 */ ! 35: #define ADD 0x00 ! 36: #define SUB 0x04 ! 37: #define AND 0x01 ! 38: #define OR 0x02 ! 39: #define XOR 0x03 ! 40: #define ANDN 0x05 ! 41: #define ORN 0x06 ! 42: #define SUBcc 0x14 ! 43: #define SLL 0x25 ! 44: #define SRL 0x26 ! 45: #define JMPL 0x38 ! 46: /* Inst3 3 */ ! 47: #define LD 0x00 ! 48: #define LDUB 0x01 ! 49: #define LDUH 0x02 ! 50: #define ST 0x04 ! 51: ! 52: /* ! 53: * Generate `a', `size' bits wide, into bit position `shift'. ! 54: * (to save execution time, the onus is on the caller to make sure that ! 55: * `a' fits in `size') ! 56: */ ! 57: #define SM(a,size,shift) ((a)<<(shift)) ! 58: ! 59: #define Inst2a(rd,op2,i) (SM(rd,5,25)|SM(op2,4,22)|SM(i,22,0)) ! 60: #define Inst2b(a,cond,op2,d) Inst2a(SM(a,1,4)|SM(cond,4,0), op2, d) ! 61: ! 62: #define Inst3X(op,rd,op3,rs1) (SM(op,2,30)|SM(rd,5,25)|SM(op3,6,19)|SM(rs1,5,14)) ! 63: #define Inst3a(op,rd,op3,rs1,i,asi,rs2) (Inst3X(op,rd,op3,rs1)|SM(i,1,13)|SM(asi,8,5)|SM(rs2,5,0)) ! 64: #define Inst3b(op,rd,op3,rs1,i,si) (Inst3X(op,rd,op3,rs1)|SM(i,1,13)|SM(si,13,0)) ! 65: #define Inst3c(op,rd,op3,rs1,opf,rs2) (Inst3X(op,rd,op3,rs1)|SM(opf,9,5)|SM(rs2,5,0)) ! 66: ! 67: #define OpConst(Rdst,Rsrc,op,c) /* Rdst = Rsrc op c */ \ ! 68: if(((ulong)(c)) <= 0xFFF) \ ! 69: *p++ = Inst3b(2,Rdst,op,Rsrc,1,(c)); \ ! 70: else { \ ! 71: RConst(Rc,(c)); \ ! 72: *p++ = Inst3a(2,Rdst,op,Rsrc,0,0,Rc); \ ! 73: } ! 74: ! 75: #define RConst(Rdst,c) /* Rdst = c; c is large */ \ ! 76: *p++ = Inst2a(Rdst,SETHI,((ulong)(c))>>10); \ ! 77: *p++ = Inst3b(2,Rdst,OR,Rdst,1,(c)&0x3FF) ! 78: ! 79: ! 80: /* ! 81: * Macros for assembling the operations of the abstract machine. ! 82: * Each assumes that ulong *p points to the next location where ! 83: * an instruction should be assembled. ! 84: * These macros can use RX as a scratch register, but no others. ! 85: * They can assume RF holds ~0 and R0 holds 0. ! 86: */ ! 87: ! 88: #define Ofield(c) *p++ = Inst3a(2,Rs,XOR,Rs,0,0,Rd); \ ! 89: RConst(Rc,(c)); \ ! 90: *p++ = Inst3a(2,Rs,AND,Rs,0,0,Rc); \ ! 91: *p++ = Inst3a(2,Rs,XOR,Rs,0,0,Rd) ! 92: ! 93: #define Olsha_RsRt *p++ = Inst3a(2,Rs,SLL,Rt,1,0,sha) ! 94: #define Olshb_RsRt *p++ = Inst3a(2,Rs,SLL,Rt,1,0,shb) ! 95: #define Olsh_RsRd(c) *p++ = Inst3a(2,Rs,SLL,Rd,1,0,(c)) ! 96: #define Olsh_RtRt(c) *p++ = Inst3a(2,Rt,SLL,Rt,1,0,(c)) ! 97: #define Olsha_RtRt *p++ = Inst3a(2,Rt,SLL,Rt,1,0,sha) ! 98: #define Olsha_RtRu *p++ = Inst3a(2,Rt,SLL,Ru,1,0,sha) ! 99: #define Olshb_RtRu *p++ = Inst3a(2,Rt,SLL,Ru,1,0,shb) ! 100: #define Orsha_RsRt *p++ = Inst3a(2,Rs,SRL,Rt,1,0,sha) ! 101: #define Orshb_RsRt *p++ = Inst3a(2,Rs,SRL,Rt,1,0,shb) ! 102: #define Orsha_RtRu *p++ = Inst3a(2,Rt,SRL,Ru,1,0,sha) ! 103: #define Orshb_RtRu *p++ = Inst3a(2,Rt,SRL,Ru,1,0,shb) ! 104: #define Oorlsha_RsRt *p++ = Inst3a(2,RX,SLL,Rt,1,0,sha); \ ! 105: *p++ = Inst3a(2,Rs,OR,Rs,0,0,RX) ! 106: #define Oorlshb_RsRt *p++ = Inst3a(2,RX,SLL,Rt,1,0,shb); \ ! 107: *p++ = Inst3a(2,Rs,OR,Rs,0,0,RX) ! 108: #define Oorlsh_RsRd(c) *p++ = Inst3a(2,RX,SLL,Rd,1,0,(c)); \ ! 109: *p++ = Inst3a(2,Rs,OR,Rs,0,0,RX) ! 110: #define Oorrsha_RsRt *p++ = Inst3a(2,RX,SRL,Rt,1,0,sha); \ ! 111: *p++ = Inst3a(2,Rs,OR,Rs,0,0,RX) ! 112: #define Oorrshb_RsRt *p++ = Inst3a(2,RX,SRL,Rt,1,0,shb); \ ! 113: *p++ = Inst3a(2,Rs,OR,Rs,0,0,RX) ! 114: #define Oorrsha_RtRu *p++ = Inst3a(2,RX,SRL,Ru,1,0,sha); \ ! 115: *p++ = Inst3a(2,Rt,OR,Rt,0,0,RX) ! 116: #define Oorrshb_RtRu *p++ = Inst3a(2,RX,SRL,Ru,1,0,shb); \ ! 117: *p++ = Inst3a(2,Rt,OR,Rt,0,0,RX) ! 118: #define Oor_RsRd *p++ = Inst3a(2,Rs,OR,Rd,0,0,Rs) ! 119: ! 120: #define Add_As(c) OpConst(As,As,ADD,(c)) ! 121: ! 122: #define Add_Ad(c) OpConst(Ad,Ad,ADD,(c)) ! 123: ! 124: #define Initsd(s,d) RConst(As,((ulong)(s))); \ ! 125: RConst(Ad,((ulong)(d))) ! 126: ! 127: #define Initsh(a,b) ! 128: ! 129: /* Put all ones in RF */ ! 130: #define Extrainit *p++ = Inst3b(2,RF,ORN,R0,1,0) ! 131: ! 132: #define Ilabel(c) RConst(Ri,(c)) ! 133: ! 134: #define Olabel(c) RConst(Ro,(c)) ! 135: ! 136: #define Iloop(lp) *p++ = Inst3b(2,Ri,SUBcc,Ri,1,1); \ ! 137: *p = Inst2b(0,BG,0x2,((lp)-p)&0x3FFFFF); p++; \ ! 138: Nop ! 139: ! 140: #define Oloop(lp) *p++ = Inst3b(2,Ro,SUBcc,Ro,1,1); \ ! 141: *p = Inst2b(0,BG,0x2,((lp)-p)&0x3FFFFF); p++; \ ! 142: Nop ! 143: ! 144: #define Orts *p++ = Inst3b(2,R0,JMPL,15,1,8); \ ! 145: Nop ! 146: ! 147: /* ! 148: * In the predecrement versions, it's as easy to do the decrement afterwards ! 149: * in the (virtual) delay slot, which will go faster on some versions ! 150: */ ! 151: ! 152: #define Load_Rs_P *p++ = Inst3b(3,Rs,LD,As,1,0); *p++ = Inst3b(2,As,ADD,As,1,4) ! 153: #define Load_Rt_P *p++ = Inst3b(3,Rt,LD,As,1,0); *p++ = Inst3b(2,As,ADD,As,1,4) ! 154: #define Loadzx_Rt_P *p++ = Inst3b(3,Rt,LD,As,1,0); *p++ = Inst3b(2,As,ADD,As,1,4) ! 155: #define Loador_Rt_P *p++ = Inst3b(3,Rt,LD,As,1,0); *p++ = Inst3b(2,As,ADD,As,1,4) ! 156: #define Load_Ru_P *p++ = Inst3b(3,Ru,LD,As,1,0); *p++ = Inst3b(2,As,ADD,As,1,4) ! 157: #define Load_Rd_D(f) *p++ = Inst3b(3,Rd,LD,As,1,(-4)&0x1FFF); *p++ = Inst3b(2,As,SUB,As,1,4) ! 158: #define Load_Rs_D(f) *p++ = Inst3b(3,Rs,LD,As,1,(-4)&0x1FFF); *p++ = Inst3b(2,As,SUB,As,1,4) ! 159: #define Load_Rt_D(f) *p++ = Inst3b(3,Rt,LD,As,1,(-4)&0x1FFF); *p++ = Inst3b(2,As,SUB,As,1,4) ! 160: #define Loadzx_Rt_D(f) *p++ = Inst3b(3,Rt,LD,As,1,(-4)&0x1FFF); *p++ = Inst3b(2,As,SUB,As,1,4) ! 161: #define Load_Rd(f) *p++ = Inst3b(3,Rd,LD,As,1,0) ! 162: #define Load_Rs(f) *p++ = Inst3b(3,Rs,LD,As,1,0) ! 163: #define Load_Rt(f) *p++ = Inst3b(3,Rt,LD,As,1,0) ! 164: #define Loadzx_Rt(f) *p++ = Inst3b(3,Rt,LD,As,1,0) ! 165: #define Fetch_Rd_P(f) *p++ = Inst3b(3,Rd,LD,Ad,1,0); *p++ = Inst3b(2,Ad,ADD,Ad,1,4) ! 166: #define Fetch_Rd_D(f) *p++ = Inst3b(3,Rd,LD,Ad,1,(-4)&0x1FFF); *p++ = Inst3b(2,Ad,SUB,Ad,1,4) ! 167: #define Fetch_Rd(f) *p++ = Inst3b(3,Rd,LD,Ad,1,0); ! 168: #define Store_Rs_P *p++ = Inst3b(3,Rs,ST,Ad,1,0); *p++ = Inst3b(2,Ad,ADD,Ad,1,4) ! 169: #define Store_Rs_D *p++ = Inst3b(3,Rs,ST,Ad,1,(-4)&0x1FFF); *p++ = Inst3b(2,Ad,SUB,Ad,1,4) ! 170: #define Store_Rs *p++ = Inst3b(3,Rs,ST,Ad,1,0) ! 171: #define Nop *p++ = Inst3a(2,R0,OR,R0,0,0,R0) ! 172: ! 173: #define Inittab(t,s) RConst(AT,((ulong)(t))) ! 174: ! 175: /* emit code to look up n bits at offset o; table entries are 1<<l bytes long */ ! 176: #define Table_RdRt(o,n,l) \ ! 177: tmp = 32-((o)+(n))-(l); \ ! 178: if(tmp >= 0) \ ! 179: *p++ = Inst3a(2,Rd,SRL,Rt,1,0,tmp); \ ! 180: else if((l) > 0) \ ! 181: *p++ = Inst3a(2,Rd,SLL,Rt,1,0,l); \ ! 182: else \ ! 183: *p++ = Inst3a(2,Rd,ADD,Rt,0,0,R0); \ ! 184: *p++ = Inst3b(2,Rd,AND,Rd,1,((1<<(n))-1)<<(l)); \ ! 185: if(osiz==1) *p++ = Inst3b(3,Rd,LDUB,Rd,0,AT); \ ! 186: else if(osiz==2) *p++ = Inst3b(3,Rd,LDUH,Rd,0,AT); \ ! 187: else *p++ = Inst3b(3,Rd,LD,Rd,0,AT); \ ! 188: ! 189: #define Table_RsRt(o,n,l) \ ! 190: tmp = 32-((o)+(n))-(l); \ ! 191: *p++ = Inst3a(2,Rs,SRL,Rt,1,0,tmp); \ ! 192: if(tmp >= 0) \ ! 193: *p++ = Inst3a(2,Rs,SRL,Rt,1,0,tmp); \ ! 194: else if((l) > 0) \ ! 195: *p++ = Inst3a(2,Rs,SLL,Rt,1,0,l); \ ! 196: else \ ! 197: *p++ = Inst3a(2,Rs,ADD,Rt,0,0,R0); \ ! 198: if(osiz==1) *p++ = Inst3b(3,Rs,LDUB,Rs,0,AT); \ ! 199: else if(osiz==2) *p++ = Inst3b(3,Rs,LDUH,Rs,0,AT); \ ! 200: else *p++ = Inst3b(3,Rs,LD,Rs,0,AT); \ ! 201: ! 202: /* emit code to assemble low n bits of Rd into offset o in Rs */ ! 203: #define Assemble(o,n) \ ! 204: if((o) == 0) { \ ! 205: Olsh_RsRd(32-(n)); \ ! 206: } else if((o) == 32-(n)) { \ ! 207: *p++ = Inst3a(2,Rs,OR,Rs,0,0,Rd); \ ! 208: } else { \ ! 209: Oorlsh_RsRd(32-((o)+(n))); \ ! 210: } ! 211: ! 212: /* emit code to assemble low n bits of Rd into offset o in Rs. ! 213: this works by shifting Rd as we go, it only works if ! 214: the whole word will eventually be filled */ ! 215: #define Assemblex(o,n) \ ! 216: if((o) == 0) { \ ! 217: *p++ = Inst3a(2,Rs,OR,Rd,0,0,R0); \ ! 218: } else { \ ! 219: *p++ = Inst3a(2,Rs,SLL,Rs,1,0,n); \ ! 220: *p++ = Inst3a(2,Rs,OR,Rd,0,0,Rs); \ ! 221: } ! 222: ! 223: #define Execandfree(memstart,onstack) \ ! 224: (*(void (*)(void))memstart)(); \ ! 225: if(!onstack) \ ! 226: bbfree(memstart, (p-memstart) * sizeof(Type)); ! 227: ! 228: #define Emitop \ ! 229: p[0] = fi[0]; \ ! 230: p[1] = fi[1]; \ ! 231: p = (Type*)(((char *)p)+fin) ! 232: ! 233: typedef struct Fstr ! 234: { ! 235: char fetchs; ! 236: char fetchd; ! 237: short n; ! 238: Type instr[2]; ! 239: } Fstr; ! 240: ! 241: Fstr fstr[16] = ! 242: { ! 243: [0] 0,0,4, /* Zero */ ! 244: { Inst3a(2,Rs,ADD,R0,0,0,R0), 0 }, ! 245: ! 246: [1] 1,1,8, /* DnorS */ ! 247: { Inst3a(2,Rs,OR,Rs,0,0,Rd), Inst3a(2,Rs,XOR,Rs,0,0,RF) }, ! 248: ! 249: [2] 1,1,4, /* DandnotS */ ! 250: { Inst3a(2,Rs,ANDN,Rd,0,0,Rs), 0 }, ! 251: ! 252: [3] 1,0,4, /* notS */ ! 253: { Inst3a(2,Rs,XOR,Rs,0,0,RF), 0 }, ! 254: ! 255: [4] 1,1,4, /* notDandS */ ! 256: { Inst3a(2,Rs,ANDN,Rs,0,0,Rd), 0 }, ! 257: ! 258: [5] 0,1,4, /* notD */ ! 259: { Inst3a(2,Rs,XOR,Rd,0,0,RF), 0 }, ! 260: ! 261: [6] 1,1,4, /* DxorS */ ! 262: { Inst3a(2,Rs,XOR,Rd,0,0,Rs), 0 }, ! 263: ! 264: [7] 1,1,8, /* DnandS */ ! 265: { Inst3a(2,Rs,AND,Rd,0,0,Rs), Inst3a(2,Rs,XOR,Rs,0,0,RF) }, ! 266: ! 267: [8] 1,1,4, /* DandS */ ! 268: { Inst3a(2,Rs,AND,Rd,0,0,Rs), 0 }, ! 269: ! 270: [9] 1,1,8, /* DxnorS */ ! 271: { Inst3a(2,Rs,XOR,Rd,0,0,Rs), Inst3a(2,Rs,XOR,Rs,0,0,RF) }, ! 272: ! 273: [10] 0,1,4, /* D */ ! 274: { Inst3a(2,Rs,ADD,Rd,0,0,R0), 0 }, ! 275: ! 276: [11] 1,1,4, /* DornotS */ ! 277: { Inst3a(2,Rs,ORN,Rd,0,0,Rs), 0 }, ! 278: ! 279: [12] 1,0,0, /* S */ ! 280: {0, 0}, ! 281: ! 282: [13] 1,1,4, /* notDorS */ ! 283: { Inst3a(2,Rs,ORN,Rs,0,0,Rd), 0 }, ! 284: ! 285: [14] 1,1,4, /* DorS */ ! 286: { Inst3a(2,Rs,OR,Rd,0,0,Rs), 0 }, ! 287: ! 288: [15] 0,0,4, /* F */ ! 289: { Inst3a(2,Rs,OR,R0,0,0,RF), 0 }, ! 290: }; ! 291: ! 292: #include "tabs.h" ! 293: static uchar *tabs[4][4] = ! 294: { ! 295: { 0, (uchar*)tab01, (uchar*)tab02, (uchar*)tab03}, ! 296: {(uchar*)tab10, 0, (uchar*)tab12, (uchar*)tab13}, ! 297: {(uchar*)tab20, (uchar*)tab21, 0, (uchar*)tab23}, ! 298: {(uchar*)tab30, (uchar*)tab31, (uchar*)tab32, 0}, ! 299: }; ! 300: ! 301: static uchar tabosiz[4][4] = /* size in bytes of entries */ ! 302: { ! 303: { 0, 2, 4, 4}, ! 304: { 1, 0, 2, 4}, ! 305: { 1, 1, 0, 2}, ! 306: { 1, 1, 1, 0}, ! 307: }; ! 308: ! 309: enum { ! 310: Progmax = 1000, /* max number of bytes in a bitblt prog */ ! 311: Progmaxnoconv = 70, /* max number of Type units when no conversion */ ! 312: }; ! 313: ! 314: ! 315: #ifdef TEST ! 316: void ! 317: prprog(void) ! 318: { ! 319: abort(); /* use db */ ! 320: } ! 321: ! 322: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.