Context Navigation

source: mainline/uspace/app/pcc/arch/powerpc/code.c@ a7de7182

Visit:

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export

Last change on this file since a7de7182 was a7de7182, checked in by Jiří Zárevúcky <zarevucky.jiri@…>, 14 years ago
Added pcc source tree (contents of pcc-1.0.0.tgz)
Property mode set to `100644`
File size: 36.2 KB

Rev	Line
[a7de7182]	1	/* $Id: code.c,v 1.23 2010/11/26 17:06:31 ragge Exp $ */
	2	/*
	3	* Copyright (c) 2003 Anders Magnusson (ragge@ludd.luth.se).
	4	* All rights reserved.
	5	*
	6	* Redistribution and use in source and binary forms, with or without
	7	* modification, are permitted provided that the following conditions
	8	* are met:
	9	* 1. Redistributions of source code must retain the above copyright
	10	* notice, this list of conditions and the following disclaimer.
	11	* 2. Redistributions in binary form must reproduce the above copyright
	12	* notice, this list of conditions and the following disclaimer in the
	13	* documentation and/or other materials provided with the distribution.
	14	* 3. The name of the author may not be used to endorse or promote products
	15	* derived from this software without specific prior written permission
	16	*
	17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
	18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
	19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
	20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
	21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
	26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	27	*/
	28
	29	#include <assert.h>
	30	#include <stdlib.h>
	31
	32	#include "pass1.h"
	33	#include "pass2.h"
	34
	35	static void genswitch_bintree(int num, TWORD ty, struct swents **p, int n);
	36
	37	#if 0
	38	static void genswitch_table(int num, struct swents **p, int n);
	39	static void genswitch_mrst(int num, struct swents **p, int n);
	40	#endif
	41
	42	int lastloc = -1;
	43	static int rvnr;
	44
	45	/*
	46	* Define everything needed to print out some data (or text).
	47	* This means segment, alignment, visibility, etc.
	48	*/
	49	void
	50	defloc(struct symtab *sp)
	51	{
	52	#if defined(ELFABI)
	53	static char *loctbl[] = { "text", "data", "rodata" };
	54	#elif defined(MACHOABI)
	55	static char *loctbl[] = { "text", "data", "const_data" };
	56	#endif
	57	TWORD t;
	58	char *name;
	59	int s, n;
	60
	61	if (sp == NULL) {
	62	lastloc = -1;
	63	return;
	64	}
	65	t = sp->stype;
	66	s = ISFTN(t) ? PROG : ISCON(cqual(t, sp->squal)) ? RDATA : DATA;
	67	if (s != lastloc)
	68	printf(" .%s\n", loctbl[s]);
	69	lastloc = s;
	70
	71	if (s == PROG)
	72	n = 2;
	73	else if ((n = ispow2(talign(t, sp->sap) / SZCHAR)) == -1)
	74	cerror("defalign: n != 2^i");
	75	printf(" .p2align %d\n", n);
	76
	77	name = sp->soname ? sp->soname : exname(sp->sname);
	78	if (sp->sclass == EXTDEF)
	79	printf(" .globl %s\n", name);
	80	if (sp->slevel == 0)
	81	printf("%s:\n", name);
	82	else
	83	printf(LABFMT ":\n", sp->soffset);
	84	}
	85
	86	/* Put a symbol in a temporary
	87	* used by bfcode() and its helpers
	88	*/
	89	static void
	90	putintemp(struct symtab *sym)
	91	{
	92	NODE *p;
	93
	94	p = tempnode(0, sym->stype, sym->sdf, sym->sap);
	95	p = buildtree(ASSIGN, p, nametree(sym));
	96	sym->soffset = regno(p->n_left);
	97	sym->sflags \|= STNODE;
	98	ecomp(p);
	99	}
	100
	101	/* setup a 64-bit parameter (double/ldouble/longlong)
	102	* used by bfcode() */
	103	static void
	104	param_64bit(struct symtab sym, int argofsp, int dotemps)
	105	{
	106	int argofs = *argofsp;
	107	NODE p, q;
	108	int navail;
	109
	110	#if ALLONGLONG == 64
	111	/* alignment */
	112	++argofs;
	113	argofs &= ~1;
	114	#endif
	115
	116	navail = NARGREGS - argofs;
	117
	118	if (navail < 2) {
	119	/* half in and half out of the registers */
	120	q = block(REG, NIL, NIL, INT, 0, MKAP(INT));
	121	regno(q) = R3 + argofs;
	122	p = block(REG, NIL, NIL, INT, 0, MKAP(INT));
	123	regno(p) = FPREG;
	124	p = block(PLUS, p, bcon(sym->soffset/SZCHAR), PTR+INT, 0, MKAP(INT));
	125	p = block(UMUL, p, NIL, INT, 0, MKAP(INT));
	126	} else {
	127	q = block(REG, NIL, NIL, sym->stype, sym->sdf, sym->sap);
	128	regno(q) = R3R4 + argofs;
	129	if (dotemps) {
	130	p = tempnode(0, sym->stype, sym->sdf, sym->sap);
	131	sym->soffset = regno(p);
	132	sym->sflags \|= STNODE;
	133	} else {
	134	p = nametree(sym);
	135	}
	136	}
	137	p = buildtree(ASSIGN, p, q);
	138	ecomp(p);
	139	*argofsp = argofs + 2;
	140	}
	141
	142	/* setup a 32-bit param on the stack
	143	* used by bfcode() */
	144	static void
	145	param_32bit(struct symtab sym, int argofsp, int dotemps)
	146	{
	147	NODE p, q;
	148
	149	q = block(REG, NIL, NIL, sym->stype, sym->sdf, sym->sap);
	150	regno(q) = R3 + (*argofsp)++;
	151	if (dotemps) {
	152	p = tempnode(0, sym->stype, sym->sdf, sym->sap);
	153	sym->soffset = regno(p);
	154	sym->sflags \|= STNODE;
	155	} else {
	156	p = nametree(sym);
	157	}
	158	p = buildtree(ASSIGN, p, q);
	159	ecomp(p);
	160	}
	161
	162	/* setup a double param on the stack
	163	* used by bfcode() */
	164	static void
	165	param_double(struct symtab sym, int argofsp, int dotemps)
	166	{
	167	NODE p, q, *t;
	168	int tmpnr;
	169
	170	/*
	171	* we have to dump the double from the general register
	172	* into a temp, since the register allocator doesn't like
	173	* floats to be in CLASSA. This may not work for -xtemps.
	174	*/
	175
	176	if (xtemps) {
	177	q = block(REG, NIL, NIL, ULONGLONG, 0, MKAP(ULONGLONG));
	178	regno(q) = R3R4 + *argofsp;
	179	p = block(REG, NIL, NIL, PTR+ULONGLONG, 0, MKAP(ULONGLONG));
	180	regno(p) = SPREG;
	181	p = block(PLUS, p, bcon(-8), INT, 0, MKAP(INT));
	182	p = block(UMUL, p, NIL, ULONGLONG, 0, MKAP(ULONGLONG));
	183	p = buildtree(ASSIGN, p, q);
	184	ecomp(p);
	185
	186	t = tempnode(0, sym->stype, sym->sdf, sym->sap);
	187	tmpnr = regno(t);
	188	p = block(REG, NIL, NIL,
	189	INCREF(sym->stype), sym->sdf, sym->sap);
	190	regno(p) = SPREG;
	191	p = block(PLUS, p, bcon(-8), INT, 0, MKAP(INT));
	192	p = block(UMUL, p, NIL, sym->stype, sym->sdf, sym->sap);
	193	p = buildtree(ASSIGN, t, p);
	194	ecomp(p);
	195	} else {
	196	/* bounce straight into temp */
	197	p = block(REG, NIL, NIL, ULONGLONG, 0, MKAP(ULONGLONG));
	198	regno(p) = R3R4 + *argofsp;
	199	t = tempnode(0, ULONGLONG, 0, MKAP(ULONGLONG));
	200	tmpnr = regno(t);
	201	p = buildtree(ASSIGN, t, p);
	202	ecomp(p);
	203	}
	204
	205	(*argofsp) += 2;
	206
	207	sym->soffset = tmpnr;
	208	sym->sflags \|= STNODE;
	209	}
	210
	211	/* setup a float param on the stack
	212	* used by bfcode() */
	213	static void
	214	param_float(struct symtab sym, int argofsp, int dotemps)
	215	{
	216	NODE p, q, *t;
	217	int tmpnr;
	218
	219	/*
	220	* we have to dump the float from the general register
	221	* into a temp, since the register allocator doesn't like
	222	* floats to be in CLASSA. This may not work for -xtemps.
	223	*/
	224
	225	if (xtemps) {
	226	/* bounce onto TOS */
	227	q = block(REG, NIL, NIL, INT, 0, MKAP(INT));
	228	regno(q) = R3 + (*argofsp);
	229	p = block(REG, NIL, NIL, INT, 0, MKAP(INT));
	230	regno(p) = SPREG;
	231	p = block(PLUS, p, bcon(-4), INT, 0, MKAP(INT));
	232	p = block(UMUL, p, NIL, INT, 0, MKAP(INT));
	233	p = buildtree(ASSIGN, p, q);
	234	ecomp(p);
	235
	236	t = tempnode(0, sym->stype, sym->sdf, sym->sap);
	237	tmpnr = regno(t);
	238	p = block(REG, NIL, NIL, INCREF(sym->stype),
	239	sym->sdf, sym->sap);
	240	regno(p) = SPREG;
	241	p = block(PLUS, p, bcon(-4), INT, 0, MKAP(INT));
	242	p = block(UMUL, p, NIL, sym->stype, sym->sdf, sym->sap);
	243	p = buildtree(ASSIGN, t, p);
	244	ecomp(p);
	245	} else {
	246	/* bounce straight into temp */
	247	p = block(REG, NIL, NIL, INT, 0, MKAP(INT));
	248	regno(p) = R3 + (*argofsp);
	249	t = tempnode(0, INT, 0, MKAP(INT));
	250	tmpnr = regno(t);
	251	p = buildtree(ASSIGN, t, p);
	252	ecomp(p);
	253	}
	254
	255	(*argofsp)++;
	256
	257	sym->soffset = tmpnr;
	258	sym->sflags \|= STNODE;
	259	}
	260
	261	/* setup the hidden pointer to struct return parameter
	262	* used by bfcode() */
	263	static void
	264	param_retstruct(void)
	265	{
	266	NODE p, q;
	267
	268	p = tempnode(0, INCREF(cftnsp->stype), 0, cftnsp->sap);
	269	rvnr = regno(p);
	270	q = block(REG, NIL, NIL, INCREF(cftnsp->stype),
	271	cftnsp->sdf, cftnsp->sap);
	272	regno(q) = R3;
	273	p = buildtree(ASSIGN, p, q);
	274	ecomp(p);
	275	}
	276
	277
	278	/* setup struct parameter
	279	* push the registers out to memory
	280	* used by bfcode() */
	281	static void
	282	param_struct(struct symtab sym, int argofsp)
	283	{
	284	int argofs = *argofsp;
	285	NODE p, q;
	286	int navail;
	287	int sz;
	288	int off;
	289	int num;
	290	int i;
	291
	292	navail = NARGREGS - argofs;
	293	sz = tsize(sym->stype, sym->sdf, sym->sap) / SZINT;
	294	off = ARGINIT/SZINT + argofs;
	295	num = sz > navail ? navail : sz;
	296	for (i = 0; i < num; i++) {
	297	q = block(REG, NIL, NIL, INT, 0, MKAP(INT));
	298	regno(q) = R3 + argofs++;
	299	p = block(REG, NIL, NIL, INT, 0, MKAP(INT));
	300	regno(p) = SPREG;
	301	p = block(PLUS, p, bcon(4*off++), INT, 0, MKAP(INT));
	302	p = block(UMUL, p, NIL, INT, 0, MKAP(INT));
	303	p = buildtree(ASSIGN, p, q);
	304	ecomp(p);
	305	}
	306
	307	*argofsp = argofs;
	308	}
	309
	310	/*
	311	* code for the beginning of a function
	312	* sp is an array of indices in symtab for the arguments
	313	* cnt is the number of arguments
	314	*/
	315	void
	316	bfcode(struct symtab **sp, int cnt)
	317	{
	318	#ifdef USE_GOTNR
	319	extern int gotnr;
	320	#endif
	321
	322	struct symtab *sp2;
	323	union arglist *usym;
	324	int saveallargs = 0;
	325	int i, argofs = 0;
	326
	327	/*
	328	* Detect if this function has ellipses and save all
	329	* argument registers onto stack.
	330	*/
	331	usym = cftnsp->sdf->dfun;
	332	while (usym && usym->type != TNULL) {
	333	if (usym->type == TELLIPSIS) {
	334	saveallargs = 1;
	335	break;
	336	}
	337	++usym;
	338	}
	339
	340	if (cftnsp->stype == STRTY+FTN \|\| cftnsp->stype == UNIONTY+FTN) {
	341	param_retstruct();
	342	++argofs;
	343	}
	344
	345	#ifdef USE_GOTNR
	346	if (kflag) {
	347	/* put GOT register into temporary */
	348	NODE q, p;
	349	q = block(REG, NIL, NIL, INT, 0, MKAP(INT));
	350	regno(q) = GOTREG;
	351	p = tempnode(0, INT, 0, MKAP(INT));
	352	gotnr = regno(p);
	353	ecomp(buildtree(ASSIGN, p, q));
	354	}
	355	#endif
	356
	357	/* recalculate the arg offset and create TEMP moves */
	358	for (i = 0; i < cnt; i++) {
	359
	360	if (sp[i] == NULL)
	361	continue;
	362
	363	if ((argofs >= NARGREGS) && !xtemps)
	364	break;
	365
	366	if (argofs >= NARGREGS) {
	367	putintemp(sp[i]);
	368	} else if (sp[i]->stype == STRTY \|\| sp[i]->stype == UNIONTY) {
	369	param_struct(sp[i], &argofs);
	370	} else if (DEUNSIGN(sp[i]->stype) == LONGLONG) {
	371	param_64bit(sp[i], &argofs, xtemps && !saveallargs);
	372	} else if (sp[i]->stype == DOUBLE \|\| sp[i]->stype == LDOUBLE) {
	373	if (features(FEATURE_HARDFLOAT))
	374	param_double(sp[i], &argofs,
	375	xtemps && !saveallargs);
	376	else
	377	param_64bit(sp[i], &argofs,
	378	xtemps && !saveallargs);
	379	} else if (sp[i]->stype == FLOAT) {
	380	if (features(FEATURE_HARDFLOAT))
	381	param_float(sp[i], &argofs,
	382	xtemps && !saveallargs);
	383	else
	384	param_32bit(sp[i], &argofs,
	385	xtemps && !saveallargs);
	386	} else {
	387	param_32bit(sp[i], &argofs, xtemps && !saveallargs);
	388	}
	389	}
	390
	391	/* if saveallargs, save the rest of the args onto the stack */
	392	while (saveallargs && argofs < NARGREGS) {
	393	NODE p, q;
	394	/* int off = (ARGINIT+FIXEDSTACKSIZESZCHAR)/SZINT + argofs; /
	395	int off = ARGINIT/SZINT + argofs;
	396	q = block(REG, NIL, NIL, INT, 0, MKAP(INT));
	397	regno(q) = R3 + argofs++;
	398	p = block(REG, NIL, NIL, INT, 0, MKAP(INT));
	399	regno(p) = FPREG;
	400	p = block(PLUS, p, bcon(4*off), INT, 0, MKAP(INT));
	401	p = block(UMUL, p, NIL, INT, 0, MKAP(INT));
	402	p = buildtree(ASSIGN, p, q);
	403	ecomp(p);
	404	}
	405
	406	/* profiling */
	407	if (pflag) {
	408	NODE *p;
	409
	410	#if defined(ELFABI)
	411
	412	sp2 = lookup("_mcount", 0);
	413	sp2->stype = EXTERN;
	414	p = nametree(sp2);
	415	p->n_sp->sclass = EXTERN;
	416	p = clocal(p);
	417	p = buildtree(ADDROF, p, NIL);
	418	p = block(UCALL, p, NIL, INT, 0, MKAP(INT));
	419	ecomp(funcode(p));
	420
	421
	422	#elif defined(MACHOABI)
	423
	424	NODE *q;
	425	int tmpnr;
	426
	427	q = block(REG, NIL, NIL, INT, 0, MKAP(INT));
	428	regno(q) = R0;
	429	p = tempnode(0, INT, 0, MKAP(INT));
	430	tmpnr = regno(p);
	431	p = buildtree(ASSIGN, p, q);
	432	ecomp(p);
	433
	434	q = tempnode(tmpnr, INT, 0, MKAP(INT));
	435
	436	sp2 = lookup("mcount", 0);
	437	sp2->stype = EXTERN;
	438	p = nametree(sp2);
	439	p->n_sp->sclass = EXTERN;
	440	p = clocal(p);
	441	p = buildtree(ADDROF, p, NIL);
	442	p = block(CALL, p, q, INT, 0, MKAP(INT));
	443	ecomp(funcode(p));
	444
	445	#endif
	446	}
	447	}
	448
	449	/*
	450	* code for the end of a function
	451	* deals with struct return here
	452	*/
	453	void
	454	efcode()
	455	{
	456	NODE p, q;
	457	int tempnr;
	458	int ty;
	459
	460	#ifdef USE_GOTNR
	461	extern int gotnr;
	462	gotnr = 0;
	463	#endif
	464
	465	if (cftnsp->stype != STRTY+FTN && cftnsp->stype != UNIONTY+FTN)
	466	return;
	467
	468	ty = cftnsp->stype - FTN;
	469
	470	q = block(REG, NIL, NIL, INCREF(ty), 0, cftnsp->sap);
	471	regno(q) = R3;
	472	p = tempnode(0, INCREF(ty), 0, cftnsp->sap);
	473	tempnr = regno(p);
	474	p = buildtree(ASSIGN, p, q);
	475	ecomp(p);
	476
	477	q = tempnode(tempnr, INCREF(ty), 0, cftnsp->sap);
	478	q = buildtree(UMUL, q, NIL);
	479
	480	p = tempnode(rvnr, INCREF(ty), 0, cftnsp->sap);
	481	p = buildtree(UMUL, p, NIL);
	482
	483	p = buildtree(ASSIGN, p, q);
	484	ecomp(p);
	485
	486	q = tempnode(rvnr, INCREF(ty), 0, cftnsp->sap);
	487	p = block(REG, NIL, NIL, INCREF(ty), 0, cftnsp->sap);
	488	regno(p) = R3;
	489	p = buildtree(ASSIGN, p, q);
	490	ecomp(p);
	491	}
	492
	493	/*
	494	* by now, the automatics and register variables are allocated
	495	*/
	496	void
	497	bccode()
	498	{
	499	SETOFF(autooff, SZINT);
	500	}
	501
	502	struct stub stublist;
	503	struct stub nlplist;
	504
	505	/* called just before final exit */
	506	/* flag is 1 if errors, 0 if none */
	507	void
	508	ejobcode(int flag )
	509	{
	510
	511	#if defined(MACHOABI)
	512	/*
	513	* iterate over the stublist and output the PIC stubs
	514	` */
	515	if (kflag) {
	516	struct stub *p;
	517
	518	DLIST_FOREACH(p, &stublist, link) {
	519	printf("\t.section __TEXT, __picsymbolstub1,symbol_stubs,pure_instructions,32\n");
	520	printf("\t.align 5\n");
	521	printf("L%s$stub:\n", p->name);
	522	if (strcmp(p->name, "mcount") == 0)
	523	printf("\t.indirect_symbol %s\n", p->name);
	524	else
	525	printf("\t.indirect_symbol %s\n", p->name);
	526	printf("\tmflr r0\n");
	527	printf("\tbcl 20,31,L%s$spb\n", p->name);
	528	printf("L%s$spb:\n", p->name);
	529	printf("\tmflr r11\n");
	530	printf("\taddis r11,r11,ha16(L%s$lazy_ptr-L%s$spb)\n",
	531	p->name, p->name);
	532	printf("\tmtlr r0\n");
	533	printf("\tlwzu r12,lo16(L%s$lazy_ptr-L%s$spb)(r11)\n",
	534	p->name, p->name);
	535	printf("\tmtctr r12\n");
	536	printf("\tbctr\n");
	537	printf("\t.lazy_symbol_pointer\n");
	538	printf("L%s$lazy_ptr:\n", p->name);
	539	if (strcmp(p->name, "mcount") == 0)
	540	printf("\t.indirect_symbol %s\n", p->name);
	541	else
	542	printf("\t.indirect_symbol %s\n", p->name);
	543	printf("\t.long dyld_stub_binding_helper\n");
	544	printf("\t.subsections_via_symbols\n");
	545	}
	546
	547	printf("\t.non_lazy_symbol_pointer\n");
	548	DLIST_FOREACH(p, &nlplist, link) {
	549	printf("L%s$non_lazy_ptr:\n", p->name);
	550	if (strcmp(p->name, "mcount") == 0)
	551	printf("\t.indirect_symbol %s\n", p->name);
	552	else
	553	printf("\t.indirect_symbol %s\n", p->name);
	554	printf("\t.long 0\n");
	555	}
	556
	557	}
	558	#endif
	559
	560	#ifndef os_darwin
	561	#define _MKSTR(x) #x
	562	#define MKSTR(x) _MKSTR(x)
	563	#define OS MKSTR(TARGOS)
	564	printf("\t.ident \"PCC: %s (%s)\"\n", PACKAGE_STRING, OS);
	565	#endif
	566
	567	}
	568
	569	void
	570	bjobcode()
	571	{
	572	DLIST_INIT(&stublist, link);
	573	DLIST_INIT(&nlplist, link);
	574	}
	575
	576	#ifdef notdef
	577	/*
	578	* Print character t at position i in one string, until t == -1.
	579	* Locctr & label is already defined.
	580	*/
	581	void
	582	bycode(int t, int i)
	583	{
	584	static int lastoctal = 0;
	585
	586	/* put byte i+1 in a string */
	587
	588	if (t < 0) {
	589	if (i != 0)
	590	puts("\"");
	591	} else {
	592	if (i == 0)
	593	printf("\t.ascii \"");
	594	if (t == '\\' \|\| t == '"') {
	595	lastoctal = 0;
	596	putchar('\\');
	597	putchar(t);
	598	} else if (t < 040 \|\| t >= 0177) {
	599	lastoctal++;
	600	printf("\\%o",t);
	601	} else if (lastoctal && '0' <= t && t <= '9') {
	602	lastoctal = 0;
	603	printf("\"\n\t.ascii \"%c", t);
	604	} else {
	605	lastoctal = 0;
	606	putchar(t);
	607	}
	608	}
	609	}
	610	#endif
	611
	612	/*
	613	* return the alignment of field of type t
	614	*/
	615	int
	616	fldal(unsigned int t)
	617	{
	618	uerror("fldal: illegal field type");
	619	return(ALINT);
	620	}
	621
	622	/* fix up type of field p */
	623	void
	624	fldty(struct symtab *p)
	625	{
	626	}
	627
	628	/*
	629	* XXX - fix genswitch.
	630	*/
	631	int
	632	mygenswitch(int num, TWORD type, struct swents **p, int n)
	633	{
	634	if (num < 0) {
	635	genswitch_bintree(num, type, p, n);
	636	return 1;
	637	}
	638
	639	return 0;
	640
	641	#if 0
	642	if (0)
	643	genswitch_table(num, p, n);
	644	if (0)
	645	genswitch_bintree(num, p, n);
	646	genswitch_mrst(num, p, n);
	647	#endif
	648	}
	649
	650	static void bintree_rec(TWORD ty, int num,
	651	struct swents **p, int n, int s, int e);
	652
	653	static void
	654	genswitch_bintree(int num, TWORD ty, struct swents **p, int n)
	655	{
	656	int lab = getlab();
	657
	658	if (p[0]->slab == 0)
	659	p[0]->slab = lab;
	660
	661	bintree_rec(ty, num, p, n, 1, n);
	662
	663	plabel(lab);
	664	}
	665
	666	static void
	667	bintree_rec(TWORD ty, int num, struct swents **p, int n, int s, int e)
	668	{
	669	NODE *r;
	670	int rlabel;
	671	int h;
	672
	673	if (s == e) {
	674	r = tempnode(num, ty, 0, MKAP(ty));
	675	r = buildtree(NE, r, bcon(p[s]->sval));
	676	cbranch(buildtree(NOT, r, NIL), bcon(p[s]->slab));
	677	branch(p[0]->slab);
	678	return;
	679	}
	680
	681	rlabel = getlab();
	682
	683	h = s + (e - s) / 2;
	684
	685	r = tempnode(num, ty, 0, MKAP(ty));
	686	r = buildtree(GT, r, bcon(p[h]->sval));
	687	cbranch(r, bcon(rlabel));
	688	bintree_rec(ty, num, p, n, s, h);
	689	plabel(rlabel);
	690	bintree_rec(ty, num, p, n, h+1, e);
	691	}
	692
	693
	694	#if 0
	695
	696	static void
	697	genswitch_table(int num, struct swents **p, int n)
	698	{
	699	NODE r, t;
	700	int tval;
	701	int minval, maxval, range;
	702	int deflabel, tbllabel;
	703	int i, j;
	704
	705	minval = p[1]->sval;
	706	maxval = p[n]->sval;
	707
	708	range = maxval - minval + 1;
	709
	710	if (n < 10 \|\| range > 3 * n) {
	711	/* too small or too sparse for jump table */
	712	genswitch_simple(num, p, n);
	713	return;
	714	}
	715
	716	r = tempnode(num, UNSIGNED, 0, MKAP(UNSIGNED));
	717	r = buildtree(MINUS, r, bcon(minval));
	718	t = tempnode(0, UNSIGNED, 0, MKAP(UNSIGNED));
	719	tval = regno(t);
	720	r = buildtree(ASSIGN, t, r);
	721	ecomp(r);
	722
	723	deflabel = p[0]->slab;
	724	if (deflabel == 0)
	725	deflabel = getlab();
	726
	727	t = tempnode(tval, UNSIGNED, 0, MKAP(UNSIGNED));
	728	cbranch(buildtree(GT, t, bcon(maxval-minval)), bcon(deflabel));
	729
	730	tbllabel = getlab();
	731	struct symtab *strtbl = lookup("__switch_table", SLBLNAME\|STEMP);
	732	strtbl->soffset = tbllabel;
	733	strtbl->sclass = ILABEL;
	734	strtbl->stype = INCREF(UCHAR);
	735
	736	t = block(NAME, NIL, NIL, UNSIGNED, 0, MKAP(UNSIGNED));
	737	t->n_sp = strtbl;
	738	t = buildtree(ADDROF, t, NIL);
	739	r = tempnode(tval, UNSIGNED, 0, MKAP(INT));
	740	r = buildtree(PLUS, t, r);
	741	t = tempnode(0, INCREF(UNSIGNED), 0, MKAP(UNSIGNED));
	742	r = buildtree(ASSIGN, t, r);
	743	ecomp(r);
	744
	745	r = tempnode(regno(t), INCREF(UNSIGNED), 0, MKAP(UNSIGNED));
	746	r = buildtree(UMUL, r, NIL);
	747	t = block(NAME, NIL, NIL, UCHAR, 0, MKAP(UCHAR));
	748	t->n_sp = strtbl;
	749	t = buildtree(ADDROF, t, NIL);
	750	r = buildtree(PLUS, t, r);
	751	r = block(GOTO, r, NIL, 0, 0, 0);
	752	ecomp(r);
	753
	754	plabel(tbllabel);
	755	for (i = minval, j=1; i <= maxval; i++) {
	756	char *entry = tmpalloc(20);
	757	int lab = deflabel;
	758	//printf("; minval=%d, maxval=%d, i=%d, j=%d p[j]=%lld\n", minval, maxval, i, j, p[j]->sval);
	759	if (p[j]->sval == i) {
	760	lab = p[j]->slab;
	761	j++;
	762	}
	763	snprintf(entry, 20, ".long " LABFMT "-" LABFMT, lab, tbllabel);
	764	send_passt(IP_ASM, entry);
	765	}
	766
	767	if (p[0]->slab <= 0)
	768	plabel(deflabel);
	769	}
	770
	771	#define DPRINTF(x) if (xdebug) printf x
	772	//#define DPRINTF(x) do { } while(0)
	773
	774	#define MIN_TABLE_SIZE 8
	775
	776	/*
	777	* Multi-way Radix Search Tree (MRST)
	778	*/
	779
	780	static void mrst_rec(int num, struct swents *p, int n, int state, int lab);
	781	static unsigned long mrst_find_window(struct swents *p, int n, int state, int lab, int len, int lowbit);
	782	void mrst_put_entry_and_recurse(int num, struct swents *p, int n, int state, int tbllabel, int lab, unsigned long j, unsigned long tblsize, unsigned long Wmax, int lowbit);
	783
	784	static void
	785	genswitch_mrst(int num, struct swents **p, int n)
	786	{
	787	int *state;
	788	int i;
	789	int putlabel = 0;
	790
	791	if (n < 10) {
	792	/* too small for MRST */
	793	genswitch_simple(num, p, n);
	794	return;
	795	}
	796
	797	state = tmpalloc((n+1)*sizeof(int));
	798	for (i = 0; i <= n; i++)
	799	state[i] = 0;
	800
	801	if (p[0]->slab == 0) {
	802	p[0]->slab = getlab();
	803	putlabel = 1;
	804	}
	805
	806	mrst_rec(num, p, n, state, 0);
	807
	808	if (putlabel)
	809	plabel(p[0]->slab);
	810	}
	811
	812
	813	/*
	814	* Look through the cases and generate a table or
	815	* list of simple comparisons. If generating a table,
	816	* invoke mrst_put_entry_and_recurse() to put
	817	* an entry in the table and recurse.
	818	*/
	819	static void
	820	mrst_rec(int num, struct swents *p, int n, int state, int lab)
	821	{
	822	int len, lowbit;
	823	unsigned long Wmax;
	824	unsigned int tblsize;
	825	NODE *t;
	826	NODE *r;
	827	int tval;
	828	int i;
	829
	830	DPRINTF(("mrst_rec: num=%d, n=%d, lab=%d\n", num, n, lab));
	831
	832	/* find best window to cover set*/
	833	Wmax = mrst_find_window(p, n, state, lab, &len, &lowbit);
	834	tblsize = (1 << len);
	835	assert(len > 0 && tblsize > 0);
	836
	837	DPRINTF(("mrst_rec: Wmax=%lu, lowbit=%d, tblsize=%u\n",
	838	Wmax, lowbit, tblsize));
	839
	840	if (lab)
	841	plabel(lab);
	842
	843	if (tblsize <= MIN_TABLE_SIZE) {
	844	DPRINTF(("msrt_rec: break the recursion\n"));
	845	for (i = 1; i <= n; i++) {
	846	if (state[i] == lab) {
	847	t = tempnode(num, UNSIGNED, 0, MKAP(UNSIGNED));
	848	cbranch(buildtree(EQ, t, bcon(p[i]->sval)),
	849	bcon(p[i]->slab));
	850	}
	851	}
	852	branch(p[0]->slab);
	853	return;
	854	}
	855
	856	DPRINTF(("generating table with %d elements\n", tblsize));
	857
	858	// AND with Wmax
	859	t = tempnode(num, UNSIGNED, 0, MKAP(UNSIGNED));
	860	r = buildtree(AND, t, bcon(Wmax));
	861
	862	// RS lowbits
	863	r = buildtree(RS, r, bcon(lowbit));
	864
	865	t = tempnode(0, UNSIGNED, 0, MKAP(UNSIGNED));
	866	tval = regno(t);
	867	r = buildtree(ASSIGN, t, r);
	868	ecomp(r);
	869
	870	int tbllabel = getlab();
	871	struct symtab *strtbl = lookup("__switch_table", SLBLNAME\|STEMP);
	872	strtbl->sclass = STATIC;
	873	strtbl->sap = MKAP(UCHAR);
	874	strtbl->slevel = 1;
	875	strtbl->soffset = tbllabel;
	876	strtbl->stype = INCREF(UCHAR);
	877	strtbl->squal = (CON >> TSHIFT);
	878
	879	t = block(NAME, NIL, NIL, UNSIGNED, 0, MKAP(UNSIGNED));
	880	t->n_sp = strtbl;
	881	t = buildtree(ADDROF, t, NIL);
	882	r = tempnode(tval, UNSIGNED, 0, MKAP(INT));
	883	r = buildtree(PLUS, t, r);
	884	t = tempnode(0, INCREF(UNSIGNED), 0, MKAP(UNSIGNED));
	885	r = buildtree(ASSIGN, t, r);
	886	ecomp(r);
	887
	888	r = tempnode(regno(t), INCREF(UNSIGNED), 0, MKAP(UNSIGNED));
	889	r = buildtree(UMUL, r, NIL);
	890	t = block(NAME, NIL, NIL, UCHAR, 0, MKAP(UCHAR));
	891	t->n_sp = strtbl;
	892	t = buildtree(ADDROF, t, NIL);
	893	r = buildtree(PLUS, t, r);
	894	r = block(GOTO, r, NIL, 0, 0, 0);
	895	ecomp(r);
	896
	897	plabel(tbllabel);
	898
	899	mrst_put_entry_and_recurse(num, p, n, state, tbllabel, lab,
	900	0, tblsize, Wmax, lowbit);
	901	}
	902
	903
	904	/*
	905	* Put an entry into the table and recurse to the next entry
	906	* in the table. On the way back through the recursion, invoke
	907	* mrst_rec() to check to see if we should generate another
	908	* table.
	909	*/
	910	void
	911	mrst_put_entry_and_recurse(int num, struct swents *p, int n, int state,
	912	int tbllabel, int labval,
	913	unsigned long j, unsigned long tblsize, unsigned long Wmax, int lowbit)
	914	{
	915	int i;
	916	int found = 0;
	917	int lab = getlab();
	918
	919	/*
	920	* Look for labels which map to this table entry.
	921	* Mark each one in "state" that they fall inside this table.
	922	*/
	923	for (i = 1; i <= n; i++) {
	924	unsigned int val = (p[i]->sval & Wmax) >> lowbit;
	925	if (val == j && state[i] == labval) {
	926	found = 1;
	927	state[i] = lab;
	928	}
	929	}
	930
	931	/* couldn't find any labels? goto the default label */
	932	if (!found)
	933	lab = p[0]->slab;
	934
	935	/* generate the table entry */
	936	char *entry = tmpalloc(20);
	937	snprintf(entry, 20, ".long " LABFMT "-" LABFMT, lab, tbllabel);
	938	send_passt(IP_ASM, entry);
	939
	940	DPRINTF(("mrst_put_entry: table=%d, pos=%lu/%lu, label=%d\n",
	941	tbllabel, j, tblsize, lab));
	942
	943	/* go to the next table entry */
	944	if (j+1 < tblsize) {
	945	mrst_put_entry_and_recurse(num, p, n, state, tbllabel, labval,
	946	j+1, tblsize, Wmax, lowbit);
	947	}
	948
	949	/* if we are going to the default label, bail now */
	950	if (!found)
	951	return;
	952
	953	#ifdef PCC_DEBUG
	954	if (xdebug) {
	955	printf("state: ");
	956	for (i = 1; i <= n; i++)
	957	printf("%d ", state[i]);
	958	printf("\n");
	959	}
	960	#endif
	961
	962	/* build another table */
	963	mrst_rec(num, p, n, state, lab);
	964	}
	965
	966	/*
	967	* counts the number of entries in a table of size (1 << L) which would
	968	* be used given the cases and the mask (W, lowbit).
	969	*/
	970	static unsigned int
	971	mrst_cardinality(struct swents *p, int n, int state, int step, unsigned long W, int L, int lowbit)
	972	{
	973	unsigned int count = 0;
	974	int i;
	975
	976	if (W == 0)
	977	return 0;
	978
	979	int vals = (int )calloc(1 << L, sizeof(int));
	980	assert(vals);
	981
	982	DPRINTF(("mrst_cardinality: "));
	983	for (i = 1; i <= n; i++) {
	984	int idx;
	985	if (state[i] != step)
	986	continue;
	987	idx = (p[i]->sval & W) >> lowbit;
	988	DPRINTF(("%llu->%d, ", p[i]->sval, idx));
	989	if (!vals[idx]) {
	990	count++;
	991	}
	992	vals[idx] = 1;
	993	}
	994	DPRINTF((": found %d entries\n", count));
	995	free(vals);
	996
	997	return count;
	998	}
	999
	1000	/*
	1001	* Find the maximum window (table size) which would best cover
	1002	* the set of labels. Algorithm explained in:
	1003	*
	1004	* Ulfar Erlingsson, Mukkai Krishnamoorthy and T.V. Raman.
	1005	* Efficient Multiway Radix Search Trees.
	1006	* Information Processing Letters 60:3 115-120 (November 1996)
	1007	*/
	1008
	1009	static unsigned long
	1010	mrst_find_window(struct swents *p, int n, int state, int lab, int len, int lowbit)
	1011	{
	1012	unsigned int tblsize;
	1013	unsigned long W = 0;
	1014	unsigned long Wmax = 0;
	1015	unsigned long Wleft = (1 << (SZLONG-1));
	1016	unsigned int C = 0;
	1017	unsigned int Cmax = 0;
	1018	int L = 0;
	1019	int Lmax = 0;
	1020	int lowmax = 0;
	1021	int no_b = SZLONG-1;
	1022	unsigned long b = (1 << (SZLONG-1));
	1023
	1024	DPRINTF(("mrst_find_window: n=%d, lab=%d\n", n, lab));
	1025
	1026	for (; b > 0; b >>= 1, no_b--) {
	1027
	1028	// select the next bit
	1029	W \|= b;
	1030	L += 1;
	1031
	1032	tblsize = 1 << L;
	1033	assert(tblsize > 0);
	1034
	1035	DPRINTF(("no_b=%d, b=0x%lx, Wleft=0x%lx, W=0x%lx, Wmax=0x%lx, L=%d, Lmax=%d, Cmax=%u, lowmax=%d, tblsize=%u\n", no_b, b, Wleft, W, Wmax, L, Lmax, Cmax, lowmax, tblsize));
	1036
	1037	C = mrst_cardinality(p, n, state, lab, W, L, no_b);
	1038	DPRINTF((" -> cardinality is %d\n", C));
	1039
	1040	if (2*C >= tblsize) {
	1041	DPRINTF(("(found good match, keep adding to table)\n"));
	1042	Wmax = W;
	1043	Lmax = L;
	1044	lowmax = no_b;
	1045	Cmax = C;
	1046	} else {
	1047	DPRINTF(("(too sparse)\n"));
	1048	assert((W & Wleft) != 0);
	1049
	1050	/* flip the MSB and see if we get a better match */
	1051	W ^= Wleft;
	1052	Wleft >>= 1;
	1053	L -= 1;
	1054
	1055	DPRINTF((" --> trying W=0x%lx and L=%d and Cmax=%u\n", W, L, Cmax));
	1056	C = mrst_cardinality(p, n, state, lab, W, L, no_b);
	1057	DPRINTF((" --> C=%u\n", C));
	1058	if (C > Cmax) {
	1059	Wmax = W;
	1060	Lmax = L;
	1061	lowmax = no_b;
	1062	Cmax = C;
	1063	DPRINTF((" --> better!\n"));
	1064	} else {
	1065	DPRINTF((" --> no better\n"));
	1066	}
	1067	}
	1068
	1069	}
	1070
	1071	#ifdef PCC_DEBUG
	1072	if (xdebug) {
	1073	int i;
	1074	int hibit = lowmax + Lmax;
	1075	printf("msrt_find_window: Wmax=0x%lx, lowbit=%d, result=", Wmax, lowmax);
	1076	for (i = 31; i >= 0; i--) {
	1077	int mask = (1 << i);
	1078	if (i == hibit)
	1079	printf("[");
	1080	if (Wmax & mask)
	1081	printf("1");
	1082	else
	1083	printf("0");
	1084	if (i == lowmax)
	1085	printf("]");
	1086	}
	1087	printf("\n");
	1088	}
	1089	#endif
	1090
	1091	assert(Lmax > 0);
	1092	*len = Lmax;
	1093	*lowbit = lowmax;
	1094
	1095	DPRINTF(("msrt_find_window: returning Wmax=%lu, len=%d, lowbit=%d [tblsize=%u, entries=%u]\n", Wmax, Lmax, lowmax, tblsize, C));
	1096
	1097	return Wmax;
	1098	}
	1099	#endif
	1100
	1101	/*
	1102	* Straighten a chain of CM ops so that the CM nodes
	1103	* only appear on the left node.
	1104	*
	1105	* CM CM
	1106	* CM CM CM b
	1107	* x y a b CM a
	1108	* x y
	1109	*
	1110	* CM CM
	1111	* CM CM CM c
	1112	* CM z CM c CM b
	1113	* x y a b CM a
	1114	* CM z
	1115	* x y
	1116	*/
	1117	static NODE *
	1118	straighten(NODE *p)
	1119	{
	1120	NODE *r = p->n_right;
	1121
	1122	if (p->n_op != CM \|\| r->n_op != CM)
	1123	return p;
	1124
	1125	p->n_right = r->n_left;
	1126	r->n_left = straighten(p);
	1127
	1128	return r;
	1129	}
	1130
	1131	static NODE *
	1132	reverse1(NODE p, NODE a)
	1133	{
	1134	NODE *l = p->n_left;
	1135	NODE *r = p->n_right;
	1136
	1137	a->n_right = r;
	1138	p->n_left = a;
	1139
	1140	if (l->n_op == CM) {
	1141	return reverse1(l, p);
	1142	} else {
	1143	p->n_right = l;
	1144	return p;
	1145	}
	1146	}
	1147
	1148	/*
	1149	* Reverse a chain of CM ops
	1150	*/
	1151	static NODE *
	1152	reverse(NODE *p)
	1153	{
	1154	NODE *l = p->n_left;
	1155	NODE *r = p->n_right;
	1156
	1157	p->n_left = r;
	1158
	1159	if (l->n_op == CM)
	1160	return reverse1(l, p);
	1161
	1162	p->n_right = l;
	1163
	1164	return p;
	1165	}
	1166
	1167	/* push arg onto the stack */
	1168	/* called by moveargs() */
	1169	static NODE *
	1170	pusharg(NODE p, int regp)
	1171	{
	1172	NODE *q;
	1173	int sz;
	1174	int off;
	1175
	1176	/* convert to register size, if smaller */
	1177	sz = tsize(p->n_type, p->n_df, p->n_ap);
	1178	if (sz < SZINT)
	1179	p = block(SCONV, p, NIL, INT, 0, MKAP(INT));
	1180
	1181	q = block(REG, NIL, NIL, INCREF(p->n_type), p->n_df, p->n_ap);
	1182	regno(q) = SPREG;
	1183
	1184	off = ARGINIT/SZCHAR + 4 * (*regp - R3);
	1185	q = block(PLUS, q, bcon(off), INT, 0, MKAP(INT));
	1186	q = block(UMUL, q, NIL, p->n_type, p->n_df, p->n_ap);
	1187	(*regp) += szty(p->n_type);
	1188
	1189	return buildtree(ASSIGN, q, p);
	1190	}
	1191
	1192	/* setup call stack with 32-bit argument */
	1193	/* called from moveargs() */
	1194	static NODE *
	1195	movearg_32bit(NODE p, int regp)
	1196	{
	1197	int reg = *regp;
	1198	NODE *q;
	1199
	1200	q = block(REG, NIL, NIL, p->n_type, p->n_df, p->n_ap);
	1201	regno(q) = reg++;
	1202	q = buildtree(ASSIGN, q, p);
	1203
	1204	*regp = reg;
	1205	return q;
	1206	}
	1207
	1208	/* setup call stack with 64-bit argument */
	1209	/* called from moveargs() */
	1210	static NODE *
	1211	movearg_64bit(NODE p, int regp)
	1212	{
	1213	int reg = *regp;
	1214	NODE q, r;
	1215
	1216	#if ALLONGLONG == 64
	1217	/* alignment */
	1218	++reg;
	1219	reg &= ~1;
	1220	#endif
	1221
	1222	if (reg > R10) {
	1223	*regp = reg;
	1224	q = pusharg(p, regp);
	1225	} else if (reg == R10) {
	1226	/* half in and half out of the registers */
	1227	r = tcopy(p);
	1228	if (!features(FEATURE_BIGENDIAN)) {
	1229	q = block(SCONV, p, NIL, INT, 0, MKAP(INT));
	1230	q = movearg_32bit(q, regp); /* little-endian */
	1231	r = buildtree(RS, r, bcon(32));
	1232	r = block(SCONV, r, NIL, INT, 0, MKAP(INT));
	1233	r = pusharg(r, regp); /* little-endian */
	1234	} else {
	1235	q = buildtree(RS, p, bcon(32));
	1236	q = block(SCONV, q, NIL, INT, 0, MKAP(INT));
	1237	q = movearg_32bit(q, regp); /* big-endian */
	1238	r = block(SCONV, r, NIL, INT, 0, MKAP(INT));
	1239	r = pusharg(r, regp); /* big-endian */
	1240	}
	1241	q = straighten(block(CM, q, r, p->n_type, p->n_df, p->n_ap));
	1242	} else {
	1243	q = block(REG, NIL, NIL, p->n_type, p->n_df, p->n_ap);
	1244	regno(q) = R3R4 + (reg - R3);
	1245	q = buildtree(ASSIGN, q, p);
	1246	*regp = reg + 2;
	1247	}
	1248
	1249	return q;
	1250	}
	1251
	1252	/* setup call stack with float argument */
	1253	/* called from moveargs() */
	1254	static NODE *
	1255	movearg_float(NODE p, int fregp, int *regp)
	1256	{
	1257	#if defined(MACHOABI)
	1258	NODE q, r;
	1259	TWORD ty = INCREF(p->n_type);
	1260	int tmpnr;
	1261	#endif
	1262
	1263	p = movearg_32bit(p, fregp);
	1264
	1265	/*
	1266	* On OS/X, floats are passed in the floating-point registers
	1267	* and in the general registers for compatibily with libraries
	1268	* compiled to handle soft-float.
	1269	*/
	1270
	1271	#if defined(MACHOABI)
	1272
	1273	if (xtemps) {
	1274	/* bounce into TOS */
	1275	r = block(REG, NIL, NIL, ty, p->n_df, p->n_ap);
	1276	regno(r) = SPREG;
	1277	r = block(PLUS, r, bcon(-4), INT, 0, MKAP(INT));
	1278	r = block(UMUL, r, NIL, p->n_type, p->n_df, p->n_ap);
	1279	r = buildtree(ASSIGN, r, p);
	1280	ecomp(r);
	1281
	1282	/* bounce into temp */
	1283	r = block(REG, NIL, NIL, PTR+INT, 0, MKAP(INT));
	1284	regno(r) = SPREG;
	1285	r = block(PLUS, r, bcon(-4), INT, 0, MKAP(INT));
	1286	r = block(UMUL, r, NIL, INT, 0, MKAP(INT));
	1287	q = tempnode(0, INT, 0, MKAP(INT));
	1288	tmpnr = regno(q);
	1289	r = buildtree(ASSIGN, q, r);
	1290	ecomp(r);
	1291	} else {
	1292	/* copy directly into temp */
	1293	q = tempnode(0, p->n_type, p->n_df, p->n_ap);
	1294	tmpnr = regno(q);
	1295	r = buildtree(ASSIGN, q, p);
	1296	ecomp(r);
	1297	}
	1298
	1299	/* copy from temp to register parameter */
	1300	r = tempnode(tmpnr, INT, 0, MKAP(INT));
	1301	q = block(REG, NIL, NIL, INT, 0, MKAP(INT));
	1302	regno(q) = (*regp)++;
	1303	p = buildtree(ASSIGN, q, r);
	1304
	1305	#endif
	1306	return p;
	1307
	1308	}
	1309
	1310	/* setup call stack with float/double argument */
	1311	/* called from moveargs() */
	1312	static NODE *
	1313	movearg_double(NODE p, int fregp, int *regp)
	1314	{
	1315	#if defined(MACHOABI)
	1316	NODE q, r;
	1317	TWORD ty = INCREF(p->n_type);
	1318	int tmpnr;
	1319	#endif
	1320
	1321	/* this does the move to a single register for us */
	1322	p = movearg_32bit(p, fregp);
	1323
	1324	/*
	1325	* On OS/X, doubles are passed in the floating-point registers
	1326	* and in the general registers for compatibily with libraries
	1327	* compiled to handle soft-float.
	1328	*/
	1329
	1330	#if defined(MACHOABI)
	1331
	1332	if (xtemps) {
	1333	/* bounce on TOS */
	1334	r = block(REG, NIL, NIL, ty, p->n_df, p->n_ap);
	1335	regno(r) = SPREG;
	1336	r = block(PLUS, r, bcon(-8), ty, p->n_df, p->n_ap);
	1337	r = block(UMUL, r, NIL, p->n_type, p->n_df, p->n_ap);
	1338	r = buildtree(ASSIGN, r, p);
	1339	ecomp(r);
	1340
	1341	/* bounce into temp */
	1342	r = block(REG, NIL, NIL, PTR+LONGLONG, 0, MKAP(LONGLONG));
	1343	regno(r) = SPREG;
	1344	r = block(PLUS, r, bcon(-8), PTR+LONGLONG, 0, MKAP(LONGLONG));
	1345	r = block(UMUL, r, NIL, LONGLONG, 0, MKAP(LONGLONG));
	1346	q = tempnode(0, LONGLONG, 0, MKAP(LONGLONG));
	1347	tmpnr = regno(q);
	1348	r = buildtree(ASSIGN, q, r);
	1349	ecomp(r);
	1350	} else {
	1351	/* copy directly into temp */
	1352	q = tempnode(0, p->n_type, p->n_df, p->n_ap);
	1353	tmpnr = regno(q);
	1354	r = buildtree(ASSIGN, q, p);
	1355	ecomp(r);
	1356	}
	1357
	1358	/* copy from temp to register parameter */
	1359	r = tempnode(tmpnr, LONGLONG, 0, MKAP(LONGLONG));
	1360	q = block(REG, NIL, NIL, LONGLONG, 0, MKAP(LONGLONG));
	1361	regno(q) = R3R4 - R3 + (*regp);
	1362	p = buildtree(ASSIGN, q, r);
	1363
	1364	(*regp) += 2;
	1365
	1366	#endif
	1367
	1368	return p;
	1369	}
	1370
	1371	/* setup call stack with a structure */
	1372	/* called from moveargs() */
	1373	static NODE *
	1374	movearg_struct(NODE p, int regp)
	1375	{
	1376	int reg = *regp;
	1377	NODE l, q, t, r;
	1378	int tmpnr;
	1379	int navail;
	1380	int num;
	1381	int sz;
	1382	int ty;
	1383	int i;
	1384
	1385	assert(p->n_op == STARG);
	1386
	1387	navail = NARGREGS - (reg - R3);
	1388	navail = navail < 0 ? 0 : navail;
	1389	sz = tsize(p->n_type, p->n_df, p->n_ap) / SZINT;
	1390	num = sz > navail ? navail : sz;
	1391
	1392	/* remove STARG node */
	1393	l = p->n_left;
	1394	nfree(p);
	1395	ty = l->n_type;
	1396
	1397	/*
	1398	* put it into a TEMP, rather than tcopy(), since the tree
	1399	* in p may have side-affects
	1400	*/
	1401	t = tempnode(0, ty, l->n_df, l->n_ap);
	1402	tmpnr = regno(t);
	1403	q = buildtree(ASSIGN, t, l);
	1404
	1405	/* copy structure into registers */
	1406	for (i = 0; i < num; i++) {
	1407	t = tempnode(tmpnr, ty, 0, MKAP(PTR+ty));
	1408	t = block(SCONV, t, NIL, PTR+INT, 0, MKAP(PTR+INT));
	1409	t = block(PLUS, t, bcon(4*i), PTR+INT, 0, MKAP(PTR+INT));
	1410	t = buildtree(UMUL, t, NIL);
	1411
	1412	r = block(REG, NIL, NIL, INT, 0, MKAP(INT));
	1413	regno(r) = reg++;
	1414	r = buildtree(ASSIGN, r, t);
	1415
	1416	q = block(CM, q, r, INT, 0, MKAP(INT));
	1417	}
	1418
	1419	/* put the rest of the structure on the stack */
	1420	for (i = num; i < sz; i++) {
	1421	t = tempnode(tmpnr, ty, 0, MKAP(PTR+ty));
	1422	t = block(SCONV, t, NIL, PTR+INT, 0, MKAP(PTR+INT));
	1423	t = block(PLUS, t, bcon(4*i), PTR+INT, 0, MKAP(PTR+INT));
	1424	t = buildtree(UMUL, t, NIL);
	1425	r = pusharg(t, &reg);
	1426	q = block(CM, q, r, INT, 0, MKAP(INT));
	1427	}
	1428
	1429	q = reverse(q);
	1430
	1431	*regp = reg;
	1432	return q;
	1433	}
	1434
	1435
	1436	static NODE *
	1437	moveargs(NODE p, int regp, int *fregp)
	1438	{
	1439	NODE r, *rp;
	1440	int reg, freg;
	1441
	1442	if (p->n_op == CM) {
	1443	p->n_left = moveargs(p->n_left, regp, fregp);
	1444	r = p->n_right;
	1445	rp = &p->n_right;
	1446	} else {
	1447	r = p;
	1448	rp = &p;
	1449	}
	1450
	1451	reg = *regp;
	1452	freg = *fregp;
	1453
	1454	#define ISFLOAT(p) (p->n_type == FLOAT \|\| \
	1455	p->n_type == DOUBLE \|\| \
	1456	p->n_type == LDOUBLE)
	1457
	1458	if (reg > R10 && r->n_op != STARG) {
	1459	*rp = pusharg(r, regp);
	1460	} else if (r->n_op == STARG) {
	1461	*rp = movearg_struct(r, regp);
	1462	} else if (DEUNSIGN(r->n_type) == LONGLONG) {
	1463	*rp = movearg_64bit(r, regp);
	1464	} else if (r->n_type == DOUBLE \|\| r->n_type == LDOUBLE) {
	1465	if (features(FEATURE_HARDFLOAT))
	1466	*rp = movearg_double(r, fregp, regp);
	1467	else
	1468	*rp = movearg_64bit(r, regp);
	1469	} else if (r->n_type == FLOAT) {
	1470	if (features(FEATURE_HARDFLOAT))
	1471	*rp = movearg_float(r, fregp, regp);
	1472	else
	1473	*rp = movearg_32bit(r, regp);
	1474	} else {
	1475	*rp = movearg_32bit(r, regp);
	1476	}
	1477
	1478	return straighten(p);
	1479	}
	1480
	1481	/*
	1482	* Fixup arguments to pass pointer-to-struct as first argument.
	1483	*
	1484	* called from funcode().
	1485	*/
	1486	static NODE *
	1487	retstruct(NODE *p)
	1488	{
	1489	struct symtab s;
	1490	NODE l, r, t, q;
	1491	TWORD ty;
	1492
	1493	l = p->n_left;
	1494	r = p->n_right;
	1495
	1496	ty = DECREF(l->n_type) - FTN;
	1497
	1498	s.sclass = AUTO;
	1499	s.stype = ty;
	1500	s.sdf = l->n_df;
	1501	s.sap = l->n_ap;
	1502	oalloc(&s, &autooff);
	1503	q = block(REG, NIL, NIL, INCREF(ty), l->n_df, l->n_ap);
	1504	regno(q) = FPREG;
	1505	q = block(MINUS, q, bcon(autooff/SZCHAR), INCREF(ty),
	1506	l->n_df, l->n_ap);
	1507
	1508	/* insert hidden assignment at beginning of list */
	1509	if (r->n_op != CM) {
	1510	p->n_right = block(CM, q, r, INCREF(ty), l->n_df, l->n_ap);
	1511	} else {
	1512	for (t = r; t->n_left->n_op == CM; t = t->n_left)
	1513	;
	1514	t->n_left = block(CM, q, t->n_left, INCREF(ty),
	1515	l->n_df, l->n_ap);
	1516	}
	1517
	1518	return p;
	1519	}
	1520
	1521	/*
	1522	* Called with a function call with arguments as argument.
	1523	* This is done early in buildtree() and only done once.
	1524	*/
	1525	NODE *
	1526	funcode(NODE *p)
	1527	{
	1528	int regnum = R3;
	1529	int fregnum = F1;
	1530
	1531	if (DECREF(p->n_left->n_type) == STRTY+FTN \|\|
	1532	DECREF(p->n_left->n_type) == UNIONTY+FTN)
	1533	p = retstruct(p);
	1534
	1535	p->n_right = moveargs(p->n_right, &regnum, &fregnum);
	1536
	1537	if (p->n_right == NULL)
	1538	p->n_op += (UCALL - CALL);
	1539
	1540	return p;
	1541	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: