WebSVN – planix.SVN – Blame – /os/trunk/sys/src/cmd/qc/peep.c

Rev	Author	Line No.	Line
2	-	1	`#include "gc.h"`
		2
		3	`void`
		4	`peep(void)`
		5	`{`
		6	`Reg r, r1, *r2;`
		7	`Prog p, p1;`
		8	`int t;`
		9	`/*`
		10	`* complete R structure`
		11	`*/`
		12	`t = 0;`
		13	`for(r=firstr; r!=R; r=r1) {`
		14	`r1 = r->link;`
		15	`if(r1 == R)`
		16	`break;`
		17	`p = r->prog->link;`
		18	`while(p != r1->prog)`
		19	`switch(p->as) {`
		20	`default:`
		21	`r2 = rega();`
		22	`r->link = r2;`
		23	`r2->link = r1;`
		24
		25	`r2->prog = p;`
		26	`r2->p1 = r;`
		27	`r->s1 = r2;`
		28	`r2->s1 = r1;`
		29	`r1->p1 = r2;`
		30
		31	`r = r2;`
		32	`t++;`
		33
		34	`case ADATA:`
		35	`case AGLOBL:`
		36	`case ANAME:`
		37	`case ASIGNAME:`
		38	`p = p->link;`
		39	`}`
		40	`}`
		41
		42	`loop1:`
		43	`t = 0;`
		44	`for(r=firstr; r!=R; r=r->link) {`
		45	`p = r->prog;`
		46	`if(p->as == AMOVW \|\| p->as == AFMOVS \|\| p->as == AFMOVD)`
		47	`if(regtyp(&p->to)) {`
		48	`if(regtyp(&p->from))`
		49	`if(p->from.type == p->to.type) {`
		50	`if(copyprop(r)) {`
		51	`excise(r);`
		52	`t++;`
		53	`} else`
		54	`if(subprop(r) && copyprop(r)) {`
		55	`excise(r);`
		56	`t++;`
		57	`}`
		58	`}`
		59	`if(regzer(&p->from))`
		60	`if(p->to.type == D_REG) {`
		61	`p->from.type = D_REG;`
		62	`p->from.reg = REGZERO;`
		63	`if(copyprop(r)) {`
		64	`excise(r);`
		65	`t++;`
		66	`} else`
		67	`if(subprop(r) && copyprop(r)) {`
		68	`excise(r);`
		69	`t++;`
		70	`}`
		71	`}`
		72	`}`
		73	`}`
		74	`if(t)`
		75	`goto loop1;`
		76	`/*`
		77	`* look for MOVB x,R; MOVB R,R`
		78	`*/`
		79	`for(r=firstr; r!=R; r=r->link) {`
		80	`p = r->prog;`
		81	`switch(p->as) {`
		82	`default:`
		83	`continue;`
		84	`case AMOVH:`
		85	`case AMOVHZ:`
		86	`case AMOVB:`
		87	`case AMOVBZ:`
		88	`if(p->to.type != D_REG)`
		89	`continue;`
		90	`break;`
		91	`}`
		92	`r1 = r->link;`
		93	`if(r1 == R)`
		94	`continue;`
		95	`p1 = r1->prog;`
		96	`if(p1->as != p->as)`
		97	`continue;`
		98	`if(p1->from.type != D_REG \|\| p1->from.reg != p->to.reg)`
		99	`continue;`
		100	`if(p1->to.type != D_REG \|\| p1->to.reg != p->to.reg)`
		101	`continue;`
		102	`excise(r1);`
		103	`}`
		104
		105	`if(debug['Q'] > 1)`
		106	`return; /* allow following code improvement to be suppressed */`
		107
		108	`/*`
		109	`* look for OP x,y,R; CMP R, $0 -> OPCC x,y,R`
		110	`* when OP can set condition codes correctly`
		111	`*/`
		112	`for(r=firstr; r!=R; r=r->link) {`
		113	`p = r->prog;`
		114	`switch(p->as) {`
		115	`case ACMP:`
		116	`if(!regzer(&p->to))`
		117	`continue;`
		118	`r1 = r->s1;`
		119	`if(r1 == R)`
		120	`continue;`
		121	`switch(r1->prog->as) {`
		122	`default:`
		123	`continue;`
		124	`case ABCL:`
		125	`case ABC:`
		126	`/* the conditions can be complex and these are currently little used */`
		127	`continue;`
		128	`case ABEQ:`
		129	`case ABGE:`
		130	`case ABGT:`
		131	`case ABLE:`
		132	`case ABLT:`
		133	`case ABNE:`
		134	`case ABVC:`
		135	`case ABVS:`
		136	`break;`
		137	`}`
		138	`r1 = r;`
		139	`do`
		140	`r1 = uniqp(r1);`
		141	`while (r1 != R && r1->prog->as == ANOP);`
		142	`if(r1 == R)`
		143	`continue;`
		144	`p1 = r1->prog;`
		145	`if(p1->to.type != D_REG \|\| p1->to.reg != p->from.reg)`
		146	`continue;`
		147	`switch(p1->as) {`
		148	`case ASUB:`
		149	`case AADD:`
		150	`case AXOR:`
		151	`case AOR:`
		152	`/* irregular instructions */`
		153	`if(p1->from.type == D_CONST)`
		154	`continue;`
		155	`break;`
		156	`}`
		157	`switch(p1->as) {`
		158	`default:`
		159	`continue;`
		160	`case AMOVW:`
		161	`if(p1->from.type != D_REG)`
		162	`continue;`
		163	`continue;`
		164	`case AANDCC:`
		165	`case AANDNCC:`
		166	`case AORCC:`
		167	`case AORNCC:`
		168	`case AXORCC:`
		169	`case ASUBCC:`
		170	`case ASUBECC:`
		171	`case ASUBMECC:`
		172	`case ASUBZECC:`
		173	`case AADDCC:`
		174	`case AADDCCC:`
		175	`case AADDECC:`
		176	`case AADDMECC:`
		177	`case AADDZECC:`
		178	`case ARLWMICC:`
		179	`case ARLWNMCC:`
		180	`t = p1->as;`
		181	`break;`
		182	`/* don't deal with floating point instructions for now */`
		183	`/*`
		184	`case AFABS: t = AFABSCC; break;`
		185	`case AFADD: t = AFADDCC; break;`
		186	`case AFADDS: t = AFADDSCC; break;`
		187	`case AFCTIW: t = AFCTIWCC; break;`
		188	`case AFCTIWZ: t = AFCTIWZCC; break;`
		189	`case AFDIV: t = AFDIVCC; break;`
		190	`case AFDIVS: t = AFDIVSCC; break;`
		191	`case AFMADD: t = AFMADDCC; break;`
		192	`case AFMADDS: t = AFMADDSCC; break;`
		193	`case AFMOVD: t = AFMOVDCC; break;`
		194	`case AFMSUB: t = AFMSUBCC; break;`
		195	`case AFMSUBS: t = AFMSUBSCC; break;`
		196	`case AFMUL: t = AFMULCC; break;`
		197	`case AFMULS: t = AFMULSCC; break;`
		198	`case AFNABS: t = AFNABSCC; break;`
		199	`case AFNEG: t = AFNEGCC; break;`
		200	`case AFNMADD: t = AFNMADDCC; break;`
		201	`case AFNMADDS: t = AFNMADDSCC; break;`
		202	`case AFNMSUB: t = AFNMSUBCC; break;`
		203	`case AFNMSUBS: t = AFNMSUBSCC; break;`
		204	`case AFRSP: t = AFRSPCC; break;`
		205	`case AFSUB: t = AFSUBCC; break;`
		206	`case AFSUBS: t = AFSUBSCC; break;`
		207	`case ACNTLZW: t = ACNTLZWCC; break;`
		208	`case AMTFSB0: t = AMTFSB0CC; break;`
		209	`case AMTFSB1: t = AMTFSB1CC; break;`
		210	`*/`
		211	`case AADD: t = AADDCC; break;`
		212	`case AADDV: t = AADDVCC; break;`
		213	`case AADDC: t = AADDCCC; break;`
		214	`case AADDCV: t = AADDCVCC; break;`
		215	`case AADDME: t = AADDMECC; break;`
		216	`case AADDMEV: t = AADDMEVCC; break;`
		217	`case AADDE: t = AADDECC; break;`
		218	`case AADDEV: t = AADDEVCC; break;`
		219	`case AADDZE: t = AADDZECC; break;`
		220	`case AADDZEV: t = AADDZEVCC; break;`
		221	`case AAND: t = AANDCC; break;`
		222	`case AANDN: t = AANDNCC; break;`
		223	`case ADIVW: t = ADIVWCC; break;`
		224	`case ADIVWV: t = ADIVWVCC; break;`
		225	`case ADIVWU: t = ADIVWUCC; break;`
		226	`case ADIVWUV: t = ADIVWUVCC; break;`
		227	`case AEQV: t = AEQVCC; break;`
		228	`case AEXTSB: t = AEXTSBCC; break;`
		229	`case AEXTSH: t = AEXTSHCC; break;`
		230	`case AMULHW: t = AMULHWCC; break;`
		231	`case AMULHWU: t = AMULHWUCC; break;`
		232	`case AMULLW: t = AMULLWCC; break;`
		233	`case AMULLWV: t = AMULLWVCC; break;`
		234	`case ANAND: t = ANANDCC; break;`
		235	`case ANEG: t = ANEGCC; break;`
		236	`case ANEGV: t = ANEGVCC; break;`
		237	`case ANOR: t = ANORCC; break;`
		238	`case AOR: t = AORCC; break;`
		239	`case AORN: t = AORNCC; break;`
		240	`case AREM: t = AREMCC; break;`
		241	`case AREMV: t = AREMVCC; break;`
		242	`case AREMU: t = AREMUCC; break;`
		243	`case AREMUV: t = AREMUVCC; break;`
		244	`case ARLWMI: t = ARLWMICC; break;`
		245	`case ARLWNM: t = ARLWNMCC; break;`
		246	`case ASLW: t = ASLWCC; break;`
		247	`case ASRAW: t = ASRAWCC; break;`
		248	`case ASRW: t = ASRWCC; break;`
		249	`case ASUB: t = ASUBCC; break;`
		250	`case ASUBV: t = ASUBVCC; break;`
		251	`case ASUBC: t = ASUBCCC; break;`
		252	`case ASUBCV: t = ASUBCVCC; break;`
		253	`case ASUBME: t = ASUBMECC; break;`
		254	`case ASUBMEV: t = ASUBMEVCC; break;`
		255	`case ASUBE: t = ASUBECC; break;`
		256	`case ASUBEV: t = ASUBEVCC; break;`
		257	`case ASUBZE: t = ASUBZECC; break;`
		258	`case ASUBZEV: t = ASUBZEVCC; break;`
		259	`case AXOR: t = AXORCC; break;`
		260	`break;`
		261	`}`
		262	`if(debug['Q'])`
		263	`print("cmp %P; %P -> ", p1, p);`
		264	`p1->as = t;`
		265	`if(debug['Q'])`
		266	`print("%P\n", p1);`
		267	`excise(r);`
		268	`continue;`
		269	`}`
		270	`}`
		271	`}`
		272
		273	`void`
		274	`excise(Reg *r)`
		275	`{`
		276	`Prog *p;`
		277
		278	`p = r->prog;`
		279	`p->as = ANOP;`
		280	`p->from = zprog.from;`
		281	`p->from3 = zprog.from3;`
		282	`p->to = zprog.to;`
		283	`p->reg = zprog.reg; /**/`
		284	`}`
		285
		286	`Reg*`
		287	`uniqp(Reg *r)`
		288	`{`
		289	`Reg *r1;`
		290
		291	`r1 = r->p1;`
		292	`if(r1 == R) {`
		293	`r1 = r->p2;`
		294	`if(r1 == R \|\| r1->p2link != R)`
		295	`return R;`
		296	`} else`
		297	`if(r->p2 != R)`
		298	`return R;`
		299	`return r1;`
		300	`}`
		301
		302	`Reg*`
		303	`uniqs(Reg *r)`
		304	`{`
		305	`Reg *r1;`
		306
		307	`r1 = r->s1;`
		308	`if(r1 == R) {`
		309	`r1 = r->s2;`
		310	`if(r1 == R)`
		311	`return R;`
		312	`} else`
		313	`if(r->s2 != R)`
		314	`return R;`
		315	`return r1;`
		316	`}`
		317
		318	`/*`
		319	`* if the system forces R0 to be zero,`
		320	`* convert references to $0 to references to R0.`
		321	`*/`
		322	`regzer(Adr *a)`
		323	`{`
		324	`if(R0ISZERO) {`
		325	`if(a->type == D_CONST)`
		326	`if(a->sym == S)`
		327	`if(a->offset == 0)`
		328	`return 1;`
		329	`if(a->type == D_REG)`
		330	`if(a->reg == REGZERO)`
		331	`return 1;`
		332	`}`
		333	`return 0;`
		334	`}`
		335
		336	`regtyp(Adr *a)`
		337	`{`
		338
		339	`if(a->type == D_REG) {`
		340	`if(!R0ISZERO \|\| a->reg != REGZERO)`
		341	`return 1;`
		342	`return 0;`
		343	`}`
		344	`if(a->type == D_FREG)`
		345	`return 1;`
		346	`return 0;`
		347	`}`
		348
		349	`/*`
		350	`* the idea is to substitute`
		351	`* one register for another`
		352	`* from one MOV to another`
		353	`* MOV a, R0`
		354	`* ADD b, R0 / no use of R1`
		355	`* MOV R0, R1`
		356	`* would be converted to`
		357	`* MOV a, R1`
		358	`* ADD b, R1`
		359	`* MOV R1, R0`
		360	`* hopefully, then the former or latter MOV`
		361	`* will be eliminated by copy propagation.`
		362	`*/`
		363	`int`
		364	`subprop(Reg *r0)`
		365	`{`
		366	`Prog *p;`
		367	`Adr v1, v2;`
		368	`Reg *r;`
		369	`int t;`
		370
		371	`p = r0->prog;`
		372	`v1 = &p->from;`
		373	`if(!regtyp(v1))`
		374	`return 0;`
		375	`v2 = &p->to;`
		376	`if(!regtyp(v2))`
		377	`return 0;`
		378	`for(r=uniqp(r0); r!=R; r=uniqp(r)) {`
		379	`if(uniqs(r) == R)`
		380	`break;`
		381	`p = r->prog;`
		382	`switch(p->as) {`
		383	`case ABL:`
		384	`return 0;`
		385
		386	`case AADD:`
		387	`case AADDC:`
		388	`case AADDCC:`
		389	`case AADDE:`
		390	`case AADDECC:`
		391	`case ASUB:`
		392	`case ASUBCC:`
		393	`case ASUBC:`
		394	`case ASUBCCC:`
		395	`case ASUBE:`
		396	`case ASUBECC:`
		397	`case ASLW:`
		398	`case ASLWCC:`
		399	`case ASRW:`
		400	`case ASRWCC:`
		401	`case ASRAW:`
		402	`case ASRAWCC:`
		403	`case AOR:`
		404	`case AORCC:`
		405	`case AORN:`
		406	`case AORNCC:`
		407	`case AAND:`
		408	`case AANDCC:`
		409	`case AANDN:`
		410	`case AANDNCC:`
		411	`case ANAND:`
		412	`case ANANDCC:`
		413	`case ANOR:`
		414	`case ANORCC:`
		415	`case AXOR:`
		416	`case AXORCC:`
		417	`case AMULHW:`
		418	`case AMULHWU:`
		419	`case AMULLW:`
		420	`case ADIVW:`
		421	`case ADIVWU:`
		422	`case AREM:`
		423	`case AREMU:`
		424	`case ARLWNM:`
		425	`case ARLWNMCC:`
		426
		427	`case AFADD:`
		428	`case AFADDS:`
		429	`case AFSUB:`
		430	`case AFSUBS:`
		431	`case AFMUL:`
		432	`case AFMULS:`
		433	`case AFDIV:`
		434	`case AFDIVS:`
		435	`if(p->to.type == v1->type)`
		436	`if(p->to.reg == v1->reg) {`
		437	`if(p->reg == NREG)`
		438	`p->reg = p->to.reg;`
		439	`goto gotit;`
		440	`}`
		441	`break;`
		442
		443	`case AADDME:`
		444	`case AADDMECC:`
		445	`case AADDZE:`
		446	`case AADDZECC:`
		447	`case ASUBME:`
		448	`case ASUBMECC:`
		449	`case ASUBZE:`
		450	`case ASUBZECC:`
		451	`case ANEG:`
		452	`case ANEGCC:`
		453	`case AFNEG:`
		454	`case AFNEGCC:`
		455	`case AFMOVS:`
		456	`case AFMOVD:`
		457	`case AMOVW:`
		458	`if(p->to.type == v1->type)`
		459	`if(p->to.reg == v1->reg)`
		460	`goto gotit;`
		461	`break;`
		462	`}`
		463	`if(copyau(&p->from, v2) \|\|`
		464	`copyau1(p, v2) \|\|`
		465	`copyau(&p->to, v2))`
		466	`break;`
		467	`if(copysub(&p->from, v1, v2, 0) \|\|`
		468	`copysub1(p, v1, v2, 0) \|\|`
		469	`copysub(&p->to, v1, v2, 0))`
		470	`break;`
		471	`}`
		472	`return 0;`
		473
		474	`gotit:`
		475	`copysub(&p->to, v1, v2, 1);`
		476	`if(debug['P']) {`
		477	`print("gotit: %D->%D\n%P", v1, v2, r->prog);`
		478	`if(p->from.type == v2->type)`
		479	`print(" excise");`
		480	`print("\n");`
		481	`}`
		482	`for(r=uniqs(r); r!=r0; r=uniqs(r)) {`
		483	`p = r->prog;`
		484	`copysub(&p->from, v1, v2, 1);`
		485	`copysub1(p, v1, v2, 1);`
		486	`copysub(&p->to, v1, v2, 1);`
		487	`if(debug['P'])`
		488	`print("%P\n", r->prog);`
		489	`}`
		490	`t = v1->reg;`
		491	`v1->reg = v2->reg;`
		492	`v2->reg = t;`
		493	`if(debug['P'])`
		494	`print("%P last\n", r->prog);`
		495	`return 1;`
		496	`}`
		497
		498	`/*`
		499	`* The idea is to remove redundant copies.`
		500	`* v1->v2 F=0`
		501	`* (use v2 s/v2/v1/)*`
		502	`* set v1 F=1`
		503	`* use v2 return fail`
		504	`* -----------------`
		505	`* v1->v2 F=0`
		506	`* (use v2 s/v2/v1/)*`
		507	`* set v1 F=1`
		508	`* set v2 return success`
		509	`*/`
		510	`int`
		511	`copyprop(Reg *r0)`
		512	`{`
		513	`Prog *p;`
		514	`Adr v1, v2;`
		515	`Reg *r;`
		516
		517	`p = r0->prog;`
		518	`v1 = &p->from;`
		519	`v2 = &p->to;`
		520	`if(copyas(v1, v2))`
		521	`return 1;`
		522	`for(r=firstr; r!=R; r=r->link)`
		523	`r->active = 0;`
		524	`return copy1(v1, v2, r0->s1, 0);`
		525	`}`
		526
		527	`copy1(Adr v1, Adr v2, Reg *r, int f)`
		528	`{`
		529	`int t;`
		530	`Prog *p;`
		531
		532	`if(r->active) {`
		533	`if(debug['P'])`
		534	`print("act set; return 1\n");`
		535	`return 1;`
		536	`}`
		537	`r->active = 1;`
		538	`if(debug['P'])`
		539	`print("copy %D->%D f=%d\n", v1, v2, f);`
		540	`for(; r != R; r = r->s1) {`
		541	`p = r->prog;`
		542	`if(debug['P'])`
		543	`print("%P", p);`
		544	`if(!f && uniqp(r) == R) {`
		545	`f = 1;`
		546	`if(debug['P'])`
		547	`print("; merge; f=%d", f);`
		548	`}`
		549	`t = copyu(p, v2, A);`
		550	`switch(t) {`
		551	`case 2: /* rar, cant split */`
		552	`if(debug['P'])`
		553	`print("; %Drar; return 0\n", v2);`
		554	`return 0;`
		555
		556	`case 3: /* set */`
		557	`if(debug['P'])`
		558	`print("; %Dset; return 1\n", v2);`
		559	`return 1;`
		560
		561	`case 1: /* used, substitute */`
		562	`case 4: /* use and set */`
		563	`if(f) {`
		564	`if(!debug['P'])`
		565	`return 0;`
		566	`if(t == 4)`
		567	`print("; %Dused+set and f=%d; return 0\n", v2, f);`
		568	`else`
		569	`print("; %Dused and f=%d; return 0\n", v2, f);`
		570	`return 0;`
		571	`}`
		572	`if(copyu(p, v2, v1)) {`
		573	`if(debug['P'])`
		574	`print("; sub fail; return 0\n");`
		575	`return 0;`
		576	`}`
		577	`if(debug['P'])`
		578	`print("; sub%D/%D", v2, v1);`
		579	`if(t == 4) {`
		580	`if(debug['P'])`
		581	`print("; %Dused+set; return 1\n", v2);`
		582	`return 1;`
		583	`}`
		584	`break;`
		585	`}`
		586	`if(!f) {`
		587	`t = copyu(p, v1, A);`
		588	`if(!f && (t == 2 \|\| t == 3 \|\| t == 4)) {`
		589	`f = 1;`
		590	`if(debug['P'])`
		591	`print("; %Dset and !f; f=%d", v1, f);`
		592	`}`
		593	`}`
		594	`if(debug['P'])`
		595	`print("\n");`
		596	`if(r->s2)`
		597	`if(!copy1(v1, v2, r->s2, f))`
		598	`return 0;`
		599	`}`
		600	`return 1;`
		601	`}`
		602
		603	`/*`
		604	`* return`
		605	`* 1 if v only used (and substitute),`
		606	`* 2 if read-alter-rewrite`
		607	`* 3 if set`
		608	`* 4 if set and used`
		609	`* 0 otherwise (not touched)`
		610	`*/`
		611	`int`
		612	`copyu(Prog p, Adr v, Adr *s)`
		613	`{`
		614
		615	`switch(p->as) {`
		616
		617	`default:`
		618	`if(debug['P'])`
		619	`print(" (???)");`
		620	`return 2;`
		621
		622	`case ANOP: /* read, write */`
		623	`case AMOVW:`
		624	`case AMOVH:`
		625	`case AMOVHZ:`
		626	`case AMOVB:`
		627	`case AMOVBZ:`
		628
		629	`case ANEG:`
		630	`case ANEGCC:`
		631	`case AADDME:`
		632	`case AADDMECC:`
		633	`case AADDZE:`
		634	`case AADDZECC:`
		635	`case ASUBME:`
		636	`case ASUBMECC:`
		637	`case ASUBZE:`
		638	`case ASUBZECC:`
		639
		640	`case AFCTIW:`
		641	`case AFCTIWZ:`
		642	`case AFMOVS:`
		643	`case AFMOVD:`
		644	`case AFRSP:`
		645	`case AFNEG:`
		646	`case AFNEGCC:`
		647	`if(s != A) {`
		648	`if(copysub(&p->from, v, s, 1))`
		649	`return 1;`
		650	`if(!copyas(&p->to, v))`
		651	`if(copysub(&p->to, v, s, 1))`
		652	`return 1;`
		653	`return 0;`
		654	`}`
		655	`if(copyas(&p->to, v)) {`
		656	`if(copyau(&p->from, v))`
		657	`return 4;`
		658	`return 3;`
		659	`}`
		660	`if(copyau(&p->from, v))`
		661	`return 1;`
		662	`if(copyau(&p->to, v))`
		663	`return 1;`
		664	`return 0;`
		665
		666	`case ARLWMI: /* read read rar */`
		667	`case ARLWMICC:`
		668	`if(copyas(&p->to, v))`
		669	`return 2;`
		670	`/* fall through */`
		671
		672	`case AADD: /* read read write */`
		673	`case AADDC:`
		674	`case AADDE:`
		675	`case ASUB:`
		676	`case ASLW:`
		677	`case ASRW:`
		678	`case ASRAW:`
		679	`case AOR:`
		680	`case AORCC:`
		681	`case AORN:`
		682	`case AORNCC:`
		683	`case AAND:`
		684	`case AANDCC:`
		685	`case AANDN:`
		686	`case AANDNCC:`
		687	`case ANAND:`
		688	`case ANANDCC:`
		689	`case ANOR:`
		690	`case ANORCC:`
		691	`case AXOR:`
		692	`case AMULHW:`
		693	`case AMULHWU:`
		694	`case AMULLW:`
		695	`case ADIVW:`
		696	`case ADIVWU:`
		697	`case AREM:`
		698	`case AREMU:`
		699	`case ARLWNM:`
		700	`case ARLWNMCC:`
		701
		702	`case AFADDS:`
		703	`case AFADD:`
		704	`case AFSUBS:`
		705	`case AFSUB:`
		706	`case AFMULS:`
		707	`case AFMUL:`
		708	`case AFDIVS:`
		709	`case AFDIV:`
		710	`if(s != A) {`
		711	`if(copysub(&p->from, v, s, 1))`
		712	`return 1;`
		713	`if(copysub1(p, v, s, 1))`
		714	`return 1;`
		715	`if(!copyas(&p->to, v))`
		716	`if(copysub(&p->to, v, s, 1))`
		717	`return 1;`
		718	`return 0;`
		719	`}`
		720	`if(copyas(&p->to, v)) {`
		721	`if(p->reg == NREG)`
		722	`p->reg = p->to.reg;`
		723	`if(copyau(&p->from, v))`
		724	`return 4;`
		725	`if(copyau1(p, v))`
		726	`return 4;`
		727	`return 3;`
		728	`}`
		729	`if(copyau(&p->from, v))`
		730	`return 1;`
		731	`if(copyau1(p, v))`
		732	`return 1;`
		733	`if(copyau(&p->to, v))`
		734	`return 1;`
		735	`return 0;`
		736
		737	`case ABEQ:`
		738	`case ABGT:`
		739	`case ABGE:`
		740	`case ABLT:`
		741	`case ABLE:`
		742	`case ABNE:`
		743	`case ABVC:`
		744	`case ABVS:`
		745	`break;`
		746
		747	`case ACMP: /* read read */`
		748	`case ACMPU:`
		749	`case AFCMPO:`
		750	`case AFCMPU:`
		751	`if(s != A) {`
		752	`if(copysub(&p->from, v, s, 1))`
		753	`return 1;`
		754	`return copysub(&p->to, v, s, 1);`
		755	`}`
		756	`if(copyau(&p->from, v))`
		757	`return 1;`
		758	`if(copyau(&p->to, v))`
		759	`return 1;`
		760	`break;`
		761
		762	`case ABR: /* funny */`
		763	`if(s != A) {`
		764	`if(copysub(&p->to, v, s, 1))`
		765	`return 1;`
		766	`return 0;`
		767	`}`
		768	`if(copyau(&p->to, v))`
		769	`return 1;`
		770	`return 0;`
		771
		772	`case ARETURN: /* funny */`
		773	`if(v->type == D_REG)`
		774	`if(v->reg == REGRET)`
		775	`return 2;`
		776	`if(v->type == D_FREG)`
		777	`if(v->reg == FREGRET)`
		778	`return 2;`
		779
		780	`case ABL: /* funny */`
		781	`if(v->type == D_REG) {`
		782	`if(v->reg <= REGEXT && v->reg > exregoffset)`
		783	`return 2;`
		784	`if(v->reg == REGARG)`
		785	`return 2;`
		786	`}`
		787	`if(v->type == D_FREG) {`
		788	`if(v->reg <= FREGEXT && v->reg > exfregoffset)`
		789	`return 2;`
		790	`}`
		791
		792	`if(s != A) {`
		793	`if(copysub(&p->to, v, s, 1))`
		794	`return 1;`
		795	`return 0;`
		796	`}`
		797	`if(copyau(&p->to, v))`
		798	`return 4;`
		799	`return 3;`
		800
		801	`case ATEXT: /* funny */`
		802	`if(v->type == D_REG)`
		803	`if(v->reg == REGARG)`
		804	`return 3;`
		805	`return 0;`
		806	`}`
		807	`return 0;`
		808	`}`
		809
		810	`int`
		811	`a2type(Prog *p)`
		812	`{`
		813
		814	`switch(p->as) {`
		815	`case AADD:`
		816	`case AADDC:`
		817	`case AADDCC:`
		818	`case AADDCCC:`
		819	`case AADDE:`
		820	`case AADDECC:`
		821	`case AADDME:`
		822	`case AADDMECC:`
		823	`case AADDZE:`
		824	`case AADDZECC:`
		825	`case ASUB:`
		826	`case ASUBC:`
		827	`case ASUBCC:`
		828	`case ASUBCCC:`
		829	`case ASUBE:`
		830	`case ASUBECC:`
		831	`case ASUBME:`
		832	`case ASUBMECC:`
		833	`case ASUBZE:`
		834	`case ASUBZECC:`
		835	`case ASLW:`
		836	`case ASLWCC:`
		837	`case ASRW:`
		838	`case ASRWCC:`
		839	`case ASRAW:`
		840	`case ASRAWCC:`
		841	`case AOR:`
		842	`case AORCC:`
		843	`case AORN:`
		844	`case AORNCC:`
		845	`case AAND:`
		846	`case AANDCC:`
		847	`case AANDN:`
		848	`case AANDNCC:`
		849	`case AXOR:`
		850	`case AXORCC:`
		851	`case ANEG:`
		852	`case ANEGCC:`
		853	`case AMULHW:`
		854	`case AMULHWU:`
		855	`case AMULLW:`
		856	`case AMULLWCC:`
		857	`case ADIVW:`
		858	`case ADIVWCC:`
		859	`case ADIVWU:`
		860	`case ADIVWUCC:`
		861	`case AREM:`
		862	`case AREMCC:`
		863	`case AREMU:`
		864	`case AREMUCC:`
		865	`case ANAND:`
		866	`case ANANDCC:`
		867	`case ANOR:`
		868	`case ANORCC:`
		869	`case ARLWMI:`
		870	`case ARLWMICC:`
		871	`case ARLWNM:`
		872	`case ARLWNMCC:`
		873	`return D_REG;`
		874
		875	`case AFADDS:`
		876	`case AFADDSCC:`
		877	`case AFADD:`
		878	`case AFADDCC:`
		879	`case AFSUBS:`
		880	`case AFSUBSCC:`
		881	`case AFSUB:`
		882	`case AFSUBCC:`
		883	`case AFMULS:`
		884	`case AFMULSCC:`
		885	`case AFMUL:`
		886	`case AFMULCC:`
		887	`case AFDIVS:`
		888	`case AFDIVSCC:`
		889	`case AFDIV:`
		890	`case AFDIVCC:`
		891	`case AFNEG:`
		892	`case AFNEGCC:`
		893	`return D_FREG;`
		894	`}`
		895	`return D_NONE;`
		896	`}`
		897
		898	`/*`
		899	`* direct reference,`
		900	`* could be set/use depending on`
		901	`* semantics`
		902	`*/`
		903	`int`
		904	`copyas(Adr a, Adr v)`
		905	`{`
		906
		907	`if(regtyp(v))`
		908	`if(a->type == v->type)`
		909	`if(a->reg == v->reg)`
		910	`return 1;`
		911	`return 0;`
		912	`}`
		913
		914	`/*`
		915	`* either direct or indirect`
		916	`*/`
		917	`int`
		918	`copyau(Adr a, Adr v)`
		919	`{`
		920
		921	`if(copyas(a, v))`
		922	`return 1;`
		923	`if(v->type == D_REG)`
		924	`if(a->type == D_OREG)`
		925	`if(v->reg == a->reg)`
		926	`return 1;`
		927	`return 0;`
		928	`}`
		929
		930	`int`
		931	`copyau1(Prog p, Adr v)`
		932	`{`
		933
		934	`if(regtyp(v))`
		935	`if(p->from.type == v->type \|\| p->to.type == v->type)`
		936	`if(p->reg == v->reg) {`
		937	`if(a2type(p) != v->type)`
		938	`print("botch a2type %P\n", p);`
		939	`return 1;`
		940	`}`
		941	`return 0;`
		942	`}`
		943
		944	`/*`
		945	`* substitute s for v in a`
		946	`* return failure to substitute`
		947	`*/`
		948	`int`
		949	`copysub(Adr a, Adr v, Adr *s, int f)`
		950	`{`
		951
		952	`if(f)`
		953	`if(copyau(a, v))`
		954	`a->reg = s->reg;`
		955	`return 0;`
		956	`}`
		957
		958	`int`
		959	`copysub1(Prog p1, Adr v, Adr *s, int f)`
		960	`{`
		961
		962	`if(f)`
		963	`if(copyau1(p1, v))`
		964	`p1->reg = s->reg;`
		965	`return 0;`
		966	`}`

Subversion Repositories planix.SVN

(root)/os/trunk/sys/src/cmd/qc/peep.c – Rev 2