Context Navigation

source: mainline/uspace/app/pcc/arch/i386/local.c@ 9749e47

Visit:

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

Last change on this file since 9749e47 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: 31.9 KB

Line
1	/* $Id: local.c,v 1.130.2.3 2011/03/30 16:35:36 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
30	#include "pass1.h"
31
32	/* this file contains code which is dependent on the target machine */
33
34	#ifdef notyet
35	/*
36	* Check if a constant is too large for a type.
37	*/
38	static int
39	toolarge(TWORD t, CONSZ con)
40	{
41	U_CONSZ ucon = con;
42
43	switch (t) {
44	case ULONGLONG:
45	case LONGLONG:
46	break; /* cannot be too large */
47	#define SCHK(i) case i: if (con > MAX_##i \|\| con < MIN_##i) return 1; break
48	#define UCHK(i) case i: if (ucon > MAX_##i) return 1; break
49	SCHK(INT);
50	SCHK(SHORT);
51	case BOOL:
52	SCHK(CHAR);
53	UCHK(UNSIGNED);
54	UCHK(USHORT);
55	UCHK(UCHAR);
56	default:
57	cerror("toolarge");
58	}
59	return 0;
60	}
61	#endif
62
63	#if defined(MACHOABI)
64
65	/*
66	* Keep track of PIC stubs.
67	*/
68
69	void
70	addstub(struct stub list, char name)
71	{
72	struct stub *s;
73
74	DLIST_FOREACH(s, list, link) {
75	if (strcmp(s->name, name) == 0)
76	return;
77	}
78
79	s = permalloc(sizeof(struct stub));
80	s->name = permalloc(strlen(name) + 1);
81	strcpy(s->name, name);
82	DLIST_INSERT_BEFORE(list, s, link);
83	}
84
85	#endif
86
87	#define IALLOC(sz) (isinlining ? permalloc(sz) : tmpalloc(sz))
88
89	/*
90	* Make a symtab entry for PIC use.
91	*/
92	static struct symtab *
93	picsymtab(char p, char s, char *s2)
94	{
95	struct symtab *sp = IALLOC(sizeof(struct symtab));
96	size_t len = strlen(p) + strlen(s) + strlen(s2) + 1;
97
98	sp->sname = sp->soname = IALLOC(len);
99	strlcpy(sp->soname, p, len);
100	strlcat(sp->soname, s, len);
101	strlcat(sp->soname, s2, len);
102	sp->sap = NULL;
103	sp->sclass = EXTERN;
104	sp->sflags = sp->slevel = 0;
105	return sp;
106	}
107
108	#ifdef os_win32
109	static NODE *
110	import(NODE *p)
111	{
112	NODE *q;
113	char *name;
114	struct symtab *sp;
115
116	if ((name = p->n_sp->soname) == NULL)
117	name = exname(p->n_sp->sname);
118
119	sp = picsymtab("__imp_", name, "");
120	q = xbcon(0, sp, PTR+VOID);
121	q = block(UMUL, q, 0, PTR\|VOID, 0, MKAP(VOID));
122	q = block(UMUL, q, 0, p->n_type, p->n_df, p->n_ap);
123	q->n_sp = p->n_sp; /* for init */
124	nfree(p);
125
126	return q;
127	}
128	#endif
129
130	int gotnr; /* tempnum for GOT register */
131	int argstacksize;
132
133	/*
134	* Create a reference for an extern variable.
135	*/
136	static NODE *
137	picext(NODE *p)
138	{
139
140	#if defined(ELFABI)
141
142	NODE q, r;
143	struct symtab *sp;
144	char *name;
145
146	q = tempnode(gotnr, PTR\|VOID, 0, MKAP(VOID));
147	if ((name = p->n_sp->soname) == NULL)
148	name = p->n_sp->sname;
149	sp = picsymtab("", name, "@GOT");
150	#ifdef GCC_COMPAT
151	if (attr_find(p->n_sp->sap, GCC_ATYP_STDCALL) != NULL)
152	p->n_sp->sflags \|= SSTDCALL;
153	#endif
154	sp->sflags = p->n_sp->sflags & SSTDCALL;
155	r = xbcon(0, sp, INT);
156	q = buildtree(PLUS, q, r);
157	q = block(UMUL, q, 0, PTR\|VOID, 0, MKAP(VOID));
158	q = block(UMUL, q, 0, p->n_type, p->n_df, p->n_ap);
159	q->n_sp = p->n_sp; /* for init */
160	nfree(p);
161	return q;
162
163	#elif defined(MACHOABI)
164
165	NODE q, r;
166	struct symtab *sp;
167	char buf2[256], name, pspn;
168
169	if ((name = cftnsp->soname) == NULL)
170	name = cftnsp->sname;
171	if ((pspn = p->n_sp->soname) == NULL)
172	pspn = exname(p->n_sp->sname);
173	if (p->n_sp->sclass == EXTDEF) {
174	snprintf(buf2, 256, "-L%s$pb", name);
175	sp = picsymtab("", pspn, buf2);
176	} else {
177	snprintf(buf2, 256, "$non_lazy_ptr-L%s$pb", name);
178	sp = picsymtab("L", pspn, buf2);
179	addstub(&nlplist, pspn);
180	}
181	q = tempnode(gotnr, PTR+VOID, 0, MKAP(VOID));
182	r = xbcon(0, sp, INT);
183	q = buildtree(PLUS, q, r);
184
185	if (p->n_sp->sclass != EXTDEF)
186	q = block(UMUL, q, 0, PTR+VOID, 0, MKAP(VOID));
187	q = block(UMUL, q, 0, p->n_type, p->n_df, p->n_ap);
188	q->n_sp = p->n_sp; /* for init */
189	nfree(p);
190	return q;
191
192	#elif defined(PECOFFABI)
193
194	return p;
195
196	#endif
197
198	}
199
200	/*
201	* Create a reference for a static variable.
202	*/
203	static NODE *
204	picstatic(NODE *p)
205	{
206
207	#if defined(ELFABI)
208
209	NODE q, r;
210	struct symtab *sp;
211
212	q = tempnode(gotnr, PTR\|VOID, 0, MKAP(VOID));
213	if (p->n_sp->slevel > 0) {
214	char buf[32];
215	snprintf(buf, 32, LABFMT, (int)p->n_sp->soffset);
216	sp = picsymtab("", buf, "@GOTOFF");
217	} else {
218	char *name;
219	if ((name = p->n_sp->soname) == NULL)
220	name = p->n_sp->sname;
221	sp = picsymtab("", name, "@GOTOFF");
222	}
223
224	sp->sclass = STATIC;
225	sp->stype = p->n_sp->stype;
226	r = xbcon(0, sp, INT);
227	q = buildtree(PLUS, q, r);
228	q = block(UMUL, q, 0, p->n_type, p->n_df, p->n_ap);
229	q->n_sp = p->n_sp; /* for init */
230	nfree(p);
231	return q;
232
233	#elif defined(MACHOABI)
234
235	NODE q, r;
236	struct symtab *sp;
237	char buf2[256];
238
239	snprintf(buf2, 256, "-L%s$pb",
240	cftnsp->soname ? cftnsp->soname : cftnsp->sname);
241
242	if (p->n_sp->slevel > 0) {
243	char buf1[32];
244	snprintf(buf1, 32, LABFMT, (int)p->n_sp->soffset);
245	sp = picsymtab("", buf1, buf2);
246	} else {
247	char *name;
248	if ((name = p->n_sp->soname) == NULL)
249	name = p->n_sp->sname;
250	sp = picsymtab("", exname(name), buf2);
251	}
252	sp->sclass = STATIC;
253	sp->stype = p->n_sp->stype;
254	q = tempnode(gotnr, PTR+VOID, 0, MKAP(VOID));
255	r = xbcon(0, sp, INT);
256	q = buildtree(PLUS, q, r);
257	q = block(UMUL, q, 0, p->n_type, p->n_df, p->n_ap);
258	q->n_sp = p->n_sp;
259	nfree(p);
260	return q;
261
262	#elif defined(PECOFFABI)
263
264	return p;
265
266	#endif
267
268	}
269
270	#ifdef TLS
271	/*
272	* Create a reference for a TLS variable.
273	*/
274	static NODE *
275	tlspic(NODE *p)
276	{
277	NODE q, r;
278	struct symtab sp, sp2;
279	char *name;
280
281	/*
282	* creates:
283	* leal var@TLSGD(%ebx),%eax
284	* call ___tls_get_addr@PLT
285	*/
286
287	/* calc address of var@TLSGD */
288	q = tempnode(gotnr, PTR\|VOID, 0, MKAP(VOID));
289	if ((name = p->n_sp->soname) == NULL)
290	name = p->n_sp->sname;
291	sp = picsymtab("", name, "@TLSGD");
292	r = xbcon(0, sp, INT);
293	q = buildtree(PLUS, q, r);
294
295	/* assign to %eax */
296	r = block(REG, NIL, NIL, PTR\|VOID, 0, MKAP(VOID));
297	r->n_rval = EAX;
298	q = buildtree(ASSIGN, r, q);
299
300	/* call ___tls_get_addr */
301	sp2 = lookup("___tls_get_addr@PLT", 0);
302	sp2->stype = EXTERN\|INT\|FTN;
303	r = nametree(sp2);
304	r = buildtree(ADDROF, r, NIL);
305	r = block(UCALL, r, NIL, INT, 0, MKAP(INT));
306
307	/* fusion both parts together */
308	q = buildtree(COMOP, q, r);
309	q = block(UMUL, q, 0, p->n_type, p->n_df, p->n_ap);
310	q->n_sp = p->n_sp; /* for init */
311
312	nfree(p);
313	return q;
314	}
315
316	static NODE *
317	tlsnonpic(NODE *p)
318	{
319	NODE q, r;
320	struct symtab sp, sp2;
321	int ext = p->n_sp->sclass;
322	char *name;
323
324	if ((name = p->n_sp->soname) == NULL)
325	name = p->n_sp->sname;
326	sp = picsymtab("", name,
327	ext == EXTERN ? "@INDNTPOFF" : "@NTPOFF");
328	q = xbcon(0, sp, INT);
329	if (ext == EXTERN)
330	q = block(UMUL, q, NIL, PTR\|VOID, 0, MKAP(VOID));
331
332	sp2 = lookup("%gs:0", 0);
333	sp2->stype = EXTERN\|INT;
334	r = nametree(sp2);
335
336	q = buildtree(PLUS, q, r);
337	q = block(UMUL, q, 0, p->n_type, p->n_df, p->n_ap);
338	q->n_sp = p->n_sp; /* for init */
339
340	nfree(p);
341	return q;
342	}
343
344	static NODE *
345	tlsref(NODE *p)
346	{
347	if (kflag)
348	return (tlspic(p));
349	else
350	return (tlsnonpic(p));
351	}
352	#endif
353
354	/* clocal() is called to do local transformations on
355	* an expression tree preparitory to its being
356	* written out in intermediate code.
357	*
358	* the major essential job is rewriting the
359	* automatic variables and arguments in terms of
360	* REG and OREG nodes
361	* conversion ops which are not necessary are also clobbered here
362	* in addition, any special features (such as rewriting
363	* exclusive or) are easily handled here as well
364	*/
365	NODE *
366	clocal(NODE *p)
367	{
368
369	register struct symtab *q;
370	register NODE r, l;
371	#if defined(os_openbsd)
372	register NODE s, n;
373	#endif
374	register int o;
375	register int m;
376
377	#ifdef PCC_DEBUG
378	if (xdebug) {
379	printf("clocal: %p\n", p);
380	fwalk(p, eprint, 0);
381	}
382	#endif
383	switch( o = p->n_op ){
384
385	case NAME:
386	if ((q = p->n_sp) == NULL)
387	return p; /* Nothing to care about */
388
389	switch (q->sclass) {
390
391	case PARAM:
392	case AUTO:
393	/* fake up a structure reference */
394	r = block(REG, NIL, NIL, PTR+STRTY, 0, 0);
395	r->n_lval = 0;
396	r->n_rval = FPREG;
397	p = stref(block(STREF, r, p, 0, 0, 0));
398	break;
399
400	case USTATIC:
401	if (kflag == 0)
402	break;
403	/* FALLTHROUGH */
404	case STATIC:
405	#ifdef TLS
406	if (q->sflags & STLS) {
407	p = tlsref(p);
408	break;
409	}
410	#endif
411	if (kflag == 0) {
412	if (q->slevel == 0)
413	break;
414	p->n_lval = 0;
415	} else if (blevel > 0)
416	p = picstatic(p);
417	break;
418
419	case REGISTER:
420	p->n_op = REG;
421	p->n_lval = 0;
422	p->n_rval = q->soffset;
423	break;
424
425	case EXTERN:
426	case EXTDEF:
427	#ifdef TLS
428	if (q->sflags & STLS) {
429	p = tlsref(p);
430	break;
431	}
432	#endif
433
434	#ifdef os_win32
435	if (q->sflags & SDLLINDIRECT)
436	p = import(p);
437	#endif
438	if (kflag == 0)
439	break;
440	if (blevel > 0)
441	p = picext(p);
442	break;
443	}
444	break;
445
446	case ADDROF:
447	if (kflag == 0 \|\| blevel == 0)
448	break;
449	/* char arrays may end up here */
450	l = p->n_left;
451	if (l->n_op != NAME \|\|
452	(l->n_type != ARY+CHAR && l->n_type != ARY+WCHAR_TYPE))
453	break;
454	l = p;
455	p = picstatic(p->n_left);
456	nfree(l);
457	if (p->n_op != UMUL)
458	cerror("ADDROF error");
459	l = p;
460	p = p->n_left;
461	nfree(l);
462	break;
463
464	case UCALL:
465	case USTCALL:
466	if (kflag == 0)
467	break;
468	#if defined(ELFABI)
469	/* Change to CALL node with ebx as argument */
470	l = block(REG, NIL, NIL, INT, 0, MKAP(INT));
471	l->n_rval = EBX;
472	p->n_right = buildtree(ASSIGN, l,
473	tempnode(gotnr, INT, 0, MKAP(INT)));
474	p->n_op -= (UCALL-CALL);
475	#endif
476
477	/* FALLTHROUGH */
478	#if defined(MACHOABI)
479	case CALL:
480	case STCALL:
481	if (p->n_type == VOID)
482	break;
483
484	r = tempnode(0, p->n_type, p->n_df, p->n_ap);
485	l = tcopy(r);
486	p = buildtree(COMOP, buildtree(ASSIGN, r, p), l);
487	#endif
488
489	break;
490
491	#ifdef notyet
492	/* XXX breaks sometimes */
493	case CBRANCH:
494	l = p->n_left;
495
496	/*
497	* Remove unnecessary conversion ops.
498	*/
499	if (!clogop(l->n_op) \|\| l->n_left->n_op != SCONV)
500	break;
501	if (coptype(l->n_op) != BITYPE)
502	break;
503	if (l->n_right->n_op != ICON)
504	break;
505	r = l->n_left->n_left;
506	if (r->n_type >= FLOAT)
507	break;
508	if (toolarge(r->n_type, l->n_right->n_lval))
509	break;
510	l->n_right->n_type = r->n_type;
511	if (l->n_op >= ULE && l->n_op <= UGT)
512	l->n_op -= (UGT-ULE);
513	p->n_left = buildtree(l->n_op, r, l->n_right);
514	nfree(l->n_left);
515	nfree(l);
516	break;
517	#endif
518
519	case PCONV:
520	/* Remove redundant PCONV's. Be careful */
521	l = p->n_left;
522	if (l->n_op == ICON) {
523	l->n_lval = (unsigned)l->n_lval;
524	goto delp;
525	}
526	if (l->n_type < INT \|\| l->n_type == LONGLONG \|\|
527	l->n_type == ULONGLONG) {
528	/* float etc? */
529	p->n_left = block(SCONV, l, NIL,
530	UNSIGNED, 0, MKAP(UNSIGNED));
531	break;
532	}
533	/* if left is SCONV, cannot remove */
534	if (l->n_op == SCONV)
535	break;
536
537	/* avoid ADDROF TEMP */
538	if (l->n_op == ADDROF && l->n_left->n_op == TEMP)
539	break;
540
541	/* if conversion to another pointer type, just remove */
542	if (p->n_type > BTMASK && l->n_type > BTMASK)
543	goto delp;
544	break;
545
546	delp: l->n_type = p->n_type;
547	l->n_qual = p->n_qual;
548	l->n_df = p->n_df;
549	l->n_ap = p->n_ap;
550	nfree(p);
551	p = l;
552	break;
553
554	case SCONV:
555	if (p->n_left->n_op == COMOP)
556	break; /* may propagate wrong type later */
557	l = p->n_left;
558
559	if (p->n_type == l->n_type) {
560	nfree(p);
561	return l;
562	}
563
564	if ((p->n_type & TMASK) == 0 && (l->n_type & TMASK) == 0 &&
565	btattr[p->n_type].atypsz == btattr[l->n_type].atypsz) {
566	if (p->n_type != FLOAT && p->n_type != DOUBLE &&
567	l->n_type != FLOAT && l->n_type != DOUBLE &&
568	l->n_type != LDOUBLE && p->n_type != LDOUBLE) {
569	if (l->n_op == NAME \|\| l->n_op == UMUL \|\|
570	l->n_op == TEMP) {
571	l->n_type = p->n_type;
572	nfree(p);
573	return l;
574	}
575	}
576	}
577
578	if (DEUNSIGN(p->n_type) == INT && DEUNSIGN(l->n_type) == INT &&
579	coptype(l->n_op) == BITYPE && l->n_op != COMOP &&
580	l->n_op != QUEST) {
581	l->n_type = p->n_type;
582	nfree(p);
583	return l;
584	}
585
586	o = l->n_op;
587	m = p->n_type;
588
589	if (o == ICON) {
590	CONSZ val = l->n_lval;
591
592	if (!ISPTR(m)) /* Pointers don't need to be conv'd */
593	switch (m) {
594	case BOOL:
595	l->n_lval = nncon(l) ? (l->n_lval != 0) : 1;
596	l->n_sp = NULL;
597	break;
598	case CHAR:
599	l->n_lval = (char)val;
600	break;
601	case UCHAR:
602	l->n_lval = val & 0377;
603	break;
604	case SHORT:
605	l->n_lval = (short)val;
606	break;
607	case USHORT:
608	l->n_lval = val & 0177777;
609	break;
610	case ULONG:
611	case UNSIGNED:
612	l->n_lval = val & 0xffffffff;
613	break;
614	case LONG:
615	case INT:
616	l->n_lval = (int)val;
617	break;
618	case LONGLONG:
619	l->n_lval = (long long)val;
620	break;
621	case ULONGLONG:
622	l->n_lval = val;
623	break;
624	case VOID:
625	break;
626	case LDOUBLE:
627	case DOUBLE:
628	case FLOAT:
629	l->n_op = FCON;
630	l->n_dcon = val;
631	break;
632	default:
633	cerror("unknown type %d", m);
634	}
635	l->n_type = m;
636	l->n_ap = MKAP(m);
637	nfree(p);
638	return l;
639	} else if (l->n_op == FCON) {
640	l->n_lval = (CONSZ)l->n_dcon;
641	l->n_sp = NULL;
642	l->n_op = ICON;
643	l->n_type = m;
644	l->n_ap = MKAP(m);
645	nfree(p);
646	return clocal(l);
647	}
648	if (DEUNSIGN(p->n_type) == SHORT &&
649	DEUNSIGN(l->n_type) == SHORT) {
650	nfree(p);
651	p = l;
652	}
653	if ((p->n_type == CHAR \|\| p->n_type == UCHAR \|\|
654	p->n_type == SHORT \|\| p->n_type == USHORT) &&
655	(l->n_type == FLOAT \|\| l->n_type == DOUBLE \|\|
656	l->n_type == LDOUBLE)) {
657	p = block(SCONV, p, NIL, p->n_type, p->n_df, p->n_ap);
658	p->n_left->n_type = INT;
659	return p;
660	}
661	break;
662
663	case MOD:
664	case DIV:
665	if (o == DIV && p->n_type != CHAR && p->n_type != SHORT)
666	break;
667	if (o == MOD && p->n_type != CHAR && p->n_type != SHORT)
668	break;
669	/* make it an int division by inserting conversions */
670	p->n_left = block(SCONV, p->n_left, NIL, INT, 0, MKAP(INT));
671	p->n_right = block(SCONV, p->n_right, NIL, INT, 0, MKAP(INT));
672	p = block(SCONV, p, NIL, p->n_type, 0, MKAP(p->n_type));
673	p->n_left->n_type = INT;
674	break;
675
676	case PMCONV:
677	case PVCONV:
678	r = p;
679	p = buildtree(o == PMCONV ? MUL : DIV, p->n_left, p->n_right);
680	nfree(r);
681	break;
682
683	case FORCE:
684	/* put return value in return reg */
685	p->n_op = ASSIGN;
686	p->n_right = p->n_left;
687	p->n_left = block(REG, NIL, NIL, p->n_type, 0, MKAP(INT));
688	p->n_left->n_rval = p->n_left->n_type == BOOL ?
689	RETREG(CHAR) : RETREG(p->n_type);
690	break;
691
692	case LS:
693	case RS:
694	/* shift count must be in a char */
695	if (p->n_right->n_type == CHAR \|\| p->n_right->n_type == UCHAR)
696	break;
697	p->n_right = block(SCONV, p->n_right, NIL, CHAR, 0, MKAP(CHAR));
698	break;
699	#if defined(os_openbsd)
700	/* If not using pcc struct return */
701	case STASG:
702	r = p->n_right;
703	if (r->n_op != STCALL && r->n_op != USTCALL)
704	break;
705	m = tsize(BTYPE(r->n_type), r->n_df, r->n_ap);
706	if (m == SZCHAR)
707	m = CHAR;
708	else if (m == SZSHORT)
709	m = SHORT;
710	else if (m == SZINT)
711	m = INT;
712	else if (m == SZLONGLONG)
713	m = LONGLONG;
714	else
715	break;
716
717	l = buildtree(ADDROF, p->n_left, NIL);
718	nfree(p);
719
720	r->n_op -= (STCALL-CALL);
721	r->n_type = m;
722
723	/* r = long, l = &struct */
724
725	n = tempnode(0, m, r->n_df, r->n_ap);
726	r = buildtree(ASSIGN, ccopy(n), r);
727
728	s = tempnode(0, l->n_type, l->n_df, l->n_ap);
729	l = buildtree(ASSIGN, ccopy(s), l);
730
731	p = buildtree(COMOP, r, l);
732
733	l = buildtree(CAST,
734	block(NAME, NIL, NIL, m\|PTR, 0, MKAP(m)), ccopy(s));
735	r = l->n_right;
736	nfree(l->n_left);
737	nfree(l);
738
739	r = buildtree(ASSIGN, buildtree(UMUL, r, NIL), n);
740	p = buildtree(COMOP, p, r);
741	p = buildtree(COMOP, p, s);
742	break;
743	#endif
744	}
745	#ifdef PCC_DEBUG
746	if (xdebug) {
747	printf("clocal end: %p\n", p);
748	fwalk(p, eprint, 0);
749	}
750	#endif
751	return(p);
752	}
753
754	/*
755	* Change CALL references to either direct (static) or PLT.
756	*/
757	static void
758	fixnames(NODE p, void arg)
759	{
760	#if !defined(PECOFFABI)
761
762	struct symtab *sp;
763	struct attr *ap;
764	NODE *q;
765	char *c;
766	int isu;
767
768	if ((cdope(p->n_op) & CALLFLG) == 0)
769	return;
770	isu = 0;
771	q = p->n_left;
772	ap = q->n_ap;
773	if (q->n_op == UMUL)
774	q = q->n_left, isu = 1;
775
776	if (q->n_op == PLUS && q->n_left->n_op == TEMP &&
777	q->n_right->n_op == ICON) {
778	sp = q->n_right->n_sp;
779
780	if (sp == NULL)
781	return; /* nothing to do */
782	if (sp->sclass == STATIC && !ISFTN(sp->stype))
783	return; /* function pointer */
784
785	if (sp->sclass != STATIC && sp->sclass != EXTERN &&
786	sp->sclass != EXTDEF)
787	cerror("fixnames");
788	c = NULL;
789	#if defined(ELFABI)
790
791	if (sp->soname == NULL \|\|
792	(c = strstr(sp->soname, "@GOT")) == NULL)
793	cerror("fixnames2");
794	if (isu) {
795	memcpy(c, "@PLT", sizeof("@PLT"));
796	} else
797	*c = 0;
798
799	#elif defined(MACHOABI)
800
801	if (sp->soname == NULL \|\|
802	((c = strstr(sp->soname, "$non_lazy_ptr")) == NULL &&
803	(c = strstr(sp->soname, "-L")) == NULL))
804	cerror("fixnames2");
805	if (isu) {
806	*c = 0;
807	addstub(&stublist, sp->soname+1);
808	strcpy(c, "$stub");
809	} else
810	*c = 0;
811
812	#endif
813
814	nfree(q->n_left);
815	q = q->n_right;
816	if (isu)
817	nfree(p->n_left->n_left);
818	nfree(p->n_left);
819	p->n_left = q;
820	q->n_ap = ap;
821	}
822	#endif
823	}
824
825	static void mangle(NODE *p);
826
827	void
828	myp2tree(NODE *p)
829	{
830	struct symtab *sp;
831
832	if (kflag)
833	fixnames(p, 0);
834
835	mangle(p);
836
837	if (p->n_op != FCON)
838	return;
839
840	sp = IALLOC(sizeof(struct symtab));
841	sp->sclass = STATIC;
842	sp->sap = MKAP(p->n_type);
843	sp->slevel = 1; /* fake numeric label */
844	sp->soffset = getlab();
845	sp->sflags = 0;
846	sp->stype = p->n_type;
847	sp->squal = (CON >> TSHIFT);
848
849	defloc(sp);
850	ninval(0, sp->sap->atypsz, p);
851
852	p->n_op = NAME;
853	p->n_lval = 0;
854	p->n_sp = sp;
855	}
856
857	/ARGSUSED/
858	int
859	andable(NODE *p)
860	{
861	return(1); /* all names can have & taken on them */
862	}
863
864	/*
865	* at the end of the arguments of a ftn, set the automatic offset
866	*/
867	void
868	cendarg()
869	{
870	autooff = AUTOINIT;
871	}
872
873	/*
874	* Return 1 if a variable of type type is OK to put in register.
875	*/
876	int
877	cisreg(TWORD t)
878	{
879	if (t == FLOAT \|\| t == DOUBLE \|\| t == LDOUBLE)
880	return 0; /* not yet */
881	return 1;
882	}
883
884	/*
885	* return a node, for structure references, which is suitable for
886	* being added to a pointer of type t, in order to be off bits offset
887	* into a structure
888	* t, d, and s are the type, dimension offset, and sizeoffset
889	* For pdp10, return the type-specific index number which calculation
890	* is based on its size. For example, short a[3] would return 3.
891	* Be careful about only handling first-level pointers, the following
892	* indirections must be fullword.
893	*/
894	NODE *
895	offcon(OFFSZ off, TWORD t, union dimfun d, struct attr ap)
896	{
897	register NODE *p;
898
899	if (xdebug)
900	printf("offcon: OFFSZ %lld type %x dim %p siz %d\n",
901	off, t, d, 0);
902
903	p = bcon(0);
904	p->n_lval = off/SZCHAR; /* Default */
905	return(p);
906	}
907
908	/*
909	* Allocate off bits on the stack. p is a tree that when evaluated
910	* is the multiply count for off, t is a storeable node where to write
911	* the allocated address.
912	*/
913	void
914	spalloc(NODE t, NODE p, OFFSZ off)
915	{
916	NODE *sp;
917
918	p = buildtree(MUL, p, bcon(off/SZCHAR)); /* XXX word alignment? */
919
920	/* sub the size from sp */
921	sp = block(REG, NIL, NIL, p->n_type, 0, MKAP(INT));
922	sp->n_lval = 0;
923	sp->n_rval = STKREG;
924	ecomp(buildtree(MINUSEQ, sp, p));
925
926	#ifdef MACHOABI
927	/* align to 16 bytes */
928	sp = block(REG, NIL, NIL, p->n_type, 0, MKAP(INT));
929	sp->n_lval = 0;
930	sp->n_rval = STKREG;
931	ecomp(buildtree(PLUSEQ, sp, bcon(15)));
932
933	sp = block(REG, NIL, NIL, p->n_type, 0, MKAP(INT));
934	sp->n_lval = 0;
935	sp->n_rval = STKREG;
936	ecomp(buildtree(RSEQ, sp, bcon(4)));
937
938	sp = block(REG, NIL, NIL, p->n_type, 0, MKAP(INT));
939	sp->n_lval = 0;
940	sp->n_rval = STKREG;
941	ecomp(buildtree(LSEQ, sp, bcon(4)));
942	#endif
943
944
945	/* save the address of sp */
946	sp = block(REG, NIL, NIL, PTR+INT, t->n_df, t->n_ap);
947	sp->n_lval = 0;
948	sp->n_rval = STKREG;
949	t->n_type = sp->n_type;
950	ecomp(buildtree(ASSIGN, t, sp)); /* Emit! */
951
952	}
953
954	/*
955	* Print out a string of characters.
956	* Assume that the assembler understands C-style escape
957	* sequences.
958	*/
959	void
960	instring(struct symtab *sp)
961	{
962	char s, str = sp->sname;
963
964	#if defined(ELFABI) \|\| defined(PECOFFABI)
965
966	defloc(sp);
967
968	#elif defined(MACHOABI)
969
970	extern int lastloc;
971	if (lastloc != STRNG)
972	printf(" .cstring\n");
973	lastloc = STRNG;
974	printf("\t.p2align 2\n");
975	printf(LABFMT ":\n", sp->soffset);
976
977	#endif
978
979	/* be kind to assemblers and avoid long strings */
980	printf("\t.ascii \"");
981	for (s = str; *s != 0; ) {
982	if (*s++ == '\\') {
983	(void)esccon(&s);
984	}
985	if (s - str > 60) {
986	fwrite(str, 1, s - str, stdout);
987	printf("\"\n\t.ascii \"");
988	str = s;
989	}
990	}
991	fwrite(str, 1, s - str, stdout);
992	printf("\\0\"\n");
993	}
994
995	static int inbits, inval;
996
997	/*
998	* set fsz bits in sequence to zero.
999	*/
1000	void
1001	zbits(OFFSZ off, int fsz)
1002	{
1003	int m;
1004
1005	if (idebug)
1006	printf("zbits off %lld, fsz %d inbits %d\n", off, fsz, inbits);
1007	if ((m = (inbits % SZCHAR))) {
1008	m = SZCHAR - m;
1009	if (fsz < m) {
1010	inbits += fsz;
1011	return;
1012	} else {
1013	fsz -= m;
1014	printf("\t.byte %d\n", inval);
1015	inval = inbits = 0;
1016	}
1017	}
1018	if (fsz >= SZCHAR) {
1019	#ifdef os_darwin
1020	printf("\t.space %d\n", fsz/SZCHAR);
1021	#else
1022	printf("\t.zero %d\n", fsz/SZCHAR);
1023	#endif
1024	fsz -= (fsz/SZCHAR) * SZCHAR;
1025	}
1026	if (fsz) {
1027	inval = 0;
1028	inbits = fsz;
1029	}
1030	}
1031
1032	/*
1033	* Initialize a bitfield.
1034	*/
1035	void
1036	infld(CONSZ off, int fsz, CONSZ val)
1037	{
1038	if (idebug)
1039	printf("infld off %lld, fsz %d, val %lld inbits %d\n",
1040	off, fsz, val, inbits);
1041	val &= ((CONSZ)1 << fsz)-1;
1042	while (fsz + inbits >= SZCHAR) {
1043	inval \|= (int)(val << inbits);
1044	printf("\t.byte %d\n", inval & 255);
1045	fsz -= (SZCHAR - inbits);
1046	val >>= (SZCHAR - inbits);
1047	inval = inbits = 0;
1048	}
1049	if (fsz) {
1050	inval \|= (int)(val << inbits);
1051	inbits += fsz;
1052	}
1053	}
1054
1055	/*
1056	* print out a constant node, may be associated with a label.
1057	* Do not free the node after use.
1058	* off is bit offset from the beginning of the aggregate
1059	* fsz is the number of bits this is referring to
1060	*/
1061	void
1062	ninval(CONSZ off, int fsz, NODE *p)
1063	{
1064	union { float f; double d; long double l; int i[3]; } u;
1065	struct symtab *q;
1066	#if defined(ELFABI) \|\| defined(MACHOABI)
1067	char *c;
1068	#endif
1069	TWORD t;
1070	int i;
1071
1072	t = p->n_type;
1073	if (t > BTMASK)
1074	t = INT; /* pointer */
1075
1076	while (p->n_op == SCONV \|\| p->n_op == PCONV) {
1077	NODE *l = p->n_left;
1078	l->n_type = p->n_type;
1079	p = l;
1080	}
1081
1082	if (kflag && (p->n_op == PLUS \|\| p->n_op == UMUL)) {
1083	if (p->n_op == UMUL)
1084	p = p->n_left;
1085	p = p->n_right;
1086	q = p->n_sp;
1087
1088	if (q->soname != NULL) {
1089	#if defined(ELFABI)
1090
1091	if ((c = strstr(q->soname, "@GOT")) != NULL)
1092	c = 0; / ignore GOT ref here */
1093	#elif defined(MACHOABI)
1094
1095	if ((c = strstr(q->soname, "$non_lazy_ptr")) != NULL) {
1096	q->soname++; /* skip "L" */
1097	c = 0; / ignore GOT ref here */
1098	} else if ((c = strstr(q->soname, "-L")) != NULL)
1099	c = 0; / ignore GOT ref here */
1100	#endif
1101	}
1102	}
1103	if (p->n_op != ICON && p->n_op != FCON)
1104	cerror("ninval: init node not constant");
1105
1106	if (p->n_op == ICON && p->n_sp != NULL && DEUNSIGN(t) != INT)
1107	uerror("element not constant");
1108
1109	switch (t) {
1110	case LONGLONG:
1111	case ULONGLONG:
1112	i = (int)(p->n_lval >> 32);
1113	p->n_lval &= 0xffffffff;
1114	p->n_type = INT;
1115	ninval(off, 32, p);
1116	p->n_lval = i;
1117	ninval(off+32, 32, p);
1118	break;
1119	case INT:
1120	case UNSIGNED:
1121	printf("\t.long %d", (int)p->n_lval);
1122	if ((q = p->n_sp) != NULL) {
1123	if ((q->sclass == STATIC && q->slevel > 0)) {
1124	printf("+" LABFMT, q->soffset);
1125	} else {
1126	char *name;
1127	if ((name = q->soname) == NULL)
1128	name = exname(q->sname);
1129	printf("+%s", name);
1130	}
1131	}
1132	printf("\n");
1133	break;
1134	case SHORT:
1135	case USHORT:
1136	#ifdef os_sunos
1137	printf("\t.2byte 0x%x\n", (int)p->n_lval & 0xffff);
1138	#else
1139	printf("\t.short 0x%x\n", (int)p->n_lval & 0xffff);
1140	#endif
1141	break;
1142	case BOOL:
1143	if (p->n_lval > 1)
1144	p->n_lval = p->n_lval != 0;
1145	/* FALLTHROUGH */
1146	case CHAR:
1147	case UCHAR:
1148	printf("\t.byte %d\n", (int)p->n_lval & 0xff);
1149	break;
1150	case LDOUBLE:
1151	u.i[2] = 0;
1152	u.l = (long double)p->n_dcon;
1153	#if defined(HOST_BIG_ENDIAN)
1154	/* XXX probably broken on most hosts */
1155	printf("\t.long\t0x%x,0x%x,0x%x\n", u.i[2], u.i[1], u.i[0]);
1156	#else
1157	printf("\t.long\t%d,%d,%d\n", u.i[0], u.i[1], u.i[2] & 0177777);
1158	#endif
1159	break;
1160	case DOUBLE:
1161	u.d = (double)p->n_dcon;
1162	#if defined(HOST_BIG_ENDIAN)
1163	printf("\t.long\t0x%x,0x%x\n", u.i[1], u.i[0]);
1164	#else
1165	printf("\t.long\t%d,%d\n", u.i[0], u.i[1]);
1166	#endif
1167	break;
1168	case FLOAT:
1169	u.f = (float)p->n_dcon;
1170	printf("\t.long\t%d\n", u.i[0]);
1171	break;
1172	default:
1173	cerror("ninval");
1174	}
1175	}
1176
1177	/* make a name look like an external name in the local machine */
1178	char *
1179	exname(char *p)
1180	{
1181	#if defined(PECOFFABI) \|\| defined(MACHOABI)
1182
1183	#define NCHNAM 256
1184	static char text[NCHNAM+1];
1185	int i;
1186
1187	if (p == NULL)
1188	return "";
1189
1190	text[0] = '_';
1191	for (i=1; *p && i<NCHNAM; ++i)
1192	text[i] = *p++;
1193
1194	text[i] = '\0';
1195	text[NCHNAM] = '\0'; /* truncate */
1196
1197	return (text);
1198
1199	#else
1200
1201	return (p == NULL ? "" : p);
1202
1203	#endif
1204	}
1205
1206	/*
1207	* map types which are not defined on the local machine
1208	*/
1209	TWORD
1210	ctype(TWORD type)
1211	{
1212	switch (BTYPE(type)) {
1213	case LONG:
1214	MODTYPE(type,INT);
1215	break;
1216
1217	case ULONG:
1218	MODTYPE(type,UNSIGNED);
1219
1220	}
1221	return (type);
1222	}
1223
1224	void
1225	calldec(NODE p, NODE q)
1226	{
1227	}
1228
1229	void
1230	extdec(struct symtab *q)
1231	{
1232	}
1233
1234	/* make a common declaration for id, if reasonable */
1235	void
1236	defzero(struct symtab *sp)
1237	{
1238	int off;
1239	int al;
1240	char *name;
1241
1242	#ifdef TLS
1243	if (sp->sflags & STLS) {
1244	if (sp->sclass == EXTERN)
1245	sp->sclass = EXTDEF;
1246	simpleinit(sp, bcon(0));
1247	return;
1248	}
1249	#endif
1250
1251	if ((name = sp->soname) == NULL)
1252	name = exname(sp->sname);
1253	al = talign(sp->stype, sp->sap)/SZCHAR;
1254	off = (int)tsize(sp->stype, sp->sdf, sp->sap);
1255	off = (off+(SZCHAR-1))/SZCHAR;
1256	#ifdef GCC_COMPAT
1257	{
1258	struct attr *ap;
1259	if ((ap = attr_find(sp->sap, GCC_ATYP_VISIBILITY)) &&
1260	strcmp(ap->sarg(0), "default"))
1261	printf("\t.%s %s\n", ap->sarg(0), name);
1262	}
1263	#endif
1264	printf(" .%scomm ", sp->sclass == STATIC ? "l" : "");
1265	if (sp->slevel == 0)
1266	printf("%s,0%o", name, off);
1267	else
1268	printf(LABFMT ",0%o", sp->soffset, off);
1269	if (sp->sclass != STATIC) {
1270	#if defined(ELFABI)
1271	printf(",%d", al);
1272	#elif defined(MACHOABI)
1273	printf(",%d", ispow2(al));
1274	#endif
1275	}
1276	printf("\n");
1277	}
1278
1279	static char *
1280	section2string(char *name, int len)
1281	{
1282	#if defined(ELFABI)
1283	char *s;
1284	int n;
1285
1286	if (strncmp(name, "link_set", 8) == 0) {
1287	const char *postfix = ",\"aw\",@progbits";
1288	n = len + strlen(postfix) + 1;
1289	s = IALLOC(n);
1290	strlcpy(s, name, n);
1291	strlcat(s, postfix, n);
1292	return s;
1293	}
1294	#endif
1295
1296	return newstring(name, len);
1297	}
1298
1299	char *nextsect;
1300	#ifdef TLS
1301	static int gottls;
1302	#endif
1303	static int stdcall;
1304	#ifdef os_win32
1305	static int dllindirect;
1306	#endif
1307	static char *alias;
1308	static int constructor;
1309	static int destructor;
1310
1311	/*
1312	* Give target the opportunity of handling pragmas.
1313	*/
1314	int
1315	mypragma(char *str)
1316	{
1317	char *a2 = pragtok(NULL);
1318
1319	#ifdef TLS
1320	if (strcmp(str, "tls") == 0 && a2 == NULL) {
1321	gottls = 1;
1322	return 1;
1323	}
1324	#endif
1325	if (strcmp(str, "stdcall") == 0) {
1326	stdcall = 1;
1327	return 1;
1328	}
1329	if (strcmp(str, "cdecl") == 0) {
1330	stdcall = 0;
1331	return 1;
1332	}
1333	#ifdef os_win32
1334	if (strcmp(str, "fastcall") == 0) {
1335	stdcall = 2;
1336	return 1;
1337	}
1338	if (strcmp(str, "dllimport") == 0) {
1339	dllindirect = 1;
1340	return 1;
1341	}
1342	if (strcmp(str, "dllexport") == 0) {
1343	dllindirect = 1;
1344	return 1;
1345	}
1346	#endif
1347	if (strcmp(str, "constructor") == 0 \|\| strcmp(str, "init") == 0) {
1348	constructor = 1;
1349	return 1;
1350	}
1351	if (strcmp(str, "destructor") == 0 \|\| strcmp(str, "fini") == 0) {
1352	destructor = 1;
1353	return 1;
1354	}
1355	if (strcmp(str, "section") == 0 && a2 != NULL) {
1356	nextsect = section2string(a2, strlen(a2));
1357	return 1;
1358	}
1359	if (strcmp(str, "alias") == 0 && a2 != NULL) {
1360	alias = tmpstrdup(a2);
1361	return 1;
1362	}
1363	if (strcmp(str, "ident") == 0)
1364	return 1; /* Just ignore */
1365
1366	return 0;
1367	}
1368
1369	/*
1370	* Called when a identifier has been declared.
1371	*/
1372	void
1373	fixdef(struct symtab *sp)
1374	{
1375	struct attr *ap;
1376	#ifdef TLS
1377	/* may have sanity checks here */
1378	if (gottls)
1379	sp->sflags \|= STLS;
1380	gottls = 0;
1381	#endif
1382	if ((ap = attr_find(sp->sap, GCC_ATYP_ALIAS)) != NULL) {
1383	char *an = ap->sarg(0);
1384	char *sn = sp->soname ? sp->soname : sp->sname;
1385	char *v;
1386
1387	v = attr_find(sp->sap, GCC_ATYP_WEAK) ? "weak" : "globl";
1388	printf("\t.%s %s\n", v, sn);
1389	printf("\t.set %s,%s\n", sn, an);
1390	}
1391
1392	if (alias != NULL && (sp->sclass != PARAM)) {
1393	char *name;
1394	if ((name = sp->soname) == NULL)
1395	name = exname(sp->sname);
1396	printf("\t.globl %s\n", name);
1397	printf("%s = ", name);
1398	printf("%s\n", exname(alias));
1399	alias = NULL;
1400	}
1401	if ((constructor \|\| destructor) && (sp->sclass != PARAM)) {
1402	#if defined(ELFABI)
1403	printf("\t.section .%ctors,\"aw\",@progbits\n",
1404	constructor ? 'c' : 'd');
1405	#elif defined(PECOFFABI)
1406	printf("\t.section .%ctors,\"w\"\n",
1407	constructor ? 'c' : 'd');
1408	#elif defined(MACHOABI)
1409	if (kflag) {
1410	if (constructor)
1411	printf("\t.mod_init_func\n");
1412	else
1413	printf("\t.mod_term_func\n");
1414	} else {
1415	if (constructor)
1416	printf("\t.constructor\n");
1417	else
1418	printf("\t.destructor\n");
1419	}
1420	#endif
1421	printf("\t.p2align 2\n");
1422	printf("\t.long %s\n", exname(sp->sname));
1423	#ifdef MACHOABI
1424	printf("\t.text\n");
1425	#else
1426	printf("\t.previous\n");
1427	#endif
1428	constructor = destructor = 0;
1429	}
1430	if (stdcall && (sp->sclass != PARAM)) {
1431	sp->sflags \|= SSTDCALL;
1432	stdcall = 0;
1433	}
1434	#ifdef os_win32
1435	if (dllindirect && (sp->sclass != PARAM)) {
1436	sp->sflags \|= SDLLINDIRECT;
1437	dllindirect = 0;
1438	}
1439	#endif
1440	}
1441
1442	NODE *
1443	i386_builtin_return_address(NODE f, NODE a, TWORD rt)
1444	{
1445	int nframes;
1446
1447	if (a == NULL \|\| a->n_op != ICON)
1448	goto bad;
1449
1450	nframes = (int)a->n_lval;
1451
1452	tfree(f);
1453	tfree(a);
1454
1455	f = block(REG, NIL, NIL, PTR+VOID, 0, MKAP(VOID));
1456	regno(f) = FPREG;
1457
1458	while (nframes--)
1459	f = block(UMUL, f, NIL, PTR+VOID, 0, MKAP(VOID));
1460
1461	f = block(PLUS, f, bcon(4), INCREF(PTR+VOID), 0, MKAP(VOID));
1462	f = buildtree(UMUL, f, NIL);
1463
1464	return f;
1465	bad:
1466	uerror("bad argument to __builtin_return_address");
1467	return bcon(0);
1468	}
1469
1470	NODE *
1471	i386_builtin_frame_address(NODE f, NODE a, TWORD rt)
1472	{
1473	int nframes;
1474
1475	if (a == NULL \|\| a->n_op != ICON)
1476	goto bad;
1477
1478	nframes = (int)a->n_lval;
1479
1480	tfree(f);
1481	tfree(a);
1482
1483	f = block(REG, NIL, NIL, PTR+VOID, 0, MKAP(VOID));
1484	regno(f) = FPREG;
1485
1486	while (nframes--)
1487	f = block(UMUL, f, NIL, PTR+VOID, 0, MKAP(VOID));
1488
1489	return f;
1490	bad:
1491	uerror("bad argument to __builtin_frame_address");
1492	return bcon(0);
1493	}
1494
1495	/*
1496	* Postfix external functions with the arguments size.
1497	*/
1498	static void
1499	mangle(NODE *p)
1500	{
1501	NODE *l;
1502
1503	if (p->n_op == NAME \|\| p->n_op == ICON) {
1504	p->n_flags = 0; /* for later setting of STDCALL */
1505	if (p->n_sp) {
1506	if (p->n_sp->sflags & SSTDCALL)
1507	p->n_flags = FSTDCALL;
1508	}
1509	} else if (p->n_op == TEMP)
1510	p->n_flags = 0; /* STDCALL fun ptr not allowed */
1511
1512	if (p->n_op != CALL && p->n_op != STCALL &&
1513	p->n_op != UCALL && p->n_op != USTCALL)
1514	return;
1515
1516	p->n_flags = 0;
1517
1518	l = p->n_left;
1519	while (cdope(l->n_op) & CALLFLG)
1520	l = l->n_left;
1521	if (l->n_op == TEMP)
1522	return;
1523	if (l->n_op == ADDROF)
1524	l = l->n_left;
1525	if (l->n_sp == NULL)
1526	return;
1527	#ifdef GCC_COMPAT
1528	if (attr_find(l->n_sp->sap, GCC_ATYP_STDCALL) != NULL)
1529	l->n_sp->sflags \|= SSTDCALL;
1530	#endif
1531	#ifdef os_win32
1532	if (l->n_sp->sflags & SSTDCALL) {
1533	if (strchr(l->n_name, '@') == NULL) {
1534	int size = 0;
1535	char buf[256];
1536	NODE *r;
1537	TWORD t;
1538
1539	if (p->n_op == CALL \|\| p->n_op == STCALL) {
1540	for (r = p->n_right;
1541	r->n_op == CM; r = r->n_left) {
1542	t = r->n_type;
1543	if (t == STRTY \|\| t == UNIONTY)
1544	size += tsize(t, r->n_df, r->n_ap);
1545	else
1546	size += szty(t) * SZINT / SZCHAR;
1547	}
1548	t = r->n_type;
1549	if (t == STRTY \|\| t == UNIONTY)
1550	size += tsize(t, r->n_df, r->n_ap);
1551	else
1552	size += szty(t) * SZINT / SZCHAR;
1553	}
1554	snprintf(buf, 256, "%s@%d", l->n_name, size);
1555	l->n_name = IALLOC(strlen(buf) + 1);
1556	strcpy(l->n_name, buf);
1557	}
1558	}
1559	#endif
1560	}
1561
1562	void
1563	pass1_lastchance(struct interpass *ip)
1564	{
1565	if (ip->type == IP_NODE &&
1566	(ip->ip_node->n_op == CALL \|\| ip->ip_node->n_op == UCALL) &&
1567	ISFTY(ip->ip_node->n_type))
1568	ip->ip_node->n_flags = FFPPOP;
1569
1570	if (ip->type == IP_EPILOG) {
1571	struct interpass_prolog ipp = (struct interpass_prolog )ip;
1572	ipp->ipp_argstacksize = argstacksize;
1573	}
1574	}

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

Download in other formats: