source: mainline/uspace/app/pcc/arch/i386/local.c@ 814717fa

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 814717fa 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
RevLine 
[a7de7182]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 */
38static int
39toolarge(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
69void
70addstub(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 */
92static struct symtab *
93picsymtab(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
109static NODE *
110import(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
130int gotnr; /* tempnum for GOT register */
131int argstacksize;
132
133/*
134 * Create a reference for an extern variable.
135 */
136static NODE *
137picext(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 */
203static NODE *
204picstatic(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 */
274static NODE *
275tlspic(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
316static NODE *
317tlsnonpic(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
344static NODE *
345tlsref(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 */
365NODE *
366clocal(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 */
757static void
758fixnames(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
825static void mangle(NODE *p);
826
827void
828myp2tree(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*/
858int
859andable(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 */
867void
868cendarg()
869{
870 autooff = AUTOINIT;
871}
872
873/*
874 * Return 1 if a variable of type type is OK to put in register.
875 */
876int
877cisreg(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 */
894NODE *
895offcon(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 */
913void
914spalloc(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 */
959void
960instring(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
995static int inbits, inval;
996
997/*
998 * set fsz bits in sequence to zero.
999 */
1000void
1001zbits(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 */
1035void
1036infld(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 */
1061void
1062ninval(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 */
1178char *
1179exname(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 */
1209TWORD
1210ctype(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
1224void
1225calldec(NODE *p, NODE *q)
1226{
1227}
1228
1229void
1230extdec(struct symtab *q)
1231{
1232}
1233
1234/* make a common declaration for id, if reasonable */
1235void
1236defzero(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
1279static char *
1280section2string(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
1299char *nextsect;
1300#ifdef TLS
1301static int gottls;
1302#endif
1303static int stdcall;
1304#ifdef os_win32
1305static int dllindirect;
1306#endif
1307static char *alias;
1308static int constructor;
1309static int destructor;
1310
1311/*
1312 * Give target the opportunity of handling pragmas.
1313 */
1314int
1315mypragma(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 */
1372void
1373fixdef(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
1442NODE *
1443i386_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;
1465bad:
1466 uerror("bad argument to __builtin_return_address");
1467 return bcon(0);
1468}
1469
1470NODE *
1471i386_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;
1490bad:
1491 uerror("bad argument to __builtin_frame_address");
1492 return bcon(0);
1493}
1494
1495/*
1496 * Postfix external functions with the arguments size.
1497 */
1498static void
1499mangle(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
1562void
1563pass1_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.