← Back to branch summary

~john-koepi/ubuntu/trusty/golang/default

« back to all changes in this revision

Viewing changes to src/cmd/cc/sub.c

  • Committer: Bazaar Package Importer
  • Author(s): Ondřej Surý
  • Date: 2011-04-20 17:36:48 UTC
  • Revision ID: james.westby@ubuntu.com-20110420173648-ifergoxyrm832trd
Tags: upstream-2011.03.07.1
Import upstream version 2011.03.07.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/cmd/cc/sub.c
 
1
// Inferno utils/cc/sub.c
 
2
// http://code.google.com/p/inferno-os/source/browse/utils/cc/sub.c
 
3
//
 
4
//      Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
 
5
//      Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
 
6
//      Portions Copyright © 1997-1999 Vita Nuova Limited
 
7
//      Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
 
8
//      Portions Copyright © 2004,2006 Bruce Ellis
 
9
//      Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
 
10
//      Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
 
11
//      Portions Copyright © 2009 The Go Authors.  All rights reserved.
 
12
//
 
13
// Permission is hereby granted, free of charge, to any person obtaining a copy
 
14
// of this software and associated documentation files (the "Software"), to deal
 
15
// in the Software without restriction, including without limitation the rights
 
16
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 
17
// copies of the Software, and to permit persons to whom the Software is
 
18
// furnished to do so, subject to the following conditions:
 
19
//
 
20
// The above copyright notice and this permission notice shall be included in
 
21
// all copies or substantial portions of the Software.
 
22
//
 
23
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 
24
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 
25
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
 
26
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 
27
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 
28
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 
29
// THE SOFTWARE.
 
30
 
 
31
#include        "cc.h"
 
32
 
 
33
Node*
 
34
new(int t, Node *l, Node *r)
 
35
{
 
36
        Node *n;
 
37
 
 
38
        n = alloc(sizeof(*n));
 
39
        n->op = t;
 
40
        n->left = l;
 
41
        n->right = r;
 
42
        if(l && t != OGOTO)
 
43
                n->lineno = l->lineno;
 
44
        else if(r)
 
45
                n->lineno = r->lineno;
 
46
        else
 
47
                n->lineno = lineno;
 
48
        newflag = 1;
 
49
        return n;
 
50
}
 
51
 
 
52
Node*
 
53
new1(int o, Node *l, Node *r)
 
54
{
 
55
        Node *n;
 
56
 
 
57
        n = new(o, l, r);
 
58
        n->lineno = nearln;
 
59
        return n;
 
60
}
 
61
 
 
62
void
 
63
prtree(Node *n, char *s)
 
64
{
 
65
 
 
66
        print(" == %s ==\n", s);
 
67
        prtree1(n, 0, 0);
 
68
        print("\n");
 
69
}
 
70
 
 
71
void
 
72
prtree1(Node *n, int d, int f)
 
73
{
 
74
        int i;
 
75
 
 
76
        if(f)
 
77
        for(i=0; i<d; i++)
 
78
                print("   ");
 
79
        if(n == Z) {
 
80
                print("Z\n");
 
81
                return;
 
82
        }
 
83
        if(n->op == OLIST) {
 
84
                prtree1(n->left, d, 0);
 
85
                prtree1(n->right, d, 1);
 
86
                return;
 
87
        }
 
88
        d++;
 
89
        print("%O", n->op);
 
90
        i = 3;
 
91
        switch(n->op)
 
92
        {
 
93
        case ONAME:
 
94
                print(" \"%F\"", n);
 
95
                print(" %d", n->xoffset);
 
96
                i = 0;
 
97
                break;
 
98
 
 
99
        case OINDREG:
 
100
                print(" %d(R%d)", n->xoffset, n->reg);
 
101
                i = 0;
 
102
                break;
 
103
 
 
104
        case OREGISTER:
 
105
                if(n->xoffset)
 
106
                        print(" %d+R%d", n->xoffset, n->reg);
 
107
                else
 
108
                        print(" R%d", n->reg);
 
109
                i = 0;
 
110
                break;
 
111
 
 
112
        case OSTRING:
 
113
                print(" \"%s\"", n->cstring);
 
114
                i = 0;
 
115
                break;
 
116
 
 
117
        case OLSTRING:
 
118
                print(" \"%S\"", n->rstring);
 
119
                i = 0;
 
120
                break;
 
121
 
 
122
        case ODOT:
 
123
        case OELEM:
 
124
                print(" \"%F\"", n);
 
125
                break;
 
126
 
 
127
        case OCONST:
 
128
                if(typefd[n->type->etype])
 
129
                        print(" \"%.8e\"", n->fconst);
 
130
                else
 
131
                        print(" \"%lld\"", n->vconst);
 
132
                i = 0;
 
133
                break;
 
134
        }
 
135
        if(n->addable != 0)
 
136
                print(" <%d>", n->addable);
 
137
        if(n->type != T)
 
138
                print(" %T", n->type);
 
139
        if(n->complex != 0)
 
140
                print(" (%d)", n->complex);
 
141
        print(" %L\n", n->lineno);
 
142
        if(i & 2)
 
143
                prtree1(n->left, d, 1);
 
144
        if(i & 1)
 
145
                prtree1(n->right, d, 1);
 
146
}
 
147
 
 
148
Type*
 
149
typ(int et, Type *d)
 
150
{
 
151
        Type *t;
 
152
 
 
153
        t = alloc(sizeof(*t));
 
154
        t->etype = et;
 
155
        t->link = d;
 
156
        t->down = T;
 
157
        t->sym = S;
 
158
        t->width = ewidth[et];
 
159
        t->offset = 0;
 
160
        t->shift = 0;
 
161
        t->nbits = 0;
 
162
        t->garb = 0;
 
163
        return t;
 
164
}
 
165
 
 
166
Type*
 
167
copytyp(Type *t)
 
168
{
 
169
        Type *nt;
 
170
 
 
171
        nt = typ(TXXX, T);
 
172
        *nt = *t;
 
173
        return nt;
 
174
}
 
175
 
 
176
Type*
 
177
garbt(Type *t, int32 b)
 
178
{
 
179
        Type *t1;
 
180
 
 
181
        if(b & BGARB) {
 
182
                t1 = copytyp(t);
 
183
                t1->garb = simpleg(b);
 
184
                return t1;
 
185
        }
 
186
        return t;
 
187
}
 
188
 
 
189
int
 
190
simpleg(int32 b)
 
191
{
 
192
 
 
193
        b &= BGARB;
 
194
        switch(b) {
 
195
        case BCONSTNT:
 
196
                return GCONSTNT;
 
197
        case BVOLATILE:
 
198
                return GVOLATILE;
 
199
        case BVOLATILE|BCONSTNT:
 
200
                return GCONSTNT|GVOLATILE;
 
201
        }
 
202
        return GXXX;
 
203
}
 
204
 
 
205
int
 
206
simplec(int32 b)
 
207
{
 
208
 
 
209
        b &= BCLASS;
 
210
        switch(b) {
 
211
        case 0:
 
212
        case BREGISTER:
 
213
                return CXXX;
 
214
        case BAUTO:
 
215
        case BAUTO|BREGISTER:
 
216
                return CAUTO;
 
217
        case BEXTERN:
 
218
                return CEXTERN;
 
219
        case BEXTERN|BREGISTER:
 
220
                return CEXREG;
 
221
        case BSTATIC:
 
222
                return CSTATIC;
 
223
        case BTYPEDEF:
 
224
                return CTYPEDEF;
 
225
        case BTYPESTR:
 
226
                return CTYPESTR;
 
227
        }
 
228
        diag(Z, "illegal combination of classes %Q", b);
 
229
        return CXXX;
 
230
}
 
231
 
 
232
Type*
 
233
simplet(int32 b)
 
234
{
 
235
 
 
236
        b &= ~BCLASS & ~BGARB;
 
237
        switch(b) {
 
238
        case BCHAR:
 
239
        case BCHAR|BSIGNED:
 
240
                return types[TCHAR];
 
241
 
 
242
        case BCHAR|BUNSIGNED:
 
243
                return types[TUCHAR];
 
244
 
 
245
        case BSHORT:
 
246
        case BSHORT|BINT:
 
247
        case BSHORT|BSIGNED:
 
248
        case BSHORT|BINT|BSIGNED:
 
249
                return types[TSHORT];
 
250
 
 
251
        case BUNSIGNED|BSHORT:
 
252
        case BUNSIGNED|BSHORT|BINT:
 
253
                return types[TUSHORT];
 
254
 
 
255
        case 0:
 
256
        case BINT:
 
257
        case BINT|BSIGNED:
 
258
        case BSIGNED:
 
259
                return types[TINT];
 
260
 
 
261
        case BUNSIGNED:
 
262
        case BUNSIGNED|BINT:
 
263
                return types[TUINT];
 
264
 
 
265
        case BLONG:
 
266
        case BLONG|BINT:
 
267
        case BLONG|BSIGNED:
 
268
        case BLONG|BINT|BSIGNED:
 
269
                return types[TLONG];
 
270
 
 
271
        case BUNSIGNED|BLONG:
 
272
        case BUNSIGNED|BLONG|BINT:
 
273
                return types[TULONG];
 
274
 
 
275
        case BVLONG|BLONG:
 
276
        case BVLONG|BLONG|BINT:
 
277
        case BVLONG|BLONG|BSIGNED:
 
278
        case BVLONG|BLONG|BINT|BSIGNED:
 
279
                return types[TVLONG];
 
280
 
 
281
        case BVLONG|BLONG|BUNSIGNED:
 
282
        case BVLONG|BLONG|BINT|BUNSIGNED:
 
283
                return types[TUVLONG];
 
284
 
 
285
        case BFLOAT:
 
286
                return types[TFLOAT];
 
287
 
 
288
        case BDOUBLE:
 
289
        case BDOUBLE|BLONG:
 
290
        case BFLOAT|BLONG:
 
291
                return types[TDOUBLE];
 
292
 
 
293
        case BVOID:
 
294
                return types[TVOID];
 
295
        }
 
296
 
 
297
        diag(Z, "illegal combination of types %Q", b);
 
298
        return types[TINT];
 
299
}
 
300
 
 
301
int
 
302
stcompat(Node *n, Type *t1, Type *t2, int32 ttab[])
 
303
{
 
304
        int i;
 
305
        uint32 b;
 
306
 
 
307
        i = 0;
 
308
        if(t2 != T)
 
309
                i = t2->etype;
 
310
        b = 1L << i;
 
311
        i = 0;
 
312
        if(t1 != T)
 
313
                i = t1->etype;
 
314
        if(b & ttab[i]) {
 
315
                if(ttab == tasign)
 
316
                        if(b == BSTRUCT || b == BUNION)
 
317
                                if(!sametype(t1, t2))
 
318
                                        return 1;
 
319
                if(n->op != OCAST)
 
320
                        if(b == BIND && i == TIND)
 
321
                                if(!sametype(t1, t2))
 
322
                                        return 1;
 
323
                return 0;
 
324
        }
 
325
        return 1;
 
326
}
 
327
 
 
328
int
 
329
tcompat(Node *n, Type *t1, Type *t2, int32 ttab[])
 
330
{
 
331
 
 
332
        if(stcompat(n, t1, t2, ttab)) {
 
333
                if(t1 == T)
 
334
                        diag(n, "incompatible type: \"%T\" for op \"%O\"",
 
335
                                t2, n->op);
 
336
                else
 
337
                        diag(n, "incompatible types: \"%T\" and \"%T\" for op \"%O\"",
 
338
                                t1, t2, n->op);
 
339
                return 1;
 
340
        }
 
341
        return 0;
 
342
}
 
343
 
 
344
void
 
345
makedot(Node *n, Type *t, int32 o)
 
346
{
 
347
        Node *n1, *n2;
 
348
 
 
349
        if(t->nbits) {
 
350
                n1 = new(OXXX, Z, Z);
 
351
                *n1 = *n;
 
352
                n->op = OBIT;
 
353
                n->left = n1;
 
354
                n->right = Z;
 
355
                n->type = t;
 
356
                n->addable = n1->left->addable;
 
357
                n = n1;
 
358
        }
 
359
        n->addable = n->left->addable;
 
360
        if(n->addable == 0) {
 
361
                n1 = new1(OCONST, Z, Z);
 
362
                n1->vconst = o;
 
363
                n1->type = types[TLONG];
 
364
                n->right = n1;
 
365
                n->type = t;
 
366
                return;
 
367
        }
 
368
        n->left->type = t;
 
369
        if(o == 0) {
 
370
                *n = *n->left;
 
371
                return;
 
372
        }
 
373
        n->type = t;
 
374
        n1 = new1(OCONST, Z, Z);
 
375
        n1->vconst = o;
 
376
        t = typ(TIND, t);
 
377
        t->width = types[TIND]->width;
 
378
        n1->type = t;
 
379
 
 
380
        n2 = new1(OADDR, n->left, Z);
 
381
        n2->type = t;
 
382
 
 
383
        n1 = new1(OADD, n1, n2);
 
384
        n1->type = t;
 
385
 
 
386
        n->op = OIND;
 
387
        n->left = n1;
 
388
        n->right = Z;
 
389
}
 
390
 
 
391
Type*
 
392
dotsearch(Sym *s, Type *t, Node *n, int32 *off)
 
393
{
 
394
        Type *t1, *xt, *rt;
 
395
 
 
396
        xt = T;
 
397
 
 
398
        /*
 
399
         * look it up by name
 
400
         */
 
401
        for(t1 = t; t1 != T; t1 = t1->down)
 
402
                if(t1->sym == s) {
 
403
                        if(xt != T)
 
404
                                goto ambig;
 
405
                        xt = t1;
 
406
                }
 
407
 
 
408
        /*
 
409
         * look it up by type
 
410
         */
 
411
        if(s->class == CTYPEDEF || s->class == CTYPESTR)
 
412
                for(t1 = t; t1 != T; t1 = t1->down)
 
413
                        if(t1->sym == S && typesu[t1->etype])
 
414
                                if(sametype(s->type, t1)) {
 
415
                                        if(xt != T)
 
416
                                                goto ambig;
 
417
                                        xt = t1;
 
418
                                }
 
419
        if(xt != T) {
 
420
                *off = xt->offset;
 
421
                return xt;
 
422
        }
 
423
 
 
424
        /*
 
425
         * look it up in unnamed substructures
 
426
         */
 
427
        for(t1 = t; t1 != T; t1 = t1->down)
 
428
                if(t1->sym == S && typesu[t1->etype]){
 
429
                        rt = dotsearch(s, t1->link, n, off);
 
430
                        if(rt != T) {
 
431
                                if(xt != T)
 
432
                                        goto ambig;
 
433
                                xt = rt;
 
434
                                *off += t1->offset;
 
435
                        }
 
436
                }
 
437
        return xt;
 
438
 
 
439
ambig:
 
440
        diag(n, "ambiguous structure element: %s", s->name);
 
441
        return xt;
 
442
}
 
443
 
 
444
int32
 
445
dotoffset(Type *st, Type *lt, Node *n)
 
446
{
 
447
        Type *t;
 
448
        Sym *g;
 
449
        int32 o, o1;
 
450
 
 
451
        o = -1;
 
452
        /*
 
453
         * first try matching at the top level
 
454
         * for matching tag names
 
455
         */
 
456
        g = st->tag;
 
457
        if(g != S)
 
458
                for(t=lt->link; t!=T; t=t->down)
 
459
                        if(t->sym == S)
 
460
                                if(g == t->tag) {
 
461
                                        if(o >= 0)
 
462
                                                goto ambig;
 
463
                                        o = t->offset;
 
464
                                }
 
465
        if(o >= 0)
 
466
                return o;
 
467
 
 
468
        /*
 
469
         * second try matching at the top level
 
470
         * for similar types
 
471
         */
 
472
        for(t=lt->link; t!=T; t=t->down)
 
473
                if(t->sym == S)
 
474
                        if(sametype(st, t)) {
 
475
                                if(o >= 0)
 
476
                                        goto ambig;
 
477
                                o = t->offset;
 
478
                        }
 
479
        if(o >= 0)
 
480
                return o;
 
481
 
 
482
        /*
 
483
         * last try matching sub-levels
 
484
         */
 
485
        for(t=lt->link; t!=T; t=t->down)
 
486
                if(t->sym == S)
 
487
                if(typesu[t->etype]) {
 
488
                        o1 = dotoffset(st, t, n);
 
489
                        if(o1 >= 0) {
 
490
                                if(o >= 0)
 
491
                                        goto ambig;
 
492
                                o = o1 + t->offset;
 
493
                        }
 
494
                }
 
495
        return o;
 
496
 
 
497
ambig:
 
498
        diag(n, "ambiguous unnamed structure element");
 
499
        return o;
 
500
}
 
501
 
 
502
/*
 
503
 * look into tree for floating point constant expressions
 
504
 */
 
505
int
 
506
allfloat(Node *n, int flag)
 
507
{
 
508
 
 
509
        if(n != Z) {
 
510
                if(n->type->etype != TDOUBLE)
 
511
                        return 1;
 
512
                switch(n->op) {
 
513
                case OCONST:
 
514
                        if(flag)
 
515
                                n->type = types[TFLOAT];
 
516
                        return 1;
 
517
                case OADD:      /* no need to get more exotic than this */
 
518
                case OSUB:
 
519
                case OMUL:
 
520
                case ODIV:
 
521
                        if(!allfloat(n->right, flag))
 
522
                                break;
 
523
                case OCAST:
 
524
                        if(!allfloat(n->left, flag))
 
525
                                break;
 
526
                        if(flag)
 
527
                                n->type = types[TFLOAT];
 
528
                        return 1;
 
529
                }
 
530
        }
 
531
        return 0;
 
532
}
 
533
 
 
534
void
 
535
constas(Node *n, Type *il, Type *ir)
 
536
{
 
537
        Type *l, *r;
 
538
 
 
539
        l = il;
 
540
        r = ir;
 
541
 
 
542
        if(l == T)
 
543
                return;
 
544
        if(l->garb & GCONSTNT) {
 
545
                warn(n, "assignment to a constant type (%T)", il);
 
546
                return;
 
547
        }
 
548
        if(r == T)
 
549
                return;
 
550
        for(;;) {
 
551
                if(l->etype != TIND || r->etype != TIND)
 
552
                        break;
 
553
                l = l->link;
 
554
                r = r->link;
 
555
                if(l == T || r == T)
 
556
                        break;
 
557
                if(r->garb & GCONSTNT)
 
558
                        if(!(l->garb & GCONSTNT)) {
 
559
                                warn(n, "assignment of a constant pointer type (%T)", ir);
 
560
                                break;
 
561
                        }
 
562
        }
 
563
}
 
564
 
 
565
void
 
566
typeext1(Type *st, Node *l)
 
567
{
 
568
        if(st->etype == TFLOAT && allfloat(l, 0))
 
569
                allfloat(l, 1);
 
570
}
 
571
 
 
572
void
 
573
typeext(Type *st, Node *l)
 
574
{
 
575
        Type *lt;
 
576
        Node *n1, *n2;
 
577
        int32 o;
 
578
 
 
579
        lt = l->type;
 
580
        if(lt == T)
 
581
                return;
 
582
        if(st->etype == TIND && vconst(l) == 0) {
 
583
                l->type = st;
 
584
                l->vconst = 0;
 
585
                return;
 
586
        }
 
587
        typeext1(st, l);
 
588
 
 
589
        /*
 
590
         * extension of C
 
591
         * if assign of struct containing unnamed sub-struct
 
592
         * to type of sub-struct, insert the DOT.
 
593
         * if assign of *struct containing unnamed substruct
 
594
         * to type of *sub-struct, insert the add-offset
 
595
         */
 
596
        if(typesu[st->etype] && typesu[lt->etype]) {
 
597
                o = dotoffset(st, lt, l);
 
598
                if(o >= 0) {
 
599
                        n1 = new1(OXXX, Z, Z);
 
600
                        *n1 = *l;
 
601
                        l->op = ODOT;
 
602
                        l->left = n1;
 
603
                        l->right = Z;
 
604
                        makedot(l, st, o);
 
605
                }
 
606
                return;
 
607
        }
 
608
        if(st->etype == TIND && typesu[st->link->etype])
 
609
        if(lt->etype == TIND && typesu[lt->link->etype]) {
 
610
                o = dotoffset(st->link, lt->link, l);
 
611
                if(o >= 0) {
 
612
                        l->type = st;
 
613
                        if(o == 0)
 
614
                                return;
 
615
                        n1 = new1(OXXX, Z, Z);
 
616
                        *n1 = *l;
 
617
                        n2 = new1(OCONST, Z, Z);
 
618
                        n2->vconst = o;
 
619
                        n2->type = st;
 
620
                        l->op = OADD;
 
621
                        l->left = n1;
 
622
                        l->right = n2;
 
623
                }
 
624
                return;
 
625
        }
 
626
}
 
627
 
 
628
/*
 
629
 * a cast that generates no code
 
630
 * (same size move)
 
631
 */
 
632
int
 
633
nocast(Type *t1, Type *t2)
 
634
{
 
635
        int i, b;
 
636
 
 
637
        if(t1->nbits)
 
638
                return 0;
 
639
        i = 0;
 
640
        if(t2 != T)
 
641
                i = t2->etype;
 
642
        b = 1<<i;
 
643
        i = 0;
 
644
        if(t1 != T)
 
645
                i = t1->etype;
 
646
        if(b & ncast[i])
 
647
                return 1;
 
648
        return 0;
 
649
}
 
650
 
 
651
/*
 
652
 * a cast that has a noop semantic
 
653
 * (small to large, convert)
 
654
 */
 
655
int
 
656
nilcast(Type *t1, Type *t2)
 
657
{
 
658
        int et1, et2;
 
659
 
 
660
        if(t1 == T)
 
661
                return 0;
 
662
        if(t1->nbits)
 
663
                return 0;
 
664
        if(t2 == T)
 
665
                return 0;
 
666
        et1 = t1->etype;
 
667
        et2 = t2->etype;
 
668
        if(et1 == et2)
 
669
                return 1;
 
670
        if(typefd[et1] && typefd[et2]) {
 
671
                if(ewidth[et1] < ewidth[et2])
 
672
                        return 1;
 
673
                return 0;
 
674
        }
 
675
        if(typechlp[et1] && typechlp[et2]) {
 
676
                if(ewidth[et1] < ewidth[et2])
 
677
                        return 1;
 
678
                return 0;
 
679
        }
 
680
        return 0;
 
681
}
 
682
 
 
683
/*
 
684
 * "the usual arithmetic conversions are performed"
 
685
 */
 
686
void
 
687
arith(Node *n, int f)
 
688
{
 
689
        Type *t1, *t2;
 
690
        int i, j, k;
 
691
        Node *n1;
 
692
        int32 w;
 
693
 
 
694
        t1 = n->left->type;
 
695
        if(n->right == Z)
 
696
                t2 = t1;
 
697
        else
 
698
                t2 = n->right->type;
 
699
        i = TXXX;
 
700
        if(t1 != T)
 
701
                i = t1->etype;
 
702
        j = TXXX;
 
703
        if(t2 != T)
 
704
                j = t2->etype;
 
705
        k = tab[i][j];
 
706
        if(k == TIND) {
 
707
                if(i == TIND)
 
708
                        n->type = t1;
 
709
                else
 
710
                if(j == TIND)
 
711
                        n->type = t2;
 
712
        } else {
 
713
                /* convert up to at least int */
 
714
                if(f == 1)
 
715
                while(k < TINT)
 
716
                        k += 2;
 
717
                n->type = types[k];
 
718
        }
 
719
        if(n->op == OSUB)
 
720
        if(i == TIND && j == TIND) {
 
721
                w = n->right->type->link->width;
 
722
                if(w < 1 || n->left->type->link == T || n->left->type->link->width < 1)
 
723
                        goto bad;
 
724
                n->type = types[ewidth[TIND] <= ewidth[TLONG]? TLONG: TVLONG];
 
725
                if(0 && ewidth[TIND] > ewidth[TLONG]){
 
726
                        n1 = new1(OXXX, Z, Z);
 
727
                        *n1 = *n;
 
728
                        n->op = OCAST;
 
729
                        n->left = n1;
 
730
                        n->right = Z;
 
731
                        n->type = types[TLONG];
 
732
                }
 
733
                if(w > 1) {
 
734
                        n1 = new1(OXXX, Z, Z);
 
735
                        *n1 = *n;
 
736
                        n->op = ODIV;
 
737
                        n->left = n1;
 
738
                        n1 = new1(OCONST, Z, Z);
 
739
                        n1->vconst = w;
 
740
                        n1->type = n->type;
 
741
                        n->right = n1;
 
742
                        w = vlog(n1);
 
743
                        if(w >= 0) {
 
744
                                n->op = OASHR;
 
745
                                n1->vconst = w;
 
746
                        }
 
747
                }
 
748
                return;
 
749
        }
 
750
        if(!sametype(n->type, n->left->type)) {
 
751
                n->left = new1(OCAST, n->left, Z);
 
752
                n->left->type = n->type;
 
753
                if(n->type->etype == TIND) {
 
754
                        w = n->type->link->width;
 
755
                        if(w < 1) {
 
756
                                snap(n->type->link);
 
757
                                w = n->type->link->width;
 
758
                                if(w < 1)
 
759
                                        goto bad;
 
760
                        }
 
761
                        if(w > 1) {
 
762
                                n1 = new1(OCONST, Z, Z);
 
763
                                n1->vconst = w;
 
764
                                n1->type = n->type;
 
765
                                n->left = new1(OMUL, n->left, n1);
 
766
                                n->left->type = n->type;
 
767
                        }
 
768
                }
 
769
        }
 
770
        if(n->right != Z)
 
771
        if(!sametype(n->type, n->right->type)) {
 
772
                n->right = new1(OCAST, n->right, Z);
 
773
                n->right->type = n->type;
 
774
                if(n->type->etype == TIND) {
 
775
                        w = n->type->link->width;
 
776
                        if(w < 1) {
 
777
                                snap(n->type->link);
 
778
                                w = n->type->link->width;
 
779
                                if(w < 1)
 
780
                                        goto bad;
 
781
                        }
 
782
                        if(w != 1) {
 
783
                                n1 = new1(OCONST, Z, Z);
 
784
                                n1->vconst = w;
 
785
                                n1->type = n->type;
 
786
                                n->right = new1(OMUL, n->right, n1);
 
787
                                n->right->type = n->type;
 
788
                        }
 
789
                }
 
790
        }
 
791
        return;
 
792
bad:
 
793
        diag(n, "pointer addition not fully declared: %T", n->type->link);
 
794
}
 
795
 
 
796
/*
 
797
 * try to rewrite shift & mask
 
798
 */
 
799
void
 
800
simplifyshift(Node *n)
 
801
{
 
802
        uint32 c3;
 
803
        int o, s1, s2, c1, c2;
 
804
 
 
805
        if(!typechlp[n->type->etype])
 
806
                return;
 
807
        switch(n->op) {
 
808
        default:
 
809
                return;
 
810
        case OASHL:
 
811
                s1 = 0;
 
812
                break;
 
813
        case OLSHR:
 
814
                s1 = 1;
 
815
                break;
 
816
        case OASHR:
 
817
                s1 = 2;
 
818
                break;
 
819
        }
 
820
        if(n->right->op != OCONST)
 
821
                return;
 
822
        if(n->left->op != OAND)
 
823
                return;
 
824
        if(n->left->right->op != OCONST)
 
825
                return;
 
826
        switch(n->left->left->op) {
 
827
        default:
 
828
                return;
 
829
        case OASHL:
 
830
                s2 = 0;
 
831
                break;
 
832
        case OLSHR:
 
833
                s2 = 1;
 
834
                break;
 
835
        case OASHR:
 
836
                s2 = 2;
 
837
                break;
 
838
        }
 
839
        if(n->left->left->right->op != OCONST)
 
840
                return;
 
841
 
 
842
        c1 = n->right->vconst;
 
843
        c2 = n->left->left->right->vconst;
 
844
        c3 = n->left->right->vconst;
 
845
 
 
846
/*
 
847
        if(debug['h'])
 
848
                print("%.3o %d %d %d #%.ux\n",
 
849
                        (s1<<3)|s2, c1, c2, topbit(c3), c3);
 
850
*/
 
851
 
 
852
        o = n->op;
 
853
        switch((s1<<3)|s2) {
 
854
        case 000:       /* (((e <<u c2) & c3) <<u c1) */
 
855
                c3 >>= c2;
 
856
                c1 += c2;
 
857
                if(c1 >= 32)
 
858
                        break;
 
859
                goto rewrite1;
 
860
 
 
861
        case 002:       /* (((e >>s c2) & c3) <<u c1) */
 
862
                if(topbit(c3) >= (32-c2))
 
863
                        break;
 
864
        case 001:       /* (((e >>u c2) & c3) <<u c1) */
 
865
                if(c1 > c2) {
 
866
                        c3 <<= c2;
 
867
                        c1 -= c2;
 
868
                        o = OASHL;
 
869
                        goto rewrite1;
 
870
                }
 
871
                c3 <<= c1;
 
872
                if(c1 == c2)
 
873
                        goto rewrite0;
 
874
                c1 = c2-c1;
 
875
                o = OLSHR;
 
876
                goto rewrite2;
 
877
 
 
878
        case 022:       /* (((e >>s c2) & c3) >>s c1) */
 
879
                if(c2 <= 0)
 
880
                        break;
 
881
        case 012:       /* (((e >>s c2) & c3) >>u c1) */
 
882
                if(topbit(c3) >= (32-c2))
 
883
                        break;
 
884
                goto s11;
 
885
        case 021:       /* (((e >>u c2) & c3) >>s c1) */
 
886
                if(topbit(c3) >= 31 && c2 <= 0)
 
887
                        break;
 
888
                goto s11;
 
889
        case 011:       /* (((e >>u c2) & c3) >>u c1) */
 
890
        s11:
 
891
                c3 <<= c2;
 
892
                c1 += c2;
 
893
                if(c1 >= 32)
 
894
                        break;
 
895
                o = OLSHR;
 
896
                goto rewrite1;
 
897
 
 
898
        case 020:       /* (((e <<u c2) & c3) >>s c1) */
 
899
                if(topbit(c3) >= 31)
 
900
                        break;
 
901
        case 010:       /* (((e <<u c2) & c3) >>u c1) */
 
902
                c3 >>= c1;
 
903
                if(c1 == c2)
 
904
                        goto rewrite0;
 
905
                if(c1 > c2) {
 
906
                        c1 -= c2;
 
907
                        goto rewrite2;
 
908
                }
 
909
                c1 = c2 - c1;
 
910
                o = OASHL;
 
911
                goto rewrite2;
 
912
        }
 
913
        return;
 
914
 
 
915
rewrite0:       /* get rid of both shifts */
 
916
if(debug['<'])prtree(n, "rewrite0");
 
917
        *n = *n->left;
 
918
        n->left = n->left->left;
 
919
        n->right->vconst = c3;
 
920
        return;
 
921
rewrite1:       /* get rid of lower shift */
 
922
if(debug['<'])prtree(n, "rewrite1");
 
923
        n->left->left = n->left->left->left;
 
924
        n->left->right->vconst = c3;
 
925
        n->right->vconst = c1;
 
926
        n->op = o;
 
927
        return;
 
928
rewrite2:       /* get rid of upper shift */
 
929
if(debug['<'])prtree(n, "rewrite2");
 
930
        *n = *n->left;
 
931
        n->right->vconst = c3;
 
932
        n->left->right->vconst = c1;
 
933
        n->left->op = o;
 
934
}
 
935
 
 
936
int
 
937
side(Node *n)
 
938
{
 
939
 
 
940
loop:
 
941
        if(n != Z)
 
942
        switch(n->op) {
 
943
        case OCAST:
 
944
        case ONOT:
 
945
        case OADDR:
 
946
        case OIND:
 
947
                n = n->left;
 
948
                goto loop;
 
949
 
 
950
        case OCOND:
 
951
                if(side(n->left))
 
952
                        break;
 
953
                n = n->right;
 
954
 
 
955
        case OEQ:
 
956
        case ONE:
 
957
        case OLT:
 
958
        case OGE:
 
959
        case OGT:
 
960
        case OLE:
 
961
        case OADD:
 
962
        case OSUB:
 
963
        case OMUL:
 
964
        case OLMUL:
 
965
        case ODIV:
 
966
        case OLDIV:
 
967
        case OLSHR:
 
968
        case OASHL:
 
969
        case OASHR:
 
970
        case OAND:
 
971
        case OOR:
 
972
        case OXOR:
 
973
        case OMOD:
 
974
        case OLMOD:
 
975
        case OANDAND:
 
976
        case OOROR:
 
977
        case OCOMMA:
 
978
        case ODOT:
 
979
                if(side(n->left))
 
980
                        break;
 
981
                n = n->right;
 
982
                goto loop;
 
983
 
 
984
        case OSIGN:
 
985
        case OSIZE:
 
986
        case OCONST:
 
987
        case OSTRING:
 
988
        case OLSTRING:
 
989
        case ONAME:
 
990
                return 0;
 
991
        }
 
992
        return 1;
 
993
}
 
994
 
 
995
int
 
996
vconst(Node *n)
 
997
{
 
998
        int i;
 
999
 
 
1000
        if(n == Z)
 
1001
                goto no;
 
1002
        if(n->op != OCONST)
 
1003
                goto no;
 
1004
        if(n->type == T)
 
1005
                goto no;
 
1006
        switch(n->type->etype)
 
1007
        {
 
1008
        case TFLOAT:
 
1009
        case TDOUBLE:
 
1010
                i = 100;
 
1011
                if(n->fconst > i || n->fconst < -i)
 
1012
                        goto no;
 
1013
                i = n->fconst;
 
1014
                if(i != n->fconst)
 
1015
                        goto no;
 
1016
                return i;
 
1017
 
 
1018
        case TVLONG:
 
1019
        case TUVLONG:
 
1020
                i = n->vconst;
 
1021
                if(i != n->vconst)
 
1022
                        goto no;
 
1023
                return i;
 
1024
 
 
1025
        case TCHAR:
 
1026
        case TUCHAR:
 
1027
        case TSHORT:
 
1028
        case TUSHORT:
 
1029
        case TINT:
 
1030
        case TUINT:
 
1031
        case TLONG:
 
1032
        case TULONG:
 
1033
        case TIND:
 
1034
                i = n->vconst;
 
1035
                if(i != n->vconst)
 
1036
                        goto no;
 
1037
                return i;
 
1038
        }
 
1039
no:
 
1040
        return -159;    /* first uninteresting constant */
 
1041
}
 
1042
 
 
1043
/*
 
1044
 * return log(n) if n is a power of 2 constant
 
1045
 */
 
1046
int
 
1047
xlog2(uvlong v)
 
1048
{
 
1049
        int s, i;
 
1050
        uvlong m;
 
1051
 
 
1052
        s = 0;
 
1053
        m = MASK(8*sizeof(uvlong));
 
1054
        for(i=32; i; i>>=1) {
 
1055
                m >>= i;
 
1056
                if(!(v & m)) {
 
1057
                        v >>= i;
 
1058
                        s += i;
 
1059
                }
 
1060
        }
 
1061
        if(v == 1)
 
1062
                return s;
 
1063
        return -1;
 
1064
}
 
1065
 
 
1066
int
 
1067
vlog(Node *n)
 
1068
{
 
1069
        if(n->op != OCONST)
 
1070
                goto bad;
 
1071
        if(typefd[n->type->etype])
 
1072
                goto bad;
 
1073
 
 
1074
        return xlog2(n->vconst);
 
1075
 
 
1076
bad:
 
1077
        return -1;
 
1078
}
 
1079
 
 
1080
int
 
1081
topbit(uint32 v)
 
1082
{
 
1083
        int i;
 
1084
 
 
1085
        for(i = -1; v; i++)
 
1086
                v >>= 1;
 
1087
        return i;
 
1088
}
 
1089
 
 
1090
/*
 
1091
 * try to cast a constant down
 
1092
 * rather than cast a variable up
 
1093
 * example:
 
1094
 *      if(c == 'a')
 
1095
 */
 
1096
void
 
1097
relcon(Node *l, Node *r)
 
1098
{
 
1099
        vlong v;
 
1100
 
 
1101
        if(l->op != OCONST)
 
1102
                return;
 
1103
        if(r->op != OCAST)
 
1104
                return;
 
1105
        if(!nilcast(r->left->type, r->type))
 
1106
                return;
 
1107
        switch(r->type->etype) {
 
1108
        default:
 
1109
                return;
 
1110
        case TCHAR:
 
1111
        case TUCHAR:
 
1112
        case TSHORT:
 
1113
        case TUSHORT:
 
1114
                v = convvtox(l->vconst, r->type->etype);
 
1115
                if(v != l->vconst)
 
1116
                        return;
 
1117
                break;
 
1118
        }
 
1119
        l->type = r->left->type;
 
1120
        *r = *r->left;
 
1121
}
 
1122
 
 
1123
int
 
1124
relindex(int o)
 
1125
{
 
1126
 
 
1127
        switch(o) {
 
1128
        default:
 
1129
                diag(Z, "bad in relindex: %O", o);
 
1130
        case OEQ: return 0;
 
1131
        case ONE: return 1;
 
1132
        case OLE: return 2;
 
1133
        case OLS: return 3;
 
1134
        case OLT: return 4;
 
1135
        case OLO: return 5;
 
1136
        case OGE: return 6;
 
1137
        case OHS: return 7;
 
1138
        case OGT: return 8;
 
1139
        case OHI: return 9;
 
1140
        }
 
1141
}
 
1142
 
 
1143
Node*
 
1144
invert(Node *n)
 
1145
{
 
1146
        Node *i;
 
1147
 
 
1148
        if(n == Z || n->op != OLIST)
 
1149
                return n;
 
1150
        i = n;
 
1151
        for(n = n->left; n != Z; n = n->left) {
 
1152
                if(n->op != OLIST)
 
1153
                        break;
 
1154
                i->left = n->right;
 
1155
                n->right = i;
 
1156
                i = n;
 
1157
        }
 
1158
        i->left = n;
 
1159
        return i;
 
1160
}
 
1161
 
 
1162
int
 
1163
bitno(int32 b)
 
1164
{
 
1165
        int i;
 
1166
 
 
1167
        for(i=0; i<32; i++)
 
1168
                if(b & (1L<<i))
 
1169
                        return i;
 
1170
        diag(Z, "bad in bitno");
 
1171
        return 0;
 
1172
}
 
1173
 
 
1174
int32
 
1175
typebitor(int32 a, int32 b)
 
1176
{
 
1177
        int32 c;
 
1178
 
 
1179
        c = a | b;
 
1180
        if(a & b)
 
1181
                if((a & b) == BLONG)
 
1182
                        c |= BVLONG;            /* long long => vlong */
 
1183
                else
 
1184
                        warn(Z, "once is enough: %Q", a & b);
 
1185
        return c;
 
1186
}
 
1187
 
 
1188
void
 
1189
diag(Node *n, char *fmt, ...)
 
1190
{
 
1191
        char buf[STRINGSZ];
 
1192
        va_list arg;
 
1193
 
 
1194
        va_start(arg, fmt);
 
1195
        vseprint(buf, buf+sizeof(buf), fmt, arg);
 
1196
        va_end(arg);
 
1197
        Bprint(&diagbuf, "%L %s\n", (n==Z)? nearln: n->lineno, buf);
 
1198
 
 
1199
        if(debug['X']){
 
1200
                Bflush(&diagbuf);
 
1201
                abort();
 
1202
        }
 
1203
        if(n != Z)
 
1204
        if(debug['v'])
 
1205
                prtree(n, "diagnostic");
 
1206
 
 
1207
        nerrors++;
 
1208
        if(nerrors > 10) {
 
1209
                Bprint(&diagbuf, "too many errors\n");
 
1210
                errorexit();
 
1211
        }
 
1212
}
 
1213
 
 
1214
void
 
1215
warn(Node *n, char *fmt, ...)
 
1216
{
 
1217
        char buf[STRINGSZ];
 
1218
        va_list arg;
 
1219
 
 
1220
        if(debug['w']) {
 
1221
                Bprint(&diagbuf, "warning: ");
 
1222
                va_start(arg, fmt);
 
1223
                vseprint(buf, buf+sizeof(buf), fmt, arg);
 
1224
                va_end(arg);
 
1225
                Bprint(&diagbuf, "%L %s\n", (n==Z)? nearln: n->lineno, buf);
 
1226
 
 
1227
                if(n != Z)
 
1228
                if(debug['v'])
 
1229
                        prtree(n, "warning");
 
1230
        }
 
1231
}
 
1232
 
 
1233
void
 
1234
yyerror(char *fmt, ...)
 
1235
{
 
1236
        char buf[STRINGSZ];
 
1237
        va_list arg;
 
1238
 
 
1239
        /*
 
1240
         * hack to intercept message from yaccpar
 
1241
         */
 
1242
        if(strcmp(fmt, "syntax error") == 0) {
 
1243
                yyerror("syntax error, last name: %s", symb);
 
1244
                return;
 
1245
        }
 
1246
        va_start(arg, fmt);
 
1247
        vseprint(buf, buf+sizeof(buf), fmt, arg);
 
1248
        va_end(arg);
 
1249
        Bprint(&diagbuf, "%L %s\n", lineno, buf);
 
1250
        nerrors++;
 
1251
        if(nerrors > 10) {
 
1252
                Bprint(&diagbuf, "too many errors\n");
 
1253
                errorexit();
 
1254
        }
 
1255
}
 
1256
 
 
1257
void
 
1258
fatal(Node *n, char *fmt, ...)
 
1259
{
 
1260
        char buf[STRINGSZ];
 
1261
        va_list arg;
 
1262
 
 
1263
        va_start(arg, fmt);
 
1264
        vseprint(buf, buf+sizeof(buf), fmt, arg);
 
1265
        va_end(arg);
 
1266
        Bprint(&diagbuf, "%L %s\n", (n==Z)? nearln: n->lineno, buf);
 
1267
 
 
1268
        if(debug['X']){
 
1269
                Bflush(&diagbuf);
 
1270
                abort();
 
1271
        }
 
1272
        if(n != Z)
 
1273
        if(debug['v'])
 
1274
                prtree(n, "diagnostic");
 
1275
 
 
1276
        nerrors++;
 
1277
        errorexit();
 
1278
}
 
1279
 
 
1280
uint32  thash1  = 0x2edab8c9;
 
1281
uint32  thash2  = 0x1dc74fb8;
 
1282
uint32  thash3  = 0x1f241331;
 
1283
uint32  thash[NALLTYPES];
 
1284
Init    thashinit[] =
 
1285
{
 
1286
        TXXX,           0x17527bbd,     0,
 
1287
        TCHAR,          0x5cedd32b,     0,
 
1288
        TUCHAR,         0x552c4454,     0,
 
1289
        TSHORT,         0x63040b4b,     0,
 
1290
        TUSHORT,        0x32a45878,     0,
 
1291
        TINT,           0x4151d5bd,     0,
 
1292
        TUINT,          0x5ae707d6,     0,
 
1293
        TLONG,          0x5ef20f47,     0,
 
1294
        TULONG,         0x36d8eb8f,     0,
 
1295
        TVLONG,         0x6e5e9590,     0,
 
1296
        TUVLONG,        0x75910105,     0,
 
1297
        TFLOAT,         0x25fd7af1,     0,
 
1298
        TDOUBLE,        0x7c40a1b2,     0,
 
1299
        TIND,           0x1b832357,     0,
 
1300
        TFUNC,          0x6babc9cb,     0,
 
1301
        TARRAY,         0x7c50986d,     0,
 
1302
        TVOID,          0x44112eff,     0,
 
1303
        TSTRUCT,        0x7c2da3bf,     0,
 
1304
        TUNION,         0x3eb25e98,     0,
 
1305
        TENUM,          0x44b54f61,     0,
 
1306
        TFILE,          0x19242ac3,     0,
 
1307
        TOLD,           0x22b15988,     0,
 
1308
        TDOT,           0x0204f6b3,     0,
 
1309
        -1,             0,              0,
 
1310
};
 
1311
 
 
1312
char*   bnames[NALIGN];
 
1313
Init    bnamesinit[] =
 
1314
{
 
1315
        Axxx,   0,      "Axxx",
 
1316
        Ael1,   0,      "el1",
 
1317
        Ael2,   0,      "el2",
 
1318
        Asu2,   0,      "su2",
 
1319
        Aarg0,  0,      "arg0",
 
1320
        Aarg1,  0,      "arg1",
 
1321
        Aarg2,  0,      "arg2",
 
1322
        Aaut3,  0,      "aut3",
 
1323
        -1,     0,      0,
 
1324
};
 
1325
 
 
1326
char*   tnames[NALLTYPES];
 
1327
Init    tnamesinit[] =
 
1328
{
 
1329
        TXXX,           0,      "TXXX",
 
1330
        TCHAR,          0,      "CHAR",
 
1331
        TUCHAR,         0,      "UCHAR",
 
1332
        TSHORT,         0,      "SHORT",
 
1333
        TUSHORT,        0,      "USHORT",
 
1334
        TINT,           0,      "INT",
 
1335
        TUINT,          0,      "UINT",
 
1336
        TLONG,          0,      "LONG",
 
1337
        TULONG,         0,      "ULONG",
 
1338
        TVLONG,         0,      "VLONG",
 
1339
        TUVLONG,        0,      "UVLONG",
 
1340
        TFLOAT,         0,      "FLOAT",
 
1341
        TDOUBLE,        0,      "DOUBLE",
 
1342
        TIND,           0,      "IND",
 
1343
        TFUNC,          0,      "FUNC",
 
1344
        TARRAY,         0,      "ARRAY",
 
1345
        TVOID,          0,      "VOID",
 
1346
        TSTRUCT,        0,      "STRUCT",
 
1347
        TUNION,         0,      "UNION",
 
1348
        TENUM,          0,      "ENUM",
 
1349
        TFILE,          0,      "FILE",
 
1350
        TOLD,           0,      "OLD",
 
1351
        TDOT,           0,      "DOT",
 
1352
        -1,             0,      0,
 
1353
};
 
1354
 
 
1355
char*   gnames[NGTYPES];
 
1356
Init    gnamesinit[] =
 
1357
{
 
1358
        GXXX,                   0,      "GXXX",
 
1359
        GCONSTNT,               0,      "CONST",
 
1360
        GVOLATILE,              0,      "VOLATILE",
 
1361
        GVOLATILE|GCONSTNT,     0,      "CONST-VOLATILE",
 
1362
        -1,                     0,      0,
 
1363
};
 
1364
 
 
1365
char*   qnames[NALLTYPES];
 
1366
Init    qnamesinit[] =
 
1367
{
 
1368
        TXXX,           0,      "TXXX",
 
1369
        TCHAR,          0,      "CHAR",
 
1370
        TUCHAR,         0,      "UCHAR",
 
1371
        TSHORT,         0,      "SHORT",
 
1372
        TUSHORT,        0,      "USHORT",
 
1373
        TINT,           0,      "INT",
 
1374
        TUINT,          0,      "UINT",
 
1375
        TLONG,          0,      "LONG",
 
1376
        TULONG,         0,      "ULONG",
 
1377
        TVLONG,         0,      "VLONG",
 
1378
        TUVLONG,        0,      "UVLONG",
 
1379
        TFLOAT,         0,      "FLOAT",
 
1380
        TDOUBLE,        0,      "DOUBLE",
 
1381
        TIND,           0,      "IND",
 
1382
        TFUNC,          0,      "FUNC",
 
1383
        TARRAY,         0,      "ARRAY",
 
1384
        TVOID,          0,      "VOID",
 
1385
        TSTRUCT,        0,      "STRUCT",
 
1386
        TUNION,         0,      "UNION",
 
1387
        TENUM,          0,      "ENUM",
 
1388
 
 
1389
        TAUTO,          0,      "AUTO",
 
1390
        TEXTERN,        0,      "EXTERN",
 
1391
        TSTATIC,        0,      "STATIC",
 
1392
        TTYPEDEF,       0,      "TYPEDEF",
 
1393
        TTYPESTR,       0,      "TYPESTR",
 
1394
        TREGISTER,      0,      "REGISTER",
 
1395
        TCONSTNT,       0,      "CONSTNT",
 
1396
        TVOLATILE,      0,      "VOLATILE",
 
1397
        TUNSIGNED,      0,      "UNSIGNED",
 
1398
        TSIGNED,        0,      "SIGNED",
 
1399
        TDOT,           0,      "DOT",
 
1400
        TFILE,          0,      "FILE",
 
1401
        TOLD,           0,      "OLD",
 
1402
        -1,             0,      0,
 
1403
};
 
1404
char*   cnames[NCTYPES];
 
1405
Init    cnamesinit[] =
 
1406
{
 
1407
        CXXX,           0,      "CXXX",
 
1408
        CAUTO,          0,      "AUTO",
 
1409
        CEXTERN,        0,      "EXTERN",
 
1410
        CGLOBL,         0,      "GLOBL",
 
1411
        CSTATIC,        0,      "STATIC",
 
1412
        CLOCAL,         0,      "LOCAL",
 
1413
        CTYPEDEF,       0,      "TYPEDEF",
 
1414
        CTYPESTR,       0,      "TYPESTR",
 
1415
        CPARAM,         0,      "PARAM",
 
1416
        CSELEM,         0,      "SELEM",
 
1417
        CLABEL,         0,      "LABEL",
 
1418
        CEXREG,         0,      "EXREG",
 
1419
        -1,             0,      0,
 
1420
};
 
1421
 
 
1422
char*   onames[OEND+1];
 
1423
Init    onamesinit[] =
 
1424
{
 
1425
        OXXX,           0,      "OXXX",
 
1426
        OADD,           0,      "ADD",
 
1427
        OADDR,          0,      "ADDR",
 
1428
        OAND,           0,      "AND",
 
1429
        OANDAND,        0,      "ANDAND",
 
1430
        OARRAY,         0,      "ARRAY",
 
1431
        OAS,            0,      "AS",
 
1432
        OASI,           0,      "ASI",
 
1433
        OASADD,         0,      "ASADD",
 
1434
        OASAND,         0,      "ASAND",
 
1435
        OASASHL,        0,      "ASASHL",
 
1436
        OASASHR,        0,      "ASASHR",
 
1437
        OASDIV,         0,      "ASDIV",
 
1438
        OASHL,          0,      "ASHL",
 
1439
        OASHR,          0,      "ASHR",
 
1440
        OASLDIV,        0,      "ASLDIV",
 
1441
        OASLMOD,        0,      "ASLMOD",
 
1442
        OASLMUL,        0,      "ASLMUL",
 
1443
        OASLSHR,        0,      "ASLSHR",
 
1444
        OASMOD,         0,      "ASMOD",
 
1445
        OASMUL,         0,      "ASMUL",
 
1446
        OASOR,          0,      "ASOR",
 
1447
        OASSUB,         0,      "ASSUB",
 
1448
        OASXOR,         0,      "ASXOR",
 
1449
        OBIT,           0,      "BIT",
 
1450
        OBREAK,         0,      "BREAK",
 
1451
        OCASE,          0,      "CASE",
 
1452
        OCAST,          0,      "CAST",
 
1453
        OCOMMA,         0,      "COMMA",
 
1454
        OCOND,          0,      "COND",
 
1455
        OCONST,         0,      "CONST",
 
1456
        OCONTINUE,      0,      "CONTINUE",
 
1457
        ODIV,           0,      "DIV",
 
1458
        ODOT,           0,      "DOT",
 
1459
        ODOTDOT,        0,      "DOTDOT",
 
1460
        ODWHILE,        0,      "DWHILE",
 
1461
        OENUM,          0,      "ENUM",
 
1462
        OEQ,            0,      "EQ",
 
1463
        OEXREG, 0,      "EXREG",
 
1464
        OFOR,           0,      "FOR",
 
1465
        OFUNC,          0,      "FUNC",
 
1466
        OGE,            0,      "GE",
 
1467
        OGOTO,          0,      "GOTO",
 
1468
        OGT,            0,      "GT",
 
1469
        OHI,            0,      "HI",
 
1470
        OHS,            0,      "HS",
 
1471
        OIF,            0,      "IF",
 
1472
        OIND,           0,      "IND",
 
1473
        OINDREG,        0,      "INDREG",
 
1474
        OINIT,          0,      "INIT",
 
1475
        OLABEL,         0,      "LABEL",
 
1476
        OLDIV,          0,      "LDIV",
 
1477
        OLE,            0,      "LE",
 
1478
        OLIST,          0,      "LIST",
 
1479
        OLMOD,          0,      "LMOD",
 
1480
        OLMUL,          0,      "LMUL",
 
1481
        OLO,            0,      "LO",
 
1482
        OLS,            0,      "LS",
 
1483
        OLSHR,          0,      "LSHR",
 
1484
        OLT,            0,      "LT",
 
1485
        OMOD,           0,      "MOD",
 
1486
        OMUL,           0,      "MUL",
 
1487
        ONAME,          0,      "NAME",
 
1488
        ONE,            0,      "NE",
 
1489
        ONOT,           0,      "NOT",
 
1490
        OOR,            0,      "OR",
 
1491
        OOROR,          0,      "OROR",
 
1492
        OPOSTDEC,       0,      "POSTDEC",
 
1493
        OPOSTINC,       0,      "POSTINC",
 
1494
        OPREDEC,        0,      "PREDEC",
 
1495
        OPREINC,        0,      "PREINC",
 
1496
        OPROTO,         0,      "PROTO",
 
1497
        OREGISTER,      0,      "REGISTER",
 
1498
        ORETURN,        0,      "RETURN",
 
1499
        OSET,           0,      "SET",
 
1500
        OSIGN,          0,      "SIGN",
 
1501
        OSIZE,          0,      "SIZE",
 
1502
        OSTRING,        0,      "STRING",
 
1503
        OLSTRING,       0,      "LSTRING",
 
1504
        OSTRUCT,        0,      "STRUCT",
 
1505
        OSUB,           0,      "SUB",
 
1506
        OSWITCH,        0,      "SWITCH",
 
1507
        OUNION,         0,      "UNION",
 
1508
        OUSED,          0,      "USED",
 
1509
        OWHILE,         0,      "WHILE",
 
1510
        OXOR,           0,      "XOR",
 
1511
        OPOS,           0,      "POS",
 
1512
        ONEG,           0,      "NEG",
 
1513
        OCOM,           0,      "COM",
 
1514
        OELEM,          0,      "ELEM",
 
1515
        OTST,           0,      "TST",
 
1516
        OINDEX,         0,      "INDEX",
 
1517
        OFAS,           0,      "FAS",
 
1518
        OREGPAIR,       0,      "REGPAIR",
 
1519
        OEND,           0,      "END",
 
1520
        -1,             0,      0,
 
1521
};
 
1522
 
 
1523
/*      OEQ, ONE, OLE, OLS, OLT, OLO, OGE, OHS, OGT, OHI */
 
1524
uchar   comrel[12] =
 
1525
{
 
1526
        ONE, OEQ, OGT, OHI, OGE, OHS, OLT, OLO, OLE, OLS,
 
1527
};
 
1528
uchar   invrel[12] =
 
1529
{
 
1530
        OEQ, ONE, OGE, OHS, OGT, OHI, OLE, OLS, OLT, OLO,
 
1531
};
 
1532
uchar   logrel[12] =
 
1533
{
 
1534
        OEQ, ONE, OLS, OLS, OLO, OLO, OHS, OHS, OHI, OHI,
 
1535
};
 
1536
 
 
1537
uchar   typei[NTYPE];
 
1538
int     typeiinit[] =
 
1539
{
 
1540
        TCHAR, TUCHAR, TSHORT, TUSHORT, TINT, TUINT, TLONG, TULONG, TVLONG, TUVLONG, -1,
 
1541
};
 
1542
uchar   typeu[NTYPE];
 
1543
int     typeuinit[] =
 
1544
{
 
1545
        TUCHAR, TUSHORT, TUINT, TULONG, TUVLONG, TIND, -1,
 
1546
};
 
1547
 
 
1548
uchar   typesuv[NTYPE];
 
1549
int     typesuvinit[] =
 
1550
{
 
1551
        TVLONG, TUVLONG, TSTRUCT, TUNION, -1,
 
1552
};
 
1553
 
 
1554
uchar   typeilp[NTYPE];
 
1555
int     typeilpinit[] =
 
1556
{
 
1557
        TINT, TUINT, TLONG, TULONG, TIND, -1
 
1558
};
 
1559
 
 
1560
uchar   typechl[NTYPE];
 
1561
uchar   typechlv[NTYPE];
 
1562
uchar   typechlvp[NTYPE];
 
1563
int     typechlinit[] =
 
1564
{
 
1565
        TCHAR, TUCHAR, TSHORT, TUSHORT, TINT, TUINT, TLONG, TULONG, -1,
 
1566
};
 
1567
 
 
1568
uchar   typechlp[NTYPE];
 
1569
int     typechlpinit[] =
 
1570
{
 
1571
        TCHAR, TUCHAR, TSHORT, TUSHORT, TINT, TUINT, TLONG, TULONG, TIND, -1,
 
1572
};
 
1573
 
 
1574
uchar   typechlpfd[NTYPE];
 
1575
int     typechlpfdinit[] =
 
1576
{
 
1577
        TCHAR, TUCHAR, TSHORT, TUSHORT, TINT, TUINT, TLONG, TULONG, TFLOAT, TDOUBLE, TIND, -1,
 
1578
};
 
1579
 
 
1580
uchar   typec[NTYPE];
 
1581
int     typecinit[] =
 
1582
{
 
1583
        TCHAR, TUCHAR, -1
 
1584
};
 
1585
 
 
1586
uchar   typeh[NTYPE];
 
1587
int     typehinit[] =
 
1588
{
 
1589
        TSHORT, TUSHORT, -1,
 
1590
};
 
1591
 
 
1592
uchar   typeil[NTYPE];
 
1593
int     typeilinit[] =
 
1594
{
 
1595
        TINT, TUINT, TLONG, TULONG, -1,
 
1596
};
 
1597
 
 
1598
uchar   typev[NTYPE];
 
1599
int     typevinit[] =
 
1600
{
 
1601
        TVLONG, TUVLONG, -1,
 
1602
};
 
1603
 
 
1604
uchar   typefd[NTYPE];
 
1605
int     typefdinit[] =
 
1606
{
 
1607
        TFLOAT, TDOUBLE, -1,
 
1608
};
 
1609
 
 
1610
uchar   typeaf[NTYPE];
 
1611
int     typeafinit[] =
 
1612
{
 
1613
        TFUNC, TARRAY, -1,
 
1614
};
 
1615
 
 
1616
uchar   typesu[NTYPE];
 
1617
int     typesuinit[] =
 
1618
{
 
1619
        TSTRUCT, TUNION, -1,
 
1620
};
 
1621
 
 
1622
int32   tasign[NTYPE];
 
1623
Init    tasigninit[] =
 
1624
{
 
1625
        TCHAR,          BNUMBER,        0,
 
1626
        TUCHAR,         BNUMBER,        0,
 
1627
        TSHORT,         BNUMBER,        0,
 
1628
        TUSHORT,        BNUMBER,        0,
 
1629
        TINT,           BNUMBER,        0,
 
1630
        TUINT,          BNUMBER,        0,
 
1631
        TLONG,          BNUMBER,        0,
 
1632
        TULONG,         BNUMBER,        0,
 
1633
        TVLONG,         BNUMBER,        0,
 
1634
        TUVLONG,        BNUMBER,        0,
 
1635
        TFLOAT,         BNUMBER,        0,
 
1636
        TDOUBLE,        BNUMBER,        0,
 
1637
        TIND,           BIND,           0,
 
1638
        TSTRUCT,        BSTRUCT,        0,
 
1639
        TUNION,         BUNION,         0,
 
1640
        -1,             0,              0,
 
1641
};
 
1642
 
 
1643
int32   tasadd[NTYPE];
 
1644
Init    tasaddinit[] =
 
1645
{
 
1646
        TCHAR,          BNUMBER,        0,
 
1647
        TUCHAR,         BNUMBER,        0,
 
1648
        TSHORT,         BNUMBER,        0,
 
1649
        TUSHORT,        BNUMBER,        0,
 
1650
        TINT,           BNUMBER,        0,
 
1651
        TUINT,          BNUMBER,        0,
 
1652
        TLONG,          BNUMBER,        0,
 
1653
        TULONG,         BNUMBER,        0,
 
1654
        TVLONG,         BNUMBER,        0,
 
1655
        TUVLONG,        BNUMBER,        0,
 
1656
        TFLOAT,         BNUMBER,        0,
 
1657
        TDOUBLE,        BNUMBER,        0,
 
1658
        TIND,           BINTEGER,       0,
 
1659
        -1,             0,              0,
 
1660
};
 
1661
 
 
1662
int32   tcast[NTYPE];
 
1663
Init    tcastinit[] =
 
1664
{
 
1665
        TCHAR,          BNUMBER|BIND|BVOID,     0,
 
1666
        TUCHAR,         BNUMBER|BIND|BVOID,     0,
 
1667
        TSHORT,         BNUMBER|BIND|BVOID,     0,
 
1668
        TUSHORT,        BNUMBER|BIND|BVOID,     0,
 
1669
        TINT,           BNUMBER|BIND|BVOID,     0,
 
1670
        TUINT,          BNUMBER|BIND|BVOID,     0,
 
1671
        TLONG,          BNUMBER|BIND|BVOID,     0,
 
1672
        TULONG,         BNUMBER|BIND|BVOID,     0,
 
1673
        TVLONG,         BNUMBER|BIND|BVOID,     0,
 
1674
        TUVLONG,        BNUMBER|BIND|BVOID,     0,
 
1675
        TFLOAT,         BNUMBER|BVOID,          0,
 
1676
        TDOUBLE,        BNUMBER|BVOID,          0,
 
1677
        TIND,           BINTEGER|BIND|BVOID,    0,
 
1678
        TVOID,          BVOID,                  0,
 
1679
        TSTRUCT,        BSTRUCT|BVOID,          0,
 
1680
        TUNION,         BUNION|BVOID,           0,
 
1681
        -1,             0,                      0,
 
1682
};
 
1683
 
 
1684
int32   tadd[NTYPE];
 
1685
Init    taddinit[] =
 
1686
{
 
1687
        TCHAR,          BNUMBER|BIND,   0,
 
1688
        TUCHAR,         BNUMBER|BIND,   0,
 
1689
        TSHORT,         BNUMBER|BIND,   0,
 
1690
        TUSHORT,        BNUMBER|BIND,   0,
 
1691
        TINT,           BNUMBER|BIND,   0,
 
1692
        TUINT,          BNUMBER|BIND,   0,
 
1693
        TLONG,          BNUMBER|BIND,   0,
 
1694
        TULONG,         BNUMBER|BIND,   0,
 
1695
        TVLONG,         BNUMBER|BIND,   0,
 
1696
        TUVLONG,        BNUMBER|BIND,   0,
 
1697
        TFLOAT,         BNUMBER,        0,
 
1698
        TDOUBLE,        BNUMBER,        0,
 
1699
        TIND,           BINTEGER,       0,
 
1700
        -1,             0,              0,
 
1701
};
 
1702
 
 
1703
int32   tsub[NTYPE];
 
1704
Init    tsubinit[] =
 
1705
{
 
1706
        TCHAR,          BNUMBER,        0,
 
1707
        TUCHAR,         BNUMBER,        0,
 
1708
        TSHORT,         BNUMBER,        0,
 
1709
        TUSHORT,        BNUMBER,        0,
 
1710
        TINT,           BNUMBER,        0,
 
1711
        TUINT,          BNUMBER,        0,
 
1712
        TLONG,          BNUMBER,        0,
 
1713
        TULONG,         BNUMBER,        0,
 
1714
        TVLONG,         BNUMBER,        0,
 
1715
        TUVLONG,        BNUMBER,        0,
 
1716
        TFLOAT,         BNUMBER,        0,
 
1717
        TDOUBLE,        BNUMBER,        0,
 
1718
        TIND,           BINTEGER|BIND,  0,
 
1719
        -1,             0,              0,
 
1720
};
 
1721
 
 
1722
int32   tmul[NTYPE];
 
1723
Init    tmulinit[] =
 
1724
{
 
1725
        TCHAR,          BNUMBER,        0,
 
1726
        TUCHAR,         BNUMBER,        0,
 
1727
        TSHORT,         BNUMBER,        0,
 
1728
        TUSHORT,        BNUMBER,        0,
 
1729
        TINT,           BNUMBER,        0,
 
1730
        TUINT,          BNUMBER,        0,
 
1731
        TLONG,          BNUMBER,        0,
 
1732
        TULONG,         BNUMBER,        0,
 
1733
        TVLONG,         BNUMBER,        0,
 
1734
        TUVLONG,        BNUMBER,        0,
 
1735
        TFLOAT,         BNUMBER,        0,
 
1736
        TDOUBLE,        BNUMBER,        0,
 
1737
        -1,             0,              0,
 
1738
};
 
1739
 
 
1740
int32   tand[NTYPE];
 
1741
Init    tandinit[] =
 
1742
{
 
1743
        TCHAR,          BINTEGER,       0,
 
1744
        TUCHAR,         BINTEGER,       0,
 
1745
        TSHORT,         BINTEGER,       0,
 
1746
        TUSHORT,        BINTEGER,       0,
 
1747
        TINT,           BNUMBER,        0,
 
1748
        TUINT,          BNUMBER,        0,
 
1749
        TLONG,          BINTEGER,       0,
 
1750
        TULONG,         BINTEGER,       0,
 
1751
        TVLONG,         BINTEGER,       0,
 
1752
        TUVLONG,        BINTEGER,       0,
 
1753
        -1,             0,              0,
 
1754
};
 
1755
 
 
1756
int32   trel[NTYPE];
 
1757
Init    trelinit[] =
 
1758
{
 
1759
        TCHAR,          BNUMBER,        0,
 
1760
        TUCHAR,         BNUMBER,        0,
 
1761
        TSHORT,         BNUMBER,        0,
 
1762
        TUSHORT,        BNUMBER,        0,
 
1763
        TINT,           BNUMBER,        0,
 
1764
        TUINT,          BNUMBER,        0,
 
1765
        TLONG,          BNUMBER,        0,
 
1766
        TULONG,         BNUMBER,        0,
 
1767
        TVLONG,         BNUMBER,        0,
 
1768
        TUVLONG,        BNUMBER,        0,
 
1769
        TFLOAT,         BNUMBER,        0,
 
1770
        TDOUBLE,        BNUMBER,        0,
 
1771
        TIND,           BIND,           0,
 
1772
        -1,             0,              0,
 
1773
};
 
1774
 
 
1775
int32   tfunct[1] =
 
1776
{
 
1777
        BFUNC,
 
1778
};
 
1779
 
 
1780
int32   tindir[1] =
 
1781
{
 
1782
        BIND,
 
1783
};
 
1784
 
 
1785
int32   tdot[1] =
 
1786
{
 
1787
        BSTRUCT|BUNION,
 
1788
};
 
1789
 
 
1790
int32   tnot[1] =
 
1791
{
 
1792
        BNUMBER|BIND,
 
1793
};
 
1794
 
 
1795
int32   targ[1] =
 
1796
{
 
1797
        BNUMBER|BIND|BSTRUCT|BUNION,
 
1798
};
 
1799
 
 
1800
uchar   tab[NTYPE][NTYPE] =
 
1801
{
 
1802
/*TXXX*/        { 0,
 
1803
                },
 
1804
 
 
1805
/*TCHAR*/       { 0,    TCHAR, TUCHAR, TSHORT, TUSHORT, TINT, TUINT, TLONG,
 
1806
                        TULONG, TVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND,
 
1807
                },
 
1808
/*TUCHAR*/      { 0,    TUCHAR, TUCHAR, TUSHORT, TUSHORT, TUINT, TUINT, TULONG,
 
1809
                        TULONG, TUVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND,
 
1810
                },
 
1811
/*TSHORT*/      { 0,    TSHORT, TUSHORT, TSHORT, TUSHORT, TINT, TUINT, TLONG,
 
1812
                        TULONG, TVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND,
 
1813
                },
 
1814
/*TUSHORT*/     { 0,    TUSHORT, TUSHORT, TUSHORT, TUSHORT, TUINT, TUINT, TULONG,
 
1815
                        TULONG, TUVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND,
 
1816
                },
 
1817
/*TINT*/        { 0,    TINT, TUINT, TINT, TUINT, TINT, TUINT, TLONG,
 
1818
                        TULONG, TVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND,
 
1819
                },
 
1820
/*TUINT*/       { 0,    TUINT, TUINT, TUINT, TUINT, TUINT, TUINT, TULONG,
 
1821
                        TULONG, TUVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND,
 
1822
                },
 
1823
/*TLONG*/       { 0,    TLONG, TULONG, TLONG, TULONG, TLONG, TULONG, TLONG,
 
1824
                        TULONG, TVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND,
 
1825
                },
 
1826
/*TULONG*/      { 0,    TULONG, TULONG, TULONG, TULONG, TULONG, TULONG, TULONG,
 
1827
                        TULONG, TUVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND,
 
1828
                },
 
1829
/*TVLONG*/      { 0,    TVLONG, TUVLONG, TVLONG, TUVLONG, TVLONG, TUVLONG, TVLONG,
 
1830
                        TUVLONG, TVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND,
 
1831
                },
 
1832
/*TUVLONG*/     { 0,    TUVLONG, TUVLONG, TUVLONG, TUVLONG, TUVLONG, TUVLONG, TUVLONG,
 
1833
                        TUVLONG, TUVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND,
 
1834
                },
 
1835
/*TFLOAT*/      { 0,    TFLOAT, TFLOAT, TFLOAT, TFLOAT, TFLOAT, TFLOAT, TFLOAT,
 
1836
                        TFLOAT, TFLOAT, TFLOAT, TFLOAT, TDOUBLE, TIND,
 
1837
                },
 
1838
/*TDOUBLE*/     { 0,    TDOUBLE, TDOUBLE, TDOUBLE, TDOUBLE, TDOUBLE, TDOUBLE, TDOUBLE,
 
1839
                        TDOUBLE, TDOUBLE, TDOUBLE, TFLOAT, TDOUBLE, TIND,
 
1840
                },
 
1841
/*TIND*/        { 0,    TIND, TIND, TIND, TIND, TIND, TIND, TIND,
 
1842
                         TIND, TIND, TIND, TIND, TIND, TIND,
 
1843
                },
 
1844
};
 
1845
 
 
1846
void
 
1847
urk(char *name, int max, int i)
 
1848
{
 
1849
        if(i >= max) {
 
1850
                fprint(2, "bad tinit: %s %d>=%d\n", name, i, max);
 
1851
                exits("init");
 
1852
        }
 
1853
}
 
1854
 
 
1855
void
 
1856
tinit(void)
 
1857
{
 
1858
        int *ip;
 
1859
        Init *p;
 
1860
 
 
1861
        for(p=thashinit; p->code >= 0; p++) {
 
1862
                urk("thash", nelem(thash), p->code);
 
1863
                thash[p->code] = p->value;
 
1864
        }
 
1865
        for(p=bnamesinit; p->code >= 0; p++) {
 
1866
                urk("bnames", nelem(bnames), p->code);
 
1867
                bnames[p->code] = p->s;
 
1868
        }
 
1869
        for(p=tnamesinit; p->code >= 0; p++) {
 
1870
                urk("tnames", nelem(tnames), p->code);
 
1871
                tnames[p->code] = p->s;
 
1872
        }
 
1873
        for(p=gnamesinit; p->code >= 0; p++) {
 
1874
                urk("gnames", nelem(gnames), p->code);
 
1875
                gnames[p->code] = p->s;
 
1876
        }
 
1877
        for(p=qnamesinit; p->code >= 0; p++) {
 
1878
                urk("qnames", nelem(qnames), p->code);
 
1879
                qnames[p->code] = p->s;
 
1880
        }
 
1881
        for(p=cnamesinit; p->code >= 0; p++) {
 
1882
                urk("cnames", nelem(cnames), p->code);
 
1883
                cnames[p->code] = p->s;
 
1884
        }
 
1885
        for(p=onamesinit; p->code >= 0; p++) {
 
1886
                urk("onames", nelem(onames), p->code);
 
1887
                onames[p->code] = p->s;
 
1888
        }
 
1889
        for(ip=typeiinit; *ip>=0; ip++) {
 
1890
                urk("typei", nelem(typei), *ip);
 
1891
                typei[*ip] = 1;
 
1892
        }
 
1893
        for(ip=typeuinit; *ip>=0; ip++) {
 
1894
                urk("typeu", nelem(typeu), *ip);
 
1895
                typeu[*ip] = 1;
 
1896
        }
 
1897
        for(ip=typesuvinit; *ip>=0; ip++) {
 
1898
                urk("typesuv", nelem(typesuv), *ip);
 
1899
                typesuv[*ip] = 1;
 
1900
        }
 
1901
        for(ip=typeilpinit; *ip>=0; ip++) {
 
1902
                urk("typeilp", nelem(typeilp), *ip);
 
1903
                typeilp[*ip] = 1;
 
1904
        }
 
1905
        for(ip=typechlinit; *ip>=0; ip++) {
 
1906
                urk("typechl", nelem(typechl), *ip);
 
1907
                typechl[*ip] = 1;
 
1908
                typechlv[*ip] = 1;
 
1909
                typechlvp[*ip] = 1;
 
1910
        }
 
1911
        for(ip=typechlpinit; *ip>=0; ip++) {
 
1912
                urk("typechlp", nelem(typechlp), *ip);
 
1913
                typechlp[*ip] = 1;
 
1914
                typechlvp[*ip] = 1;
 
1915
        }
 
1916
        for(ip=typechlpfdinit; *ip>=0; ip++) {
 
1917
                urk("typechlpfd", nelem(typechlpfd), *ip);
 
1918
                typechlpfd[*ip] = 1;
 
1919
        }
 
1920
        for(ip=typecinit; *ip>=0; ip++) {
 
1921
                urk("typec", nelem(typec), *ip);
 
1922
                typec[*ip] = 1;
 
1923
        }
 
1924
        for(ip=typehinit; *ip>=0; ip++) {
 
1925
                urk("typeh", nelem(typeh), *ip);
 
1926
                typeh[*ip] = 1;
 
1927
        }
 
1928
        for(ip=typeilinit; *ip>=0; ip++) {
 
1929
                urk("typeil", nelem(typeil), *ip);
 
1930
                typeil[*ip] = 1;
 
1931
        }
 
1932
        for(ip=typevinit; *ip>=0; ip++) {
 
1933
                urk("typev", nelem(typev), *ip);
 
1934
                typev[*ip] = 1;
 
1935
                typechlv[*ip] = 1;
 
1936
                typechlvp[*ip] = 1;
 
1937
        }
 
1938
        for(ip=typefdinit; *ip>=0; ip++) {
 
1939
                urk("typefd", nelem(typefd), *ip);
 
1940
                typefd[*ip] = 1;
 
1941
        }
 
1942
        for(ip=typeafinit; *ip>=0; ip++) {
 
1943
                urk("typeaf", nelem(typeaf), *ip);
 
1944
                typeaf[*ip] = 1;
 
1945
        }
 
1946
        for(ip=typesuinit; *ip >= 0; ip++) {
 
1947
                urk("typesu", nelem(typesu), *ip);
 
1948
                typesu[*ip] = 1;
 
1949
        }
 
1950
        for(p=tasigninit; p->code >= 0; p++) {
 
1951
                urk("tasign", nelem(tasign), p->code);
 
1952
                tasign[p->code] = p->value;
 
1953
        }
 
1954
        for(p=tasaddinit; p->code >= 0; p++) {
 
1955
                urk("tasadd", nelem(tasadd), p->code);
 
1956
                tasadd[p->code] = p->value;
 
1957
        }
 
1958
        for(p=tcastinit; p->code >= 0; p++) {
 
1959
                urk("tcast", nelem(tcast), p->code);
 
1960
                tcast[p->code] = p->value;
 
1961
        }
 
1962
        for(p=taddinit; p->code >= 0; p++) {
 
1963
                urk("tadd", nelem(tadd), p->code);
 
1964
                tadd[p->code] = p->value;
 
1965
        }
 
1966
        for(p=tsubinit; p->code >= 0; p++) {
 
1967
                urk("tsub", nelem(tsub), p->code);
 
1968
                tsub[p->code] = p->value;
 
1969
        }
 
1970
        for(p=tmulinit; p->code >= 0; p++) {
 
1971
                urk("tmul", nelem(tmul), p->code);
 
1972
                tmul[p->code] = p->value;
 
1973
        }
 
1974
        for(p=tandinit; p->code >= 0; p++) {
 
1975
                urk("tand", nelem(tand), p->code);
 
1976
                tand[p->code] = p->value;
 
1977
        }
 
1978
        for(p=trelinit; p->code >= 0; p++) {
 
1979
                urk("trel", nelem(trel), p->code);
 
1980
                trel[p->code] = p->value;
 
1981
        }
 
1982
        
 
1983
        /* 32-bit defaults */
 
1984
        typeword = typechlp;
 
1985
        typecmplx = typesuv;
 
1986
}
 
1987
 
 
1988
/*
 
1989
 * return 1 if it is impossible to jump into the middle of n.
 
1990
 */
 
1991
static int
 
1992
deadhead(Node *n, int caseok)
 
1993
{
 
1994
loop:
 
1995
        if(n == Z)
 
1996
                return 1;
 
1997
        switch(n->op) {
 
1998
        case OLIST:
 
1999
                if(!deadhead(n->left, caseok))
 
2000
                        return 0;
 
2001
        rloop:
 
2002
                n = n->right;
 
2003
                goto loop;
 
2004
 
 
2005
        case ORETURN:
 
2006
                break;
 
2007
 
 
2008
        case OLABEL:
 
2009
                return 0;
 
2010
 
 
2011
        case OGOTO:
 
2012
                break;
 
2013
 
 
2014
        case OCASE:
 
2015
                if(!caseok)
 
2016
                        return 0;
 
2017
                goto rloop;
 
2018
 
 
2019
        case OSWITCH:
 
2020
                return deadhead(n->right, 1);
 
2021
 
 
2022
        case OWHILE:
 
2023
        case ODWHILE:
 
2024
                goto rloop;
 
2025
 
 
2026
        case OFOR:
 
2027
                goto rloop;
 
2028
 
 
2029
        case OCONTINUE:
 
2030
                break;
 
2031
 
 
2032
        case OBREAK:
 
2033
                break;
 
2034
 
 
2035
        case OIF:
 
2036
                return deadhead(n->right->left, caseok) && deadhead(n->right->right, caseok);
 
2037
 
 
2038
        case OSET:
 
2039
        case OUSED:
 
2040
                break;
 
2041
        }
 
2042
        return 1;
 
2043
}
 
2044
 
 
2045
int
 
2046
deadheads(Node *c)
 
2047
{
 
2048
        return deadhead(c->left, 0) && deadhead(c->right, 0);
 
2049
}
 
2050
 
 
2051
int
 
2052
mixedasop(Type *l, Type *r)
 
2053
{
 
2054
        return !typefd[l->etype] && typefd[r->etype];
 
2055
}