WebSVN – planix.SVN – Blame – /os/branches/planix-v0/sys/src/cmd/ql/span.c

Rev	Author	Line No.	Line
2	-	1	`#include "l.h"`
		2	`#define r0iszero 1`
		3
		4	`void`
		5	`span(void)`
		6	`{`
		7	`Prog p, q;`
		8	`Sym *setext;`
		9	`Optab *o;`
		10	`int m, bflag;`
		11	`long c, otxt;`
		12
		13	`if(debug['v'])`
		14	`Bprint(&bso, "%5.2f span\n", cputime());`
		15	`Bflush(&bso);`
		16
		17	`bflag = 0;`
		18	`c = INITTEXT;`
		19	`otxt = c;`
		20	`for(p = firstp; p != P; p = p->link) {`
		21	`p->pc = c;`
		22	`o = oplook(p);`
		23	`m = o->size;`
		24	`if(m == 0) {`
		25	`if(p->as == ATEXT) {`
		26	`curtext = p;`
		27	`autosize = p->to.offset + 4;`
		28	`if(p->from3.type == D_CONST) {`
		29	`if(p->from3.offset & 3)`
		30	`diag("illegal origin\n%P", p);`
		31	`if(c > p->from3.offset)`
		32	`diag("passed origin (#%lux)\n%P", c, p);`
		33	`else`
		34	`c = p->from3.offset;`
		35	`p->pc = c;`
		36	`}`
		37	`if(p->from.sym != S)`
		38	`p->from.sym->value = c;`
		39	`/* need passes to resolve branches? */`
		40	`if(c-otxt >= (1L<<15))`
		41	`bflag = c;`
		42	`otxt = c;`
		43	`continue;`
		44	`}`
		45	`if(p->as != ANOP)`
		46	`diag("zero-width instruction\n%P", p);`
		47	`continue;`
		48	`}`
		49	`c += m;`
		50	`}`
		51
		52	`/*`
		53	`* if any procedure is large enough to`
		54	`* generate a large SBRA branch, then`
		55	`* generate extra passes putting branches`
		56	`* around jmps to fix. this is rare.`
		57	`*/`
		58	`while(bflag) {`
		59	`if(debug['v'])`
		60	`Bprint(&bso, "%5.2f span1\n", cputime());`
		61	`bflag = 0;`
		62	`c = INITTEXT;`
		63	`for(p = firstp; p != P; p = p->link) {`
		64	`p->pc = c;`
		65	`o = oplook(p);`
		66	`if((o->type == 16 \|\| o->type == 17) && p->cond) {`
		67	`otxt = p->cond->pc - c;`
		68	`if(otxt < -(1L<<16)+10 \|\| otxt >= (1L<<15)-10) {`
		69	`q = prg();`
		70	`q->link = p->link;`
		71	`p->link = q;`
		72	`q->as = ABR;`
		73	`q->to.type = D_BRANCH;`
		74	`q->cond = p->cond;`
		75	`p->cond = q;`
		76	`q = prg();`
		77	`q->link = p->link;`
		78	`p->link = q;`
		79	`q->as = ABR;`
		80	`q->to.type = D_BRANCH;`
		81	`q->cond = q->link->link;`
		82	`addnop(p->link);`
		83	`addnop(p);`
		84	`bflag = 1;`
		85	`}`
		86	`}`
		87	`m = o->size;`
		88	`if(m == 0) {`
		89	`if(p->as == ATEXT) {`
		90	`curtext = p;`
		91	`autosize = p->to.offset + 4;`
		92	`if(p->from.sym != S)`
		93	`p->from.sym->value = c;`
		94	`continue;`
		95	`}`
		96	`if(p->as != ANOP)`
		97	`diag("zero-width instruction\n%P", p);`
		98	`continue;`
		99	`}`
		100	`c += m;`
		101	`}`
		102	`}`
		103
		104	`c = rnd(c, 8);`
		105
		106	`setext = lookup("etext", 0);`
		107	`if(setext != S) {`
		108	`setext->value = c;`
		109	`textsize = c - INITTEXT;`
		110	`}`
		111	`if(INITRND)`
		112	`INITDAT = rnd(c, INITRND);`
		113	`if(debug['v'])`
		114	`Bprint(&bso, "tsize = %lux\n", textsize);`
		115	`Bflush(&bso);`
		116	`}`
		117
		118	`void`
		119	`xdefine(char *p, int t, long v)`
		120	`{`
		121	`Sym *s;`
		122
		123	`s = lookup(p, 0);`
		124	`if(s->type == 0 \|\| s->type == SXREF) {`
		125	`s->type = t;`
		126	`s->value = v;`
		127	`}`
		128	`}`
		129
		130	`long`
		131	`regoff(Adr *a)`
		132	`{`
		133
		134	`instoffset = 0;`
		135	`aclass(a);`
		136	`return instoffset;`
		137	`}`
		138
		139	`int`
		140	`aclass(Adr *a)`
		141	`{`
		142	`Sym *s;`
		143	`int t;`
		144
		145	`switch(a->type) {`
		146	`case D_NONE:`
		147	`return C_NONE;`
		148
		149	`case D_REG:`
		150	`return C_REG;`
		151
		152	`case D_FREG:`
		153	`return C_FREG;`
		154
		155	`case D_CREG:`
		156	`return C_CREG;`
		157
		158	`case D_SPR:`
		159	`if(a->offset == D_LR)`
		160	`return C_LR;`
		161	`if(a->offset == D_XER)`
		162	`return C_XER;`
		163	`if(a->offset == D_CTR)`
		164	`return C_CTR;`
		165	`return C_SPR;`
		166
		167	`case D_DCR:`
		168	`return C_SPR;`
		169
		170	`case D_SREG:`
		171	`return C_SREG;`
		172
		173	`case D_FPSCR:`
		174	`return C_FPSCR;`
		175
		176	`case D_MSR:`
		177	`return C_MSR;`
		178
		179	`case D_OREG:`
		180	`switch(a->name) {`
		181	`case D_EXTERN:`
		182	`case D_STATIC:`
		183	`if(a->sym == S)`
		184	`break;`
		185	`t = a->sym->type;`
		186	`if(t == 0 \|\| t == SXREF) {`
		187	`diag("undefined external: %s in %s",`
		188	`a->sym->name, TNAME);`
		189	`a->sym->type = SDATA;`
		190	`}`
		191	`if(dlm){`
		192	`instoffset = a->sym->value + a->offset;`
		193	`switch(a->sym->type){`
		194	`case STEXT:`
		195	`case SLEAF:`
		196	`case SCONST:`
		197	`case SUNDEF:`
		198	`break;`
		199	`default:`
		200	`instoffset += INITDAT;`
		201	`}`
		202	`return C_ADDR;`
		203	`}`
		204	`instoffset = a->sym->value + a->offset - BIG;`
		205	`if(instoffset >= -BIG && instoffset < BIG)`
		206	`return C_SEXT;`
		207	`return C_LEXT;`
		208	`case D_AUTO:`
		209	`instoffset = autosize + a->offset;`
		210	`if(instoffset >= -BIG && instoffset < BIG)`
		211	`return C_SAUTO;`
		212	`return C_LAUTO;`
		213
		214	`case D_PARAM:`
		215	`instoffset = autosize + a->offset + 4L;`
		216	`if(instoffset >= -BIG && instoffset < BIG)`
		217	`return C_SAUTO;`
		218	`return C_LAUTO;`
		219	`case D_NONE:`
		220	`instoffset = a->offset;`
		221	`if(instoffset == 0)`
		222	`return C_ZOREG;`
		223	`if(instoffset >= -BIG && instoffset < BIG)`
		224	`return C_SOREG;`
		225	`return C_LOREG;`
		226	`}`
		227	`return C_GOK;`
		228
		229	`case D_OPT:`
		230	`instoffset = a->offset & 31L;`
		231	`if(a->name == D_NONE)`
		232	`return C_SCON;`
		233	`return C_GOK;`
		234
		235	`case D_CONST:`
		236	`switch(a->name) {`
		237
		238	`case D_NONE:`
		239	`instoffset = a->offset;`
		240	`consize:`
		241	`if(instoffset >= 0) {`
		242	`if(r0iszero && instoffset == 0)`
		243	`return C_ZCON;`
		244	`if(instoffset <= 0x7fff)`
		245	`return C_SCON;`
		246	`if(instoffset <= 0xffff)`
		247	`return C_ANDCON;`
		248	`if((instoffset & 0xffff) == 0)`
		249	`return C_UCON;`
		250	`return C_LCON;`
		251	`}`
		252	`if(instoffset >= -0x8000)`
		253	`return C_ADDCON;`
		254	`if((instoffset & 0xffff) == 0)`
		255	`return C_UCON;`
		256	`return C_LCON;`
		257
		258	`case D_EXTERN:`
		259	`case D_STATIC:`
		260	`s = a->sym;`
		261	`if(s == S)`
		262	`break;`
		263	`t = s->type;`
		264	`if(t == 0 \|\| t == SXREF) {`
		265	`diag("undefined external: %s in %s",`
		266	`s->name, TNAME);`
		267	`s->type = SDATA;`
		268	`}`
		269	`if(s->type == STEXT \|\| s->type == SLEAF \|\| s->type == SUNDEF) {`
		270	`instoffset = s->value + a->offset;`
		271	`return C_LCON;`
		272	`}`
		273	`if(s->type == SCONST) {`
		274	`instoffset = s->value + a->offset;`
		275	`if(dlm)`
		276	`return C_LCON;`
		277	`goto consize;`
		278	`}`
		279	`if(!dlm){`
		280	`instoffset = s->value + a->offset - BIG;`
		281	`if(instoffset >= -BIG && instoffset < BIG && instoffset != 0)`
		282	`return C_SECON;`
		283	`}`
		284	`instoffset = s->value + a->offset + INITDAT;`
		285	`if(dlm)`
		286	`return C_LCON;`
		287	`/* not sure why this barfs */`
		288	`return C_LCON;`
		289	`/*`
		290	`if(instoffset == 0)`
		291	`return C_ZCON;`
		292	`if(instoffset >= -0x8000 && instoffset <= 0xffff)`
		293	`return C_SCON;`
		294	`if((instoffset & 0xffff) == 0)`
		295	`return C_UCON;`
		296	`return C_LCON;`
		297	`*/`
		298
		299	`case D_AUTO:`
		300	`instoffset = autosize + a->offset;`
		301	`if(instoffset >= -BIG && instoffset < BIG)`
		302	`return C_SACON;`
		303	`return C_LACON;`
		304
		305	`case D_PARAM:`
		306	`instoffset = autosize + a->offset + 4L;`
		307	`if(instoffset >= -BIG && instoffset < BIG)`
		308	`return C_SACON;`
		309	`return C_LACON;`
		310	`}`
		311	`return C_GOK;`
		312
		313	`case D_BRANCH:`
		314	`return C_SBRA;`
		315	`}`
		316	`return C_GOK;`
		317	`}`
		318
		319	`Optab*`
		320	`oplook(Prog *p)`
		321	`{`
		322	`int a1, a2, a3, a4, r;`
		323	`char c1, c3, *c4;`
		324	`Optab o, e;`
		325
		326	`a1 = p->optab;`
		327	`if(a1)`
		328	`return optab+(a1-1);`
		329	`a1 = p->from.class;`
		330	`if(a1 == 0) {`
		331	`a1 = aclass(&p->from) + 1;`
		332	`p->from.class = a1;`
		333	`}`
		334	`a1--;`
		335	`a3 = p->from3.class;`
		336	`if(a3 == 0) {`
		337	`a3 = aclass(&p->from3) + 1;`
		338	`p->from3.class = a3;`
		339	`}`
		340	`a3--;`
		341	`a4 = p->to.class;`
		342	`if(a4 == 0) {`
		343	`a4 = aclass(&p->to) + 1;`
		344	`p->to.class = a4;`
		345	`}`
		346	`a4--;`
		347	`a2 = C_NONE;`
		348	`if(p->reg != NREG)`
		349	`a2 = C_REG;`
		350	`r = p->as;`
		351	`o = oprange[r].start;`
		352	`if(o == 0)`
		353	`o = oprange[r].stop; /* just generate an error */`
		354	`e = oprange[r].stop;`
		355	`c1 = xcmp[a1];`
		356	`c3 = xcmp[a3];`
		357	`c4 = xcmp[a4];`
		358	`for(; o<e; o++)`
		359	`if(o->a2 == a2)`
		360	`if(c1[o->a1])`
		361	`if(c3[o->a3])`
		362	`if(c4[o->a4]) {`
		363	`p->optab = (o-optab)+1;`
		364	`return o;`
		365	`}`
		366	`diag("illegal combination %A %R %R %R %R",`
		367	`p->as, a1, a2, a3, a4);`
		368	`if(1\|\|!debug['a'])`
		369	`prasm(p);`
		370	`if(o == 0)`
		371	`errorexit();`
		372	`return o;`
		373	`}`
		374
		375	`int`
		376	`cmp(int a, int b)`
		377	`{`
		378
		379	`if(a == b)`
		380	`return 1;`
		381	`switch(a) {`
		382	`case C_LCON:`
		383	`if(b == C_ZCON \|\| b == C_SCON \|\| b == C_UCON \|\| b == C_ADDCON \|\| b == C_ANDCON)`
		384	`return 1;`
		385	`break;`
		386	`case C_ADDCON:`
		387	`if(b == C_ZCON \|\| b == C_SCON)`
		388	`return 1;`
		389	`break;`
		390	`case C_ANDCON:`
		391	`if(b == C_ZCON \|\| b == C_SCON)`
		392	`return 1;`
		393	`break;`
		394	`case C_SPR:`
		395	`if(b == C_LR \|\| b == C_XER \|\| b == C_CTR)`
		396	`return 1;`
		397	`break;`
		398	`case C_UCON:`
		399	`if(b == C_ZCON)`
		400	`return 1;`
		401	`break;`
		402	`case C_SCON:`
		403	`if(b == C_ZCON)`
		404	`return 1;`
		405	`break;`
		406	`case C_LACON:`
		407	`if(b == C_SACON)`
		408	`return 1;`
		409	`break;`
		410	`case C_LBRA:`
		411	`if(b == C_SBRA)`
		412	`return 1;`
		413	`break;`
		414	`case C_LEXT:`
		415	`if(b == C_SEXT)`
		416	`return 1;`
		417	`break;`
		418	`case C_LAUTO:`
		419	`if(b == C_SAUTO)`
		420	`return 1;`
		421	`break;`
		422	`case C_REG:`
		423	`if(r0iszero && b == C_ZCON)`
		424	`return 1;`
		425	`break;`
		426	`case C_LOREG:`
		427	`if(b == C_ZOREG \|\| b == C_SOREG)`
		428	`return 1;`
		429	`break;`
		430	`case C_SOREG:`
		431	`if(b == C_ZOREG)`
		432	`return 1;`
		433	`break;`
		434
		435	`case C_ANY:`
		436	`return 1;`
		437	`}`
		438	`return 0;`
		439	`}`
		440
		441	`int`
		442	`ocmp(void a1, void a2)`
		443	`{`
		444	`Optab p1, p2;`
		445	`int n;`
		446
		447	`p1 = a1;`
		448	`p2 = a2;`
		449	`n = p1->as - p2->as;`
		450	`if(n)`
		451	`return n;`
		452	`n = p1->a1 - p2->a1;`
		453	`if(n)`
		454	`return n;`
		455	`n = p1->a2 - p2->a2;`
		456	`if(n)`
		457	`return n;`
		458	`n = p1->a3 - p2->a3;`
		459	`if(n)`
		460	`return n;`
		461	`n = p1->a4 - p2->a4;`
		462	`if(n)`
		463	`return n;`
		464	`return 0;`
		465	`}`
		466
		467	`void`
		468	`buildop(void)`
		469	`{`
		470	`int i, n, r;`
		471
		472	`for(i=0; i<C_NCLASS; i++)`
		473	`for(n=0; n<C_NCLASS; n++)`
		474	`xcmp[i][n] = cmp(n, i);`
		475	`for(n=0; optab[n].as != AXXX; n++)`
		476	`;`
		477	`qsort(optab, n, sizeof(optab[0]), ocmp);`
		478	`for(i=0; i<n; i++) {`
		479	`r = optab[i].as;`
		480	`oprange[r].start = optab+i;`
		481	`while(optab[i].as == r)`
		482	`i++;`
		483	`oprange[r].stop = optab+i;`
		484	`i--;`
		485
		486	`switch(r)`
		487	`{`
		488	`default:`
		489	`diag("unknown op in build: %A", r);`
		490	`errorexit();`
		491	`case ADCBF: /* unary indexed: op (b+a); op (b) */`
		492	`oprange[ADCBI] = oprange[r];`
		493	`oprange[ADCBST] = oprange[r];`
		494	`oprange[ADCBT] = oprange[r];`
		495	`oprange[ADCBTST] = oprange[r];`
		496	`oprange[ADCBZ] = oprange[r];`
		497	`oprange[AICBI] = oprange[r];`
		498	`break;`
		499	`case AECOWX: /* indexed store: op s,(b+a); op s,(b) */`
		500	`oprange[ASTWCCC] = oprange[r];`
		501	`break;`
		502	`case AREM: /* macro */`
		503	`oprange[AREMCC] = oprange[r];`
		504	`oprange[AREMV] = oprange[r];`
		505	`oprange[AREMVCC] = oprange[r];`
		506	`oprange[AREMU] = oprange[r];`
		507	`oprange[AREMUCC] = oprange[r];`
		508	`oprange[AREMUV] = oprange[r];`
		509	`oprange[AREMUVCC] = oprange[r];`
		510	`break;`
		511	`case ADIVW: /* op Rb[,Ra],Rd */`
		512	`oprange[AMULHW] = oprange[r];`
		513	`oprange[AMULHWCC] = oprange[r];`
		514	`oprange[AMULHWU] = oprange[r];`
		515	`oprange[AMULHWUCC] = oprange[r];`
		516	`oprange[AMULLWCC] = oprange[r];`
		517	`oprange[AMULLWVCC] = oprange[r];`
		518	`oprange[AMULLWV] = oprange[r];`
		519	`oprange[ADIVWCC] = oprange[r];`
		520	`oprange[ADIVWV] = oprange[r];`
		521	`oprange[ADIVWVCC] = oprange[r];`
		522	`oprange[ADIVWU] = oprange[r];`
		523	`oprange[ADIVWUCC] = oprange[r];`
		524	`oprange[ADIVWUV] = oprange[r];`
		525	`oprange[ADIVWUVCC] = oprange[r];`
		526	`oprange[AADDCC] = oprange[r];`
		527	`oprange[AADDCV] = oprange[r];`
		528	`oprange[AADDCVCC] = oprange[r];`
		529	`oprange[AADDV] = oprange[r];`
		530	`oprange[AADDVCC] = oprange[r];`
		531	`oprange[AADDE] = oprange[r];`
		532	`oprange[AADDECC] = oprange[r];`
		533	`oprange[AADDEV] = oprange[r];`
		534	`oprange[AADDEVCC] = oprange[r];`
		535	`oprange[ACRAND] = oprange[r];`
		536	`oprange[ACRANDN] = oprange[r];`
		537	`oprange[ACREQV] = oprange[r];`
		538	`oprange[ACRNAND] = oprange[r];`
		539	`oprange[ACRNOR] = oprange[r];`
		540	`oprange[ACROR] = oprange[r];`
		541	`oprange[ACRORN] = oprange[r];`
		542	`oprange[ACRXOR] = oprange[r];`
		543	`oprange[AMULCHW] = oprange[r];`
		544	`oprange[AMULCHWCC] = oprange[r];`
		545	`oprange[AMULCHWU] = oprange[r];`
		546	`oprange[AMULCHWUCC] = oprange[r];`
		547	`oprange[AMULHHW] = oprange[r];`
		548	`oprange[AMULHHWCC] = oprange[r];`
		549	`oprange[AMULHHWU] = oprange[r];`
		550	`oprange[AMULHHWUCC] = oprange[r];`
		551	`oprange[AMULLHW] = oprange[r];`
		552	`oprange[AMULLHWCC] = oprange[r];`
		553	`oprange[AMULLHWU] = oprange[r];`
		554	`oprange[AMULLHWUCC] = oprange[r];`
		555	`break;`
		556	`case AMACCHW: /* strictly 3 registers */`
		557	`oprange[AMACCHWCC] = oprange[r];`
		558	`oprange[AMACCHWS] = oprange[r];`
		559	`oprange[AMACCHWSCC] = oprange[r];`
		560	`oprange[AMACCHWSU] = oprange[r];`
		561	`oprange[AMACCHWSUCC] = oprange[r];`
		562	`oprange[AMACCHWSUV] = oprange[r];`
		563	`oprange[AMACCHWSUVCC] = oprange[r];`
		564	`oprange[AMACCHWSV] = oprange[r];`
		565	`oprange[AMACCHWSVCC] = oprange[r];`
		566	`oprange[AMACCHWU] = oprange[r];`
		567	`oprange[AMACCHWUCC] = oprange[r];`
		568	`oprange[AMACCHWUV] = oprange[r];`
		569	`oprange[AMACCHWUVCC] = oprange[r];`
		570	`oprange[AMACCHWV] = oprange[r];`
		571	`oprange[AMACCHWVCC] = oprange[r];`
		572	`oprange[AMACHHW] = oprange[r];`
		573	`oprange[AMACHHWCC] = oprange[r];`
		574	`oprange[AMACHHWS] = oprange[r];`
		575	`oprange[AMACHHWSCC] = oprange[r];`
		576	`oprange[AMACHHWSU] = oprange[r];`
		577	`oprange[AMACHHWSUCC] = oprange[r];`
		578	`oprange[AMACHHWSUV] = oprange[r];`
		579	`oprange[AMACHHWSUVCC] = oprange[r];`
		580	`oprange[AMACHHWSV] = oprange[r];`
		581	`oprange[AMACHHWSVCC] = oprange[r];`
		582	`oprange[AMACHHWU] = oprange[r];`
		583	`oprange[AMACHHWUCC] = oprange[r];`
		584	`oprange[AMACHHWUV] = oprange[r];`
		585	`oprange[AMACHHWUVCC] = oprange[r];`
		586	`oprange[AMACHHWV] = oprange[r];`
		587	`oprange[AMACHHWVCC] = oprange[r];`
		588	`oprange[AMACLHW] = oprange[r];`
		589	`oprange[AMACLHWCC] = oprange[r];`
		590	`oprange[AMACLHWS] = oprange[r];`
		591	`oprange[AMACLHWSCC] = oprange[r];`
		592	`oprange[AMACLHWSU] = oprange[r];`
		593	`oprange[AMACLHWSUCC] = oprange[r];`
		594	`oprange[AMACLHWSUV] = oprange[r];`
		595	`oprange[AMACLHWSUVCC] = oprange[r];`
		596	`oprange[AMACLHWSV] = oprange[r];`
		597	`oprange[AMACLHWSVCC] = oprange[r];`
		598	`oprange[AMACLHWU] = oprange[r];`
		599	`oprange[AMACLHWUCC] = oprange[r];`
		600	`oprange[AMACLHWUV] = oprange[r];`
		601	`oprange[AMACLHWUVCC] = oprange[r];`
		602	`oprange[AMACLHWV] = oprange[r];`
		603	`oprange[AMACLHWVCC] = oprange[r];`
		604	`oprange[ANMACCHW] = oprange[r];`
		605	`oprange[ANMACCHWCC] = oprange[r];`
		606	`oprange[ANMACCHWS] = oprange[r];`
		607	`oprange[ANMACCHWSCC] = oprange[r];`
		608	`oprange[ANMACCHWSV] = oprange[r];`
		609	`oprange[ANMACCHWSVCC] = oprange[r];`
		610	`oprange[ANMACCHWV] = oprange[r];`
		611	`oprange[ANMACCHWVCC] = oprange[r];`
		612	`oprange[ANMACHHW] = oprange[r];`
		613	`oprange[ANMACHHWCC] = oprange[r];`
		614	`oprange[ANMACHHWS] = oprange[r];`
		615	`oprange[ANMACHHWSCC] = oprange[r];`
		616	`oprange[ANMACHHWSV] = oprange[r];`
		617	`oprange[ANMACHHWSVCC] = oprange[r];`
		618	`oprange[ANMACHHWV] = oprange[r];`
		619	`oprange[ANMACHHWVCC] = oprange[r];`
		620	`oprange[ANMACLHW] = oprange[r];`
		621	`oprange[ANMACLHWCC] = oprange[r];`
		622	`oprange[ANMACLHWS] = oprange[r];`
		623	`oprange[ANMACLHWSCC] = oprange[r];`
		624	`oprange[ANMACLHWSV] = oprange[r];`
		625	`oprange[ANMACLHWSVCC] = oprange[r];`
		626	`oprange[ANMACLHWV] = oprange[r];`
		627	`oprange[ANMACLHWVCC] = oprange[r];`
		628	`break;`
		629	`case AMOVBZ: /* lbz, stz, rlwm(r/r), lhz, lha, stz, and x variants */`
		630	`oprange[AMOVH] = oprange[r];`
		631	`oprange[AMOVHZ] = oprange[r];`
		632	`break;`
		633	`case AMOVBZU: /* lbz[x]u, stb[x]u, lhz[x]u, lha[x]u, sth[u]x */`
		634	`oprange[AMOVHU] = oprange[r];`
		635	`oprange[AMOVHZU] = oprange[r];`
		636	`oprange[AMOVWU] = oprange[r];`
		637	`oprange[AMOVMW] = oprange[r];`
		638	`break;`
		639	`case AAND: /* logical op Rb,Rs,Ra; no literal */`
		640	`oprange[AANDN] = oprange[r];`
		641	`oprange[AANDNCC] = oprange[r];`
		642	`oprange[AEQV] = oprange[r];`
		643	`oprange[AEQVCC] = oprange[r];`
		644	`oprange[ANAND] = oprange[r];`
		645	`oprange[ANANDCC] = oprange[r];`
		646	`oprange[ANOR] = oprange[r];`
		647	`oprange[ANORCC] = oprange[r];`
		648	`oprange[AORCC] = oprange[r];`
		649	`oprange[AORN] = oprange[r];`
		650	`oprange[AORNCC] = oprange[r];`
		651	`oprange[AXORCC] = oprange[r];`
		652	`break;`
		653	`case AADDME: /* op Ra, Rd */`
		654	`oprange[AADDMECC] = oprange[r];`
		655	`oprange[AADDMEV] = oprange[r];`
		656	`oprange[AADDMEVCC] = oprange[r];`
		657	`oprange[AADDZE] = oprange[r];`
		658	`oprange[AADDZECC] = oprange[r];`
		659	`oprange[AADDZEV] = oprange[r];`
		660	`oprange[AADDZEVCC] = oprange[r];`
		661	`oprange[ASUBME] = oprange[r];`
		662	`oprange[ASUBMECC] = oprange[r];`
		663	`oprange[ASUBMEV] = oprange[r];`
		664	`oprange[ASUBMEVCC] = oprange[r];`
		665	`oprange[ASUBZE] = oprange[r];`
		666	`oprange[ASUBZECC] = oprange[r];`
		667	`oprange[ASUBZEV] = oprange[r];`
		668	`oprange[ASUBZEVCC] = oprange[r];`
		669	`break;`
		670	`case AADDC:`
		671	`oprange[AADDCCC] = oprange[r];`
		672	`break;`
		673	`case ABEQ:`
		674	`oprange[ABGE] = oprange[r];`
		675	`oprange[ABGT] = oprange[r];`
		676	`oprange[ABLE] = oprange[r];`
		677	`oprange[ABLT] = oprange[r];`
		678	`oprange[ABNE] = oprange[r];`
		679	`oprange[ABVC] = oprange[r];`
		680	`oprange[ABVS] = oprange[r];`
		681	`break;`
		682	`case ABR:`
		683	`oprange[ABL] = oprange[r];`
		684	`break;`
		685	`case ABC:`
		686	`oprange[ABCL] = oprange[r];`
		687	`break;`
		688	`case AEXTSB: /* op Rs, Ra */`
		689	`oprange[AEXTSBCC] = oprange[r];`
		690	`oprange[AEXTSH] = oprange[r];`
		691	`oprange[AEXTSHCC] = oprange[r];`
		692	`oprange[ACNTLZW] = oprange[r];`
		693	`oprange[ACNTLZWCC] = oprange[r];`
		694	`break;`
		695	`case AFABS: /* fop [s,]d */`
		696	`oprange[AFABSCC] = oprange[r];`
		697	`oprange[AFNABS] = oprange[r];`
		698	`oprange[AFNABSCC] = oprange[r];`
		699	`oprange[AFNEG] = oprange[r];`
		700	`oprange[AFNEGCC] = oprange[r];`
		701	`oprange[AFRSP] = oprange[r];`
		702	`oprange[AFRSPCC] = oprange[r];`
		703	`oprange[AFCTIW] = oprange[r];`
		704	`oprange[AFCTIWCC] = oprange[r];`
		705	`oprange[AFCTIWZ] = oprange[r];`
		706	`oprange[AFCTIWZCC] = oprange[r];`
		707	`oprange[AFRES] = oprange[r];`
		708	`oprange[AFRESCC] = oprange[r];`
		709	`oprange[AFRSQRTE] = oprange[r];`
		710	`oprange[AFRSQRTECC] = oprange[r];`
		711	`oprange[AFSQRT] = oprange[r];`
		712	`oprange[AFSQRTCC] = oprange[r];`
		713	`oprange[AFSQRTS] = oprange[r];`
		714	`oprange[AFSQRTSCC] = oprange[r];`
		715	`oprange[AFPRE] = oprange[r];`
		716	`oprange[AFPRSQRTE] = oprange[r];`
		717	`oprange[AFPABS] = oprange[r];`
		718	`oprange[AFPNEG] = oprange[r];`
		719	`oprange[AFPRSP] = oprange[r];`
		720	`oprange[AFPNABS] = oprange[r];`
		721	`oprange[AFSABS] = oprange[r];`
		722	`oprange[AFSNEG] = oprange[r];`
		723	`oprange[AFSNABS] = oprange[r];`
		724	`oprange[AFPCTIW] = oprange[r];`
		725	`oprange[AFPCTIWZ] = oprange[r];`
		726	`break;`
		727	`case AFADD:`
		728	`oprange[AFADDS] = oprange[r];`
		729	`oprange[AFADDCC] = oprange[r];`
		730	`oprange[AFADDSCC] = oprange[r];`
		731	`oprange[AFDIV] = oprange[r];`
		732	`oprange[AFDIVS] = oprange[r];`
		733	`oprange[AFDIVCC] = oprange[r];`
		734	`oprange[AFDIVSCC] = oprange[r];`
		735	`oprange[AFSUB] = oprange[r];`
		736	`oprange[AFSUBS] = oprange[r];`
		737	`oprange[AFSUBCC] = oprange[r];`
		738	`oprange[AFSUBSCC] = oprange[r];`
		739	`oprange[AFPADD] = oprange[r];`
		740	`oprange[AFPSUB] = oprange[r];`
		741	`break;`
		742	`case AFMADD:`
		743	`oprange[AFMADDCC] = oprange[r];`
		744	`oprange[AFMADDS] = oprange[r];`
		745	`oprange[AFMADDSCC] = oprange[r];`
		746	`oprange[AFMSUB] = oprange[r];`
		747	`oprange[AFMSUBCC] = oprange[r];`
		748	`oprange[AFMSUBS] = oprange[r];`
		749	`oprange[AFMSUBSCC] = oprange[r];`
		750	`oprange[AFNMADD] = oprange[r];`
		751	`oprange[AFNMADDCC] = oprange[r];`
		752	`oprange[AFNMADDS] = oprange[r];`
		753	`oprange[AFNMADDSCC] = oprange[r];`
		754	`oprange[AFNMSUB] = oprange[r];`
		755	`oprange[AFNMSUBCC] = oprange[r];`
		756	`oprange[AFNMSUBS] = oprange[r];`
		757	`oprange[AFNMSUBSCC] = oprange[r];`
		758	`oprange[AFSEL] = oprange[r];`
		759	`oprange[AFSELCC] = oprange[r];`
		760	`oprange[AFPSEL] = oprange[r];`
		761	`oprange[AFPMADD] = oprange[r];`
		762	`oprange[AFXMADD] = oprange[r];`
		763	`oprange[AFXCPMADD] = oprange[r];`
		764	`oprange[AFXCSMADD] = oprange[r];`
		765	`oprange[AFPNMADD] = oprange[r];`
		766	`oprange[AFXNMADD] = oprange[r];`
		767	`oprange[AFXCPNMADD] = oprange[r];`
		768	`oprange[AFXCSNMADD] = oprange[r];`
		769	`oprange[AFPMSUB] = oprange[r];`
		770	`oprange[AFXMSUB] = oprange[r];`
		771	`oprange[AFXCPMSUB] = oprange[r];`
		772	`oprange[AFXCSMSUB] = oprange[r];`
		773	`oprange[AFPNMSUB] = oprange[r];`
		774	`oprange[AFXNMSUB] = oprange[r];`
		775	`oprange[AFXCPNMSUB] = oprange[r];`
		776	`oprange[AFXCSNMSUB] = oprange[r];`
		777	`oprange[AFXCPNPMA] = oprange[r];`
		778	`oprange[AFXCSNPMA] = oprange[r];`
		779	`oprange[AFXCPNSMA] = oprange[r];`
		780	`oprange[AFXCSNSMA] = oprange[r];`
		781	`oprange[AFXCXNPMA] = oprange[r];`
		782	`oprange[AFXCXNSMA] = oprange[r];`
		783	`oprange[AFXCXMA] = oprange[r];`
		784	`oprange[AFXCXNMS] = oprange[r];`
		785	`break;`
		786	`case AFMUL:`
		787	`oprange[AFMULS] = oprange[r];`
		788	`oprange[AFMULCC] = oprange[r];`
		789	`oprange[AFMULSCC] = oprange[r];`
		790	`oprange[AFPMUL] = oprange[r];`
		791	`oprange[AFXMUL] = oprange[r];`
		792	`oprange[AFXPMUL] = oprange[r];`
		793	`oprange[AFXSMUL] = oprange[r];`
		794	`break;`
		795	`case AFCMPO:`
		796	`oprange[AFCMPU] = oprange[r];`
		797	`break;`
		798	`case AMTFSB0:`
		799	`oprange[AMTFSB0CC] = oprange[r];`
		800	`oprange[AMTFSB1] = oprange[r];`
		801	`oprange[AMTFSB1CC] = oprange[r];`
		802	`break;`
		803	`case ANEG: /* op [Ra,] Rd */`
		804	`oprange[ANEGCC] = oprange[r];`
		805	`oprange[ANEGV] = oprange[r];`
		806	`oprange[ANEGVCC] = oprange[r];`
		807	`break;`
		808	`case AOR: /* or/xor Rb,Rs,Ra; ori/xori $uimm,Rs,Ra; oris/xoris $uimm,Rs,Ra */`
		809	`oprange[AXOR] = oprange[r];`
		810	`break;`
		811	`case ASLW:`
		812	`oprange[ASLWCC] = oprange[r];`
		813	`oprange[ASRW] = oprange[r];`
		814	`oprange[ASRWCC] = oprange[r];`
		815	`break;`
		816	`case ASRAW: /* sraw Rb,Rs,Ra; srawi sh,Rs,Ra */`
		817	`oprange[ASRAWCC] = oprange[r];`
		818	`break;`
		819	`case ASUB: /* SUB Ra,Rb,Rd => subf Rd,ra,rb */`
		820	`oprange[ASUB] = oprange[r];`
		821	`oprange[ASUBCC] = oprange[r];`
		822	`oprange[ASUBV] = oprange[r];`
		823	`oprange[ASUBVCC] = oprange[r];`
		824	`oprange[ASUBCCC] = oprange[r];`
		825	`oprange[ASUBCV] = oprange[r];`
		826	`oprange[ASUBCVCC] = oprange[r];`
		827	`oprange[ASUBE] = oprange[r];`
		828	`oprange[ASUBECC] = oprange[r];`
		829	`oprange[ASUBEV] = oprange[r];`
		830	`oprange[ASUBEVCC] = oprange[r];`
		831	`break;`
		832	`case ASYNC:`
		833	`oprange[AISYNC] = oprange[r];`
		834	`break;`
		835	`case ARLWMI:`
		836	`oprange[ARLWMICC] = oprange[r];`
		837	`oprange[ARLWNM] = oprange[r];`
		838	`oprange[ARLWNMCC] = oprange[r];`
		839	`break;`
		840	`case AFMOVD:`
		841	`oprange[AFMOVDCC] = oprange[r];`
		842	`oprange[AFMOVDU] = oprange[r];`
		843	`oprange[AFMOVS] = oprange[r];`
		844	`oprange[AFMOVSU] = oprange[r];`
		845	`break;`
		846	`case AECIWX:`
		847	`oprange[ALWAR] = oprange[r];`
		848	`break;`
		849	`case ASYSCALL: /* just the op; flow of control */`
		850	`oprange[ARFI] = oprange[r];`
		851	`oprange[ARFCI] = oprange[r];`
		852	`break;`
		853	`case AMOVHBR:`
		854	`oprange[AMOVWBR] = oprange[r];`
		855	`break;`
		856	`case AFSMOVS: /* indexed floating loads and stores (fp2) */`
		857	`oprange[AFSMOVSU] = oprange[r];`
		858	`oprange[AFSMOVDU] = oprange[r];`
		859	`oprange[AFXMOVS] = oprange[r];`
		860	`oprange[AFXMOVSU] = oprange[r];`
		861	`oprange[AFXMOVDU] = oprange[r];`
		862	`oprange[AFPMOVS] = oprange[r];`
		863	`oprange[AFPMOVSU] = oprange[r];`
		864	`oprange[AFPMOVDU] = oprange[r];`
		865	`oprange[AFPMOVIW] = oprange[r];`
		866	`break;`
		867	`case AFPMOVD: /* indexed load/store and moves (fp2) */`
		868	`oprange[AFSMOVD] = oprange[r];`
		869	`oprange[AFXMOVD] = oprange[r];`
		870	`break;`
		871	`case AFMOVSPD: /* move between fp reg sets (fp2) */`
		872	`oprange[AFMOVPSD] = oprange[r];`
		873	`break;`
		874	`case AADD:`
		875	`case AANDCC: /* and. Rb,Rs,Ra; andi. $uimm,Rs,Ra; andis. $uimm,Rs,Ra */`
		876	`case ACMP:`
		877	`case ACMPU:`
		878	`case AEIEIO:`
		879	`case ALSW:`
		880	`case AMOVB: /* macro: move byte with sign extension */`
		881	`case AMOVBU: /* macro: move byte with sign extension & update */`
		882	`case AMOVW:`
		883	`case AMOVFL:`
		884	`case AMULLW: /* op $s[,r2],r3; op r1[,r2],r3; no cc/v */`
		885	`case ASUBC: /* op r1,$s,r3; op r1[,r2],r3 */`
		886	`case ASTSW:`
		887	`case ATLBIE:`
		888	`case ATW:`
		889	`case AWORD:`
		890	`case ANOP:`
		891	`case ATEXT:`
		892	`break;`
		893	`}`
		894	`}`
		895	`}`
		896
		897	`enum{`
		898	`ABSD = 0,`
		899	`ABSU = 1,`
		900	`RELD = 2,`
		901	`RELU = 3,`
		902	`};`
		903
		904	`int modemap[8] = { 0, 1, -1, 2, 3, 4, 5, 6};`
		905
		906	`typedef struct Reloc Reloc;`
		907
		908	`struct Reloc`
		909	`{`
		910	`int n;`
		911	`int t;`
		912	`uchar *m;`
		913	`ulong *a;`
		914	`};`
		915
		916	`Reloc rels;`
		917
		918	`static void`
		919	`grow(Reloc *r)`
		920	`{`
		921	`int t;`
		922	`uchar m, nm;`
		923	`ulong a, na;`
		924
		925	`t = r->t;`
		926	`r->t += 64;`
		927	`m = r->m;`
		928	`a = r->a;`
		929	`r->m = nm = malloc(r->t*sizeof(uchar));`
		930	`r->a = na = malloc(r->t*sizeof(ulong));`
		931	`memmove(nm, m, t*sizeof(uchar));`
		932	`memmove(na, a, t*sizeof(ulong));`
		933	`free(m);`
		934	`free(a);`
		935	`}`
		936
		937	`void`
		938	`dynreloc(Sym *s, long v, int abs, int split, int sext)`
		939	`{`
		940	`int i, k, n;`
		941	`uchar *m;`
		942	`ulong *a;`
		943	`Reloc *r;`
		944
		945	`if(v&3)`
		946	`diag("bad relocation address");`
		947	`v >>= 2;`
		948	`if(s->type == SUNDEF)`
		949	`k = abs ? ABSU : RELU;`
		950	`else`
		951	`k = abs ? ABSD : RELD;`
		952	`if(split)`
		953	`k += 4;`
		954	`if(sext)`
		955	`k += 2;`
		956	`/* Bprint(&bso, "R %s a=%ld(%lx) %d\n", s->name, a, a, k); */`
		957	`k = modemap[k];`
		958	`r = &rels;`
		959	`n = r->n;`
		960	`if(n >= r->t)`
		961	`grow(r);`
		962	`m = r->m;`
		963	`a = r->a;`
		964	`for(i = n; i > 0; i--){`
		965	`if(v < a[i-1]){ /* happens occasionally for data */`
		966	`m[i] = m[i-1];`
		967	`a[i] = a[i-1];`
		968	`}`
		969	`else`
		970	`break;`
		971	`}`
		972	`m[i] = k;`
		973	`a[i] = v;`
		974	`r->n++;`
		975	`}`
		976
		977	`static int`
		978	`sput(char *s)`
		979	`{`
		980	`char *p;`
		981
		982	`p = s;`
		983	`while(*s)`
		984	`cput(*s++);`
		985	`cput(0);`
		986	`return s-p+1;`
		987	`}`
		988
		989	`void`
		990	`asmdyn()`
		991	`{`
		992	`int i, n, t, c;`
		993	`Sym *s;`
		994	`ulong la, ra, *a;`
		995	`vlong off;`
		996	`uchar *m;`
		997	`Reloc *r;`
		998
		999	`cflush();`
		1000	`off = seek(cout, 0, 1);`
		1001	`lput(0);`
		1002	`t = 0;`
		1003	`lput(imports);`
		1004	`t += 4;`
		1005	`for(i = 0; i < NHASH; i++)`
		1006	`for(s = hash[i]; s != S; s = s->link)`
		1007	`if(s->type == SUNDEF){`
		1008	`lput(s->sig);`
		1009	`t += 4;`
		1010	`t += sput(s->name);`
		1011	`}`
		1012
		1013	`la = 0;`
		1014	`r = &rels;`
		1015	`n = r->n;`
		1016	`m = r->m;`
		1017	`a = r->a;`
		1018	`lput(n);`
		1019	`t += 4;`
		1020	`for(i = 0; i < n; i++){`
		1021	`ra = *a-la;`
		1022	`if(*a < la)`
		1023	`diag("bad relocation order");`
		1024	`if(ra < 256)`
		1025	`c = 0;`
		1026	`else if(ra < 65536)`
		1027	`c = 1;`
		1028	`else`
		1029	`c = 2;`
		1030	`cput((c<<6)\|*m++);`
		1031	`t++;`
		1032	`if(c == 0){`
		1033	`cput(ra);`
		1034	`t++;`
		1035	`}`
		1036	`else if(c == 1){`
		1037	`wput(ra);`
		1038	`t += 2;`
		1039	`}`
		1040	`else{`
		1041	`lput(ra);`
		1042	`t += 4;`
		1043	`}`
		1044	`la = *a++;`
		1045	`}`
		1046
		1047	`cflush();`
		1048	`seek(cout, off, 0);`
		1049	`lput(t);`
		1050
		1051	`if(debug['v']){`
		1052	`Bprint(&bso, "import table entries = %d\n", imports);`
		1053	`Bprint(&bso, "export table entries = %d\n", exports);`
		1054	`}`
		1055	`}`

Subversion Repositories planix.SVN

(root)/os/branches/planix-v0/sys/src/cmd/ql/span.c – Rev 9